1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.mediaframeworktest.functional.videoeditor; 18 19 import java.io.File; 20 import java.io.IOException; 21 import java.util.List; 22 import java.util.concurrent.Semaphore; 23 24 import android.graphics.Bitmap; 25 import android.graphics.Rect; 26 import android.media.videoeditor.AudioTrack; 27 import android.media.videoeditor.Effect; 28 import android.media.videoeditor.EffectColor; 29 import android.media.videoeditor.EffectKenBurns; 30 import android.media.videoeditor.MediaImageItem; 31 import android.media.videoeditor.MediaItem; 32 import android.media.videoeditor.MediaProperties; 33 import android.media.videoeditor.MediaVideoItem; 34 import android.media.videoeditor.Overlay; 35 import android.media.videoeditor.OverlayFrame; 36 import android.media.videoeditor.Transition; 37 import android.media.videoeditor.TransitionAlpha; 38 import android.media.videoeditor.TransitionCrossfade; 39 import android.media.videoeditor.TransitionFadeBlack; 40 import android.media.videoeditor.TransitionSliding; 41 import android.media.videoeditor.VideoEditor; 42 import android.media.videoeditor.VideoEditor.ExportProgressListener; 43 import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener; 44 import android.media.videoeditor.VideoEditor.PreviewProgressListener; 45 import android.media.videoeditor.VideoEditor.OverlayData; 46 import android.os.Environment; 47 import android.test.ActivityInstrumentationTestCase; 48 import android.view.SurfaceHolder; 49 50 51 import com.android.mediaframeworktest.MediaFrameworkTest; 52 import android.test.suitebuilder.annotation.LargeTest; 53 import com.android.mediaframeworktest.VideoEditorHelper; 54 55 import android.os.Handler; 56 import android.os.Looper; 57 import android.os.Message; 58 59 import java.util.concurrent.TimeUnit; 60 61 import android.util.Log; 62 63 public class VideoEditorPreviewTest extends 64 ActivityInstrumentationTestCase<MediaFrameworkTest> { 65 private final String TAG = "VideoEditorTest"; 66 67 private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON; 68 69 private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON; 70 71 private final String PROJECT_CLASS_NAME = 72 "android.media.videoeditor.VideoEditorImpl"; 73 74 private VideoEditor mVideoEditor; 75 76 private VideoEditorHelper mVideoEditorHelper; 77 78 private class EventHandler extends Handler { 79 public EventHandler( Looper lp) 80 { 81 super(lp); 82 } 83 public void handleMessage(Message msg) 84 { 85 switch (msg.what) 86 { 87 default: 88 MediaFrameworkTest.testInvalidateOverlay(); 89 } 90 } 91 } 92 private EventHandler mEventHandler; 93 94 private boolean previewStart; 95 private boolean previewStop; 96 private boolean previewError; 97 98 /* Minimum waiting time for Semaphore to wait for release */ 99 private final long minWaitingTime = 3000; 100 101 // Declares the annotation for Preview Test Cases 102 public @interface Preview { 103 } 104 105 public VideoEditorPreviewTest() { 106 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 107 108 Looper looper; 109 if ((looper = Looper.myLooper()) != null) { 110 mEventHandler = new EventHandler(looper); 111 112 } else { 113 //Handle error when looper can not be created. 114 ; 115 } 116 } 117 118 @Override 119 protected void setUp() throws Exception { 120 // setup for each test case. 121 super.setUp(); 122 mVideoEditorHelper = new VideoEditorHelper(); 123 // Create a random String which will be used as project path, where all 124 // project related files will be stored. 125 final String projectPath = 126 mVideoEditorHelper.createRandomFile(PROJECT_LOCATION); 127 mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath); 128 } 129 130 @Override 131 protected void tearDown() throws Exception { 132 mVideoEditorHelper.destroyVideoEditor(mVideoEditor); 133 // Clean the directory created as project path 134 mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath())); 135 System.gc(); 136 super.tearDown(); 137 } 138 139 protected void setPreviewStart() { 140 previewStart = true; 141 } 142 protected void setPreviewStop() { 143 previewStop = true; 144 } 145 protected void setPreviewError() { 146 previewError = true; 147 } 148 protected void validatePreviewProgress(int startMs, int endMs, 149 boolean loop, long duration) throws Exception { 150 151 final int[] progressUpdate = new int[100]; 152 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 153 previewStart = false; 154 previewStop = false; 155 previewError = false; 156 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 157 int i = 0; 158 public void onProgress(Object item, int action, int progress) { 159 progressUpdate[i++] = progress; 160 } 161 }); 162 mVideoEditorHelper.checkProgressCBValues(progressUpdate); 163 final SurfaceHolder surfaceHolder = 164 MediaFrameworkTest.mSurfaceView.getHolder(); 165 166 long waitingTime = minWaitingTime; 167 if (endMs == -1) { 168 waitingTime += duration; 169 } 170 else { 171 waitingTime += (endMs - startMs); 172 } 173 blockTillPreviewCompletes.acquire(); 174 try { 175 mVideoEditor.startPreview(surfaceHolder, startMs, endMs, loop, 1, 176 new PreviewProgressListener() { 177 public void onProgress(VideoEditor videoEditor, long timeMs, 178 OverlayData overlayData) { 179 180 if ( overlayData != null) { 181 if(overlayData.needsRendering()) { 182 overlayData.renderOverlay(MediaFrameworkTest.mDestBitmap); 183 mEventHandler.sendMessage(mEventHandler.obtainMessage(1, 2, 3)); 184 } 185 } 186 } 187 public void onStart(VideoEditor videoEditor) { 188 setPreviewStart(); 189 } 190 public void onStop(VideoEditor videoEditor) { 191 setPreviewStop(); 192 blockTillPreviewCompletes.release(); 193 } 194 public void onError(VideoEditor videoEditor, int error) { 195 setPreviewError(); 196 blockTillPreviewCompletes.release(); 197 } 198 }); 199 } catch (Exception e) { 200 blockTillPreviewCompletes.release(); 201 } 202 blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS); 203 204 mVideoEditor.stopPreview(); 205 assertTrue("Preview Failed to start", previewStart); 206 assertTrue("Preview Failed to stop", previewStop); 207 assertFalse("Preview Error occurred", previewError); 208 209 blockTillPreviewCompletes.release(); 210 } 211 212 // ----------------------------------------------------------------- 213 // Preview 214 // ----------------------------------------------------------------- 215 216 /** 217 *To test Preview : FULL Preview of current work (beginning till end) 218 */ 219 @LargeTest 220 public void testPreviewTheStoryBoard() throws Exception { 221 final String videoItemFileName1 = INPUT_FILE_PATH 222 + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4"; 223 final String videoItemFileName2 = INPUT_FILE_PATH 224 + "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4"; 225 final String videoItemFileName3 = INPUT_FILE_PATH 226 + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp"; 227 previewStart = false; 228 previewStop = false; 229 final MediaVideoItem mediaVideoItem1 = 230 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1", 231 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 232 mediaVideoItem1.setExtractBoundaries(0, 10000); 233 mVideoEditor.addMediaItem(mediaVideoItem1); 234 235 final MediaVideoItem mediaVideoItem2 = 236 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2", 237 videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER); 238 mVideoEditor.addMediaItem(mediaVideoItem2); 239 mediaVideoItem2.setExtractBoundaries(0, 10000); 240 241 final MediaVideoItem mediaVideoItem3 = 242 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3", 243 videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER); 244 mediaVideoItem3.setExtractBoundaries(0, 10000); 245 246 mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId()); 247 List<MediaItem> mediaList = mVideoEditor.getAllMediaItems(); 248 assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0)); 249 assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1)); 250 assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2)); 251 252 mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER); 253 assertEquals("Media Item 1 Rendering Mode", 254 MediaItem.RENDERING_MODE_BLACK_BORDER, 255 mediaVideoItem1.getRenderingMode()); 256 257 mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER); 258 assertEquals("Media Item 2 Rendering Mode", 259 MediaItem.RENDERING_MODE_BLACK_BORDER, 260 mediaVideoItem2.getRenderingMode()); 261 262 mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH); 263 assertEquals("Media Item 3 Rendering Mode", 264 MediaItem.RENDERING_MODE_STRETCH, 265 mediaVideoItem3.getRenderingMode()); 266 267 mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3); 268 assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3, 269 mVideoEditor.getAspectRatio()); 270 271 validatePreviewProgress(0, -1, false, mVideoEditor.getDuration()); 272 } 273 274 /** 275 * To test Preview : Preview of start + 10 sec till end of story board 276 */ 277 @LargeTest 278 public void testPreviewTheStoryBoardFromDuration() throws Exception { 279 final String videoItemFileName1 = INPUT_FILE_PATH 280 + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4"; 281 final String videoItemFileName2 = INPUT_FILE_PATH + 282 "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4"; 283 final String videoItemFileName3 = INPUT_FILE_PATH 284 + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp"; 285 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 286 previewStart = false; 287 previewStop = false; 288 final MediaVideoItem mediaVideoItem1 = 289 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1", 290 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 291 mediaVideoItem1.setExtractBoundaries(0, 10000); 292 mVideoEditor.addMediaItem(mediaVideoItem1); 293 294 final MediaVideoItem mediaVideoItem2 = 295 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2", 296 videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER); 297 mediaVideoItem2.setExtractBoundaries(0, 10000); 298 mVideoEditor.addMediaItem(mediaVideoItem2); 299 300 final MediaVideoItem mediaVideoItem3 = 301 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3", 302 videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER); 303 mediaVideoItem3.setExtractBoundaries(0, 10000); 304 305 mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId()); 306 307 List<MediaItem> mediaList = mVideoEditor.getAllMediaItems(); 308 assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0)); 309 assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1)); 310 assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2)); 311 mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER); 312 313 assertEquals("Media Item 1 Rendering Mode", 314 MediaItem.RENDERING_MODE_BLACK_BORDER, 315 mediaVideoItem1.getRenderingMode()); 316 mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER); 317 318 assertEquals("Media Item 2 Rendering Mode", 319 MediaItem.RENDERING_MODE_BLACK_BORDER, 320 mediaVideoItem2.getRenderingMode()); 321 mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH); 322 323 assertEquals("Media Item 3 Rendering Mode", 324 MediaItem.RENDERING_MODE_STRETCH, 325 mediaVideoItem3.getRenderingMode()); 326 327 mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3); 328 assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3, 329 mVideoEditor.getAspectRatio()); 330 331 validatePreviewProgress(10000, -1, false, mVideoEditor.getDuration()); 332 } 333 334 /** 335 * To test Preview : Preview of current Effects applied 336 */ 337 @LargeTest 338 public void testPreviewOfEffects() throws Exception { 339 final String videoItemFileName1 = INPUT_FILE_PATH + 340 "H264_BP_640x480_30fps_256kbps_1_17.mp4"; 341 342 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 343 previewStart = false; 344 previewStop = false; 345 final MediaVideoItem mediaVideoItem1 = 346 mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1", 347 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 348 mVideoEditor.addMediaItem(mediaVideoItem1); 349 350 final EffectColor effectNegative = 351 mVideoEditorHelper.createEffectItem(mediaVideoItem1, 352 "effectNegative", 0, 2000, EffectColor.TYPE_NEGATIVE, 0); 353 mediaVideoItem1.addEffect(effectNegative); 354 355 final EffectColor effectGreen = 356 mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effectGreen", 357 2000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN); 358 mediaVideoItem1.addEffect(effectGreen); 359 360 final EffectColor effectFifties = 361 mVideoEditorHelper.createEffectItem(mediaVideoItem1, 362 "effectFifties", 5000, 4000, EffectColor.TYPE_FIFTIES, 0); 363 mediaVideoItem1.addEffect(effectFifties); 364 365 List<Effect> effectList = mediaVideoItem1.getAllEffects(); 366 assertEquals("Effect List Size", 3, effectList.size()); 367 assertEquals("Effect negative", effectNegative, effectList.get(0)); 368 assertEquals("Effect Green", effectGreen, effectList.get(1)); 369 assertEquals("Effect Fifties", effectFifties, effectList.get(2)); 370 371 mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3); 372 assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_4_3, 373 mVideoEditor.getAspectRatio()); 374 375 final long storyboardDuration = mVideoEditor.getDuration() ; 376 validatePreviewProgress(0, (int)(storyboardDuration/2), false, (storyboardDuration/2)); 377 378 assertEquals("Removing Effect : Negative", effectNegative, 379 mediaVideoItem1.removeEffect(effectNegative.getId())); 380 381 effectList = mediaVideoItem1.getAllEffects(); 382 383 assertEquals("Effect List Size", 2, effectList.size()); 384 assertEquals("Effect Green", effectGreen, effectList.get(0)); 385 assertEquals("Effect Fifties", effectFifties, effectList.get(1)); 386 387 validatePreviewProgress(0, -1, false, mVideoEditor.getDuration()); 388 } 389 390 /** 391 *To test Preview : Preview of current Transitions applied (with multiple 392 * generatePreview) 393 */ 394 @LargeTest 395 public void testPreviewWithTransition() throws Exception { 396 397 final String videoItemFileName1 = INPUT_FILE_PATH + 398 "H263_profile0_176x144_10fps_96kbps_0_25.3gp"; 399 final String imageItemFileName1 = INPUT_FILE_PATH + 400 "IMG_1600x1200.jpg"; 401 final String videoItemFileName2 = INPUT_FILE_PATH + 402 "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4"; 403 final String maskFilename = INPUT_FILE_PATH + 404 "TransitionSpiral_QVGA.jpg"; 405 previewStart = false; 406 previewStop = false; 407 previewError = false; 408 409 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 410 411 final MediaVideoItem mediaVideoItem1 = 412 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 413 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 414 mediaVideoItem1.setExtractBoundaries(0, 10000); 415 mVideoEditor.addMediaItem(mediaVideoItem1); 416 417 final MediaImageItem mediaImageItem1 = 418 mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", 419 imageItemFileName1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER); 420 mVideoEditor.addMediaItem(mediaImageItem1); 421 422 final MediaVideoItem mediaVideoItem2 = 423 mVideoEditorHelper.createMediaItem(mVideoEditor, "m3", 424 videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER); 425 mediaVideoItem2.setExtractBoundaries(0, 10000); 426 mVideoEditor.addMediaItem(mediaVideoItem2); 427 428 final TransitionCrossfade transition1And2CrossFade = 429 mVideoEditorHelper.createTCrossFade("transition_1_2_CF", 430 mediaVideoItem1, mediaImageItem1, 2000, 431 Transition.BEHAVIOR_MIDDLE_FAST); 432 mVideoEditor.addTransition(transition1And2CrossFade); 433 434 final TransitionAlpha transition2And3Alpha = 435 mVideoEditorHelper.createTAlpha("transition_2_3", mediaImageItem1, 436 mediaVideoItem2, 4000, Transition.BEHAVIOR_SPEED_UP, 437 maskFilename, 50, true); 438 mVideoEditor.addTransition(transition2And3Alpha); 439 440 final TransitionFadeBlack transition1FadeBlack = 441 mVideoEditorHelper.createTFadeBlack("transition_1FB", null, 442 mediaVideoItem1, 2000, Transition.BEHAVIOR_MIDDLE_FAST); 443 mVideoEditor.addTransition(transition1FadeBlack); 444 445 List<Transition> transitionList = mVideoEditor.getAllTransitions(); 446 assertEquals("Transition List Size", 3, transitionList.size()); 447 assertEquals("Transition 1", transition1And2CrossFade, 448 transitionList.get(0)); 449 assertEquals("Transition 2", transition2And3Alpha, transitionList.get(1)); 450 assertEquals("Transition 3", transition1FadeBlack, transitionList.get(2)); 451 452 mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_3_2); 453 454 final int[] progressValues = new int[300]; 455 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 456 int i = 0; 457 458 public void onProgress(Object item, int action, int progress) { 459 if (item instanceof TransitionCrossfade) { 460 progressValues[i] = progress; 461 assertEquals("Object", item, transition1And2CrossFade); 462 assertEquals("Action", action, 463 MediaProcessingProgressListener.ACTION_ENCODE); 464 } else if (item instanceof TransitionAlpha) { 465 progressValues[i] = progress; 466 assertEquals("Object", item, transition2And3Alpha); 467 assertEquals("Action", action, 468 MediaProcessingProgressListener.ACTION_ENCODE); 469 } else if (item instanceof TransitionFadeBlack) { 470 progressValues[i] = progress; 471 assertEquals("Object", item, transition1FadeBlack); 472 assertEquals("Action", action, 473 MediaProcessingProgressListener.ACTION_ENCODE); 474 } 475 i++; 476 } 477 }); 478 479 mVideoEditorHelper.checkProgressCBValues(progressValues); 480 final SurfaceHolder surfaceHolder = 481 MediaFrameworkTest.mSurfaceView.getHolder(); 482 /* As transition takes more time buffer of 10 sec is added */ 483 long waitingTime = minWaitingTime + 10000 + 10000; 484 485 blockTillPreviewCompletes.acquire(); 486 try { 487 mVideoEditor.startPreview(surfaceHolder, 0, 10000, false, 1, 488 new PreviewProgressListener() { 489 public void onProgress(VideoEditor videoEditor, long timeMs, 490 OverlayData overlayData) { 491 } 492 public void onStart(VideoEditor videoEditor) { 493 setPreviewStart(); 494 } 495 public void onStop(VideoEditor videoEditor) { 496 setPreviewStop(); 497 blockTillPreviewCompletes.release(); 498 } 499 public void onError(VideoEditor videoEditor, int error) { 500 setPreviewError(); 501 blockTillPreviewCompletes.release(); 502 } 503 }); 504 } catch (Exception e) { 505 blockTillPreviewCompletes.release(); 506 } 507 blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS); 508 mVideoEditor.stopPreview(); 509 blockTillPreviewCompletes.release(); 510 assertTrue("Preview Failed to start", previewStart); 511 assertTrue("Preview Failed to stop", previewStop); 512 assertFalse("Preview Error occurred", previewError); 513 514 assertEquals("Removing Transition " + transition1And2CrossFade.getId(), 515 transition1And2CrossFade, 516 mVideoEditor.removeTransition(transition1And2CrossFade.getId())); 517 transitionList = mVideoEditor.getAllTransitions(); 518 assertEquals("Transition List Size", 2, transitionList.size()); 519 assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0)); 520 assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1)); 521 522 validatePreviewProgress(0, -1, false, mVideoEditor.getDuration()); 523 524 525 final TransitionSliding transition1And2Sliding = 526 mVideoEditorHelper.createTSliding("transition_1_2Sliding", 527 mediaVideoItem1, mediaImageItem1, 4000, 528 Transition.BEHAVIOR_MIDDLE_FAST, 529 TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN); 530 mVideoEditor.addTransition(transition1And2Sliding); 531 532 transitionList = mVideoEditor.getAllTransitions(); 533 assertEquals("Transition List Size", 3, transitionList.size()); 534 assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0)); 535 assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1)); 536 assertEquals("Transition 3", transition1And2Sliding, 537 transitionList.get(2)); 538 539 validatePreviewProgress(5000, -1, false, (mVideoEditor.getDuration())); 540 541 } 542 543 /** 544 * To test Preview : Preview of current Overlay applied 545 */ 546 @LargeTest 547 public void testPreviewWithOverlay() throws Exception { 548 final String videoItemFileName = INPUT_FILE_PATH 549 + "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp"; 550 final String overlayFilename1 = INPUT_FILE_PATH + 551 "IMG_640x480_Overlay1.png"; 552 final String overlayFilename2 = INPUT_FILE_PATH + 553 "IMG_640x480_Overlay2.png"; 554 final int previewFrom = 5000; 555 final int previewTo = 10000; 556 final boolean previewLoop = false; 557 final int previewCallbackFrameCount = 1; 558 final int setAspectRatio = MediaProperties.ASPECT_RATIO_4_3; 559 final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; 560 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 561 previewStart = false; 562 previewStop = false; 563 boolean flagForException = false; 564 final MediaVideoItem mediaVideoItem = 565 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 566 videoItemFileName, renderingMode); 567 mVideoEditor.addMediaItem(mediaVideoItem); 568 mediaVideoItem.setExtractBoundaries(0, 10000); 569 570 final Bitmap mBitmap1 = mVideoEditorHelper.getBitmap(overlayFilename1, 571 640, 480); 572 final OverlayFrame overlayOnMvi1 = 573 mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi1", 574 mBitmap1, 0, 5000); 575 mediaVideoItem.addOverlay(overlayOnMvi1); 576 577 final Bitmap mBitmap2 = mVideoEditorHelper.getBitmap(overlayFilename2, 578 640, 480); 579 final OverlayFrame overlayOnMvi2 = 580 mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi2", 581 mBitmap2, 5000, 9000); 582 mediaVideoItem.addOverlay(overlayOnMvi2); 583 584 List<Overlay> overlayList = mediaVideoItem.getAllOverlays(); 585 assertEquals("Overlay Size", 2, overlayList.size()); 586 assertEquals("Overlay 1", overlayOnMvi1, overlayList.get(0)); 587 assertEquals("Overlay 2", overlayOnMvi2, overlayList.get(1)); 588 589 mVideoEditor.setAspectRatio(setAspectRatio); 590 591 validatePreviewProgress(0 /* previewFrom */, -1, previewLoop, 592 mVideoEditor.getDuration()); 593 } 594 595 /** 596 * To test Preview : Preview of current Trim applied (with default aspect 597 * ratio) 598 */ 599 @LargeTest 600 public void testPreviewWithTrim() throws Exception { 601 final String videoItemFileName = INPUT_FILE_PATH + 602 "H264_BP_640x480_30fps_192kbps_1_5.mp4"; 603 final MediaVideoItem mediaVideoItem = 604 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 605 videoItemFileName, MediaItem.RENDERING_MODE_CROPPING); 606 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 607 boolean flagForException = false; 608 previewStart = false; 609 previewStop = false; 610 mediaVideoItem.setExtractBoundaries(mediaVideoItem.getDuration() / 2, 611 mediaVideoItem.getDuration()); 612 mVideoEditor.addMediaItem(mediaVideoItem); 613 614 validatePreviewProgress(1000, -1, false, mVideoEditor.getDuration()); 615 } 616 617 /** 618 * To test Preview : Preview of current work having Overlay and Effect 619 * applied 620 */ 621 622 @LargeTest 623 public void testPreviewWithOverlayEffectKenBurn() throws Exception { 624 625 final String videoItemFileName = INPUT_FILE_PATH + 626 "H264_BP_640x480_30fps_192kbps_1_5.mp4"; 627 final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg"; 628 final String videoItemFileName1 = INPUT_FILE_PATH + 629 "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4"; 630 final String overlayFilename = INPUT_FILE_PATH + 631 "IMG_640x480_Overlay1.png"; 632 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 633 previewStart = false; 634 previewStop = false; 635 final MediaVideoItem mediaVideoItem1 = 636 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 637 videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER); 638 mVideoEditor.addMediaItem(mediaVideoItem1); 639 640 final MediaImageItem mediaImageItem2 = 641 mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", 642 imageItemFileName, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER); 643 mVideoEditor.addMediaItem(mediaImageItem2); 644 645 final MediaVideoItem mediaVideoItem3 = 646 mVideoEditorHelper.createMediaItem(mVideoEditor, "m3", 647 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 648 mVideoEditor.addMediaItem(mediaVideoItem3); 649 650 final EffectColor effectColor = 651 mVideoEditorHelper.createEffectItem(mediaVideoItem1, "Effect1", 652 1000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN); 653 mediaVideoItem1.addEffect(effectColor); 654 655 final Rect startRect = new Rect((mediaImageItem2.getHeight() / 3), 656 (mediaImageItem2.getWidth() / 3), (mediaImageItem2.getHeight() / 2), 657 (mediaImageItem2.getWidth() / 2)); 658 final Rect endRect = new Rect(0, 0, mediaImageItem2.getWidth(), 659 mediaImageItem2.getHeight()); 660 661 final EffectKenBurns kbeffectOnMI2 = new EffectKenBurns(mediaImageItem2, 662 "KBOnM2", startRect, endRect, 0, 10000); 663 assertNotNull("EffectKenBurns", kbeffectOnMI2); 664 mediaImageItem2.addEffect(kbeffectOnMI2); 665 666 final Bitmap mBitmap = mVideoEditorHelper.getBitmap(overlayFilename, 667 640, 480); 668 final OverlayFrame overlayFrame = 669 mVideoEditorHelper.createOverlay(mediaVideoItem3, "OverlayID", 670 mBitmap, (mediaImageItem2.getDuration() / 4), 671 (mediaVideoItem3.getDuration() / 3)); 672 mediaVideoItem3.addOverlay(overlayFrame); 673 674 validatePreviewProgress(5000, -1, false, mVideoEditor.getDuration()); 675 } 676 677 /** 678 *To test Preview : Export during preview 679 */ 680 @LargeTest 681 public void testPreviewDuringExport() throws Exception { 682 final String videoItemFileName = INPUT_FILE_PATH + 683 "H264_BP_640x480_30fps_192kbps_1_5.mp4"; 684 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 685 previewStart = false; 686 previewStop = false; 687 previewError = false; 688 689 final MediaVideoItem mediaVideoItem1 = 690 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 691 videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER); 692 mediaVideoItem1.setExtractBoundaries(0, 20000); 693 mVideoEditor.addMediaItem(mediaVideoItem1); 694 695 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 696 public void onProgress(Object item, int action, int progress) { 697 } 698 }); 699 700 long waitingTime = minWaitingTime + mVideoEditor.getDuration(); 701 702 703 blockTillPreviewCompletes.acquire(); 704 final String fileName = mVideoEditor.getPath() + "/test.3gp"; 705 final int height = MediaProperties.HEIGHT_480; 706 final int bitrate = MediaProperties.BITRATE_512K; 707 708 try { 709 mVideoEditor.export(fileName, height, bitrate, 710 new ExportProgressListener() { 711 public void onProgress(VideoEditor ve, 712 String outFileName,int progress) { 713 714 } 715 }); 716 } catch (IOException e) { 717 assertTrue("UnExpected Error in Export" + 718 e.toString(), false); 719 } 720 721 final SurfaceHolder surfaceHolder = 722 MediaFrameworkTest.mSurfaceView.getHolder(); 723 try { 724 725 mVideoEditor.startPreview(surfaceHolder, 5000, -1, false, 1, 726 new PreviewProgressListener() { 727 728 public void onProgress(VideoEditor videoEditor, long timeMs, 729 OverlayData overlayData) { 730 } 731 public void onStart(VideoEditor videoEditor) { 732 setPreviewStart(); 733 } 734 public void onStop(VideoEditor videoEditor) { 735 setPreviewStop(); 736 blockTillPreviewCompletes.release(); 737 } 738 public void onError(VideoEditor videoEditor, int error) { 739 setPreviewError(); 740 blockTillPreviewCompletes.release(); 741 } 742 }); 743 744 } catch (Exception e) { 745 blockTillPreviewCompletes.release(); 746 } 747 blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS); 748 mVideoEditor.stopPreview(); 749 assertTrue("Preview Failed to start", previewStart); 750 assertTrue("Preview Failed to stop", previewStop); 751 assertFalse("Preview Error occurred", previewError); 752 753 blockTillPreviewCompletes.release(); 754 } 755 756 /** 757 * To test Preview : Preview of current Effects applied (with from time > 758 * total duration) 759 */ 760 @LargeTest 761 public void testPreviewWithDurationGreaterThanMediaDuration() 762 throws Exception { 763 final String videoItemFileName = INPUT_FILE_PATH + 764 "H264_BP_640x480_30fps_192kbps_1_5.mp4"; 765 final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER; 766 boolean flagForException = false; 767 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 768 769 final MediaVideoItem mediaVideoItem1 = 770 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 771 videoItemFileName, renderingMode); 772 try { 773 mediaVideoItem1.setExtractBoundaries(0, 20000); 774 } catch (Exception e) { 775 assertTrue("Exception during setExtract Boundaries", false); 776 } 777 mVideoEditor.addMediaItem(mediaVideoItem1); 778 final SurfaceHolder surfaceHolder = 779 MediaFrameworkTest.mSurfaceView.getHolder(); 780 long waitingTime = minWaitingTime + (mVideoEditor.getDuration() - 30000); 781 if(waitingTime < 0) 782 { 783 waitingTime = minWaitingTime; 784 } 785 786 blockTillPreviewCompletes.acquire(); 787 try { 788 mVideoEditor.startPreview(surfaceHolder, 30000, -1, true, 1, 789 new PreviewProgressListener() { 790 public void onProgress(VideoEditor videoEditor, long timeMs, 791 OverlayData overlayData) { 792 } 793 public void onStart(VideoEditor videoEditor) { 794 setPreviewStart(); 795 } 796 public void onStop(VideoEditor videoEditor) { 797 setPreviewStop(); 798 blockTillPreviewCompletes.release(); 799 } 800 public void onError(VideoEditor videoEditor, int error) { 801 setPreviewError(); 802 blockTillPreviewCompletes.release(); 803 } 804 }); 805 806 } catch (IllegalArgumentException e) { 807 blockTillPreviewCompletes.release(); 808 flagForException = true; 809 } 810 blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS); 811 assertTrue("Expected Error in Preview", flagForException); 812 mVideoEditor.stopPreview(); 813 blockTillPreviewCompletes.release(); 814 } 815 816 /** 817 * To test Preview : Preview of current Effects applied (with Render Preview 818 * Frame) 819 */ 820 @LargeTest 821 public void testPreviewWithRenderPreviewFrame() throws Exception { 822 final String videoItemFileName = INPUT_FILE_PATH + 823 "H264_BP_640x480_30fps_256kbps_1_17.mp4"; 824 final Semaphore blockTillPreviewCompletes = new Semaphore(1); 825 boolean flagForException = false; 826 OverlayData overlayData1 = new OverlayData(); 827 previewStart = false; 828 previewStop = false; 829 830 final String overlayFilename1 = INPUT_FILE_PATH + 831 "IMG_640x480_Overlay1.png"; 832 833 final MediaVideoItem mediaVideoItem = 834 mVideoEditorHelper.createMediaItem(mVideoEditor, 835 "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER); 836 mVideoEditor.addMediaItem(mediaVideoItem); 837 838 final EffectColor effectPink = 839 mVideoEditorHelper.createEffectItem(mediaVideoItem, 840 "effectNegativeOnMvi", 1000, 3000, EffectColor.TYPE_COLOR, 841 EffectColor.PINK); 842 mediaVideoItem.addEffect(effectPink); 843 844 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 845 public void onProgress(Object item, int action, int progress) { 846 } 847 }); 848 final SurfaceHolder surfaceHolder = 849 MediaFrameworkTest.mSurfaceView.getHolder(); 850 851 assertEquals("Render preview Frame at 5 Sec", 5000, 852 mVideoEditor.renderPreviewFrame(surfaceHolder, 5000, 853 overlayData1)); 854 855 assertEquals("Render preview Frame at 7 Sec", 7000, 856 mVideoEditor.renderPreviewFrame(surfaceHolder, 7000, 857 overlayData1)); 858 859 validatePreviewProgress(5000, -1, false, mVideoEditor.getDuration()); 860 } 861 862 /** 863 * To test Preview : Preview of current work from selected jump location 864 * till end with Audio Track 865 */ 866 @LargeTest 867 public void testPreviewWithEndAudioTrack() throws Exception { 868 final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg"; 869 final String videoItemFileName = INPUT_FILE_PATH + 870 "H264_BP_640x480_30fps_256kbps_1_17.mp4"; 871 final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_640x480.jpg"; 872 final String audioFilename = INPUT_FILE_PATH + 873 "AMRNB_8KHz_12.2Kbps_m_1_17.3gp"; 874 875 boolean flagForException = false; 876 previewStart = false; 877 previewStop = false; 878 final MediaImageItem mediaImageItem1 = 879 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 880 imageItemFilename1, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER); 881 mVideoEditor.addMediaItem(mediaImageItem1); 882 883 final MediaVideoItem mediaVideoItem = 884 mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", 885 videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER); 886 mediaVideoItem.setExtractBoundaries(1000, 8000); 887 mVideoEditor.addMediaItem(mediaVideoItem); 888 889 final MediaImageItem mediaImageItem2 = 890 mVideoEditorHelper.createMediaItem(mVideoEditor, "m3", 891 imageItemFilename2, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER); 892 mVideoEditor.addMediaItem(mediaImageItem2); 893 894 final AudioTrack audioTrack = 895 mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename); 896 mVideoEditor.addAudioTrack(audioTrack); 897 898 List<AudioTrack> audioList = mVideoEditor.getAllAudioTracks(); 899 assertEquals("Audio Track List size", 1, audioList.size()); 900 assertEquals("Audio Track", audioTrack, audioList.get(0)); 901 mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3); 902 903 validatePreviewProgress(10000, -1, false, mVideoEditor.getDuration()); 904 } 905 906 /** 907 * To test render Preview Frame 908 */ 909 @LargeTest 910 public void testRenderPreviewFrame() throws Exception { 911 final String videoItemFileName1 = INPUT_FILE_PATH 912 + "H264_BP_1080x720_30fps_800kbps_1_17.mp4"; 913 final String videoItemFileName2 = INPUT_FILE_PATH 914 + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4"; 915 final String videoItemFileName3 = INPUT_FILE_PATH 916 + "H264_BP_640x480_30fps_256kbps_1_17.mp4"; 917 final String imageItemFilename1 = INPUT_FILE_PATH 918 + "IMG_1600x1200.jpg"; 919 final String imageItemFilename2 = INPUT_FILE_PATH 920 + "IMG_176x144.jpg"; 921 final String audioFilename = INPUT_FILE_PATH 922 + "AMRNB_8KHz_12.2Kbps_m_1_17.3gp"; 923 OverlayData overlayData1 = new OverlayData(); 924 previewStart = false; 925 previewStop = false; 926 final MediaVideoItem mediaVideoItem1 = 927 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 928 videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER); 929 mediaVideoItem1.setExtractBoundaries(0, 10000); 930 mVideoEditor.addMediaItem(mediaVideoItem1); 931 932 final MediaVideoItem mediaVideoItem2 = 933 mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", 934 videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER); 935 mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 4, 936 mediaVideoItem2.getDuration() / 2); 937 mVideoEditor.addMediaItem(mediaVideoItem2); 938 939 final MediaVideoItem mediaVideoItem3 = 940 mVideoEditorHelper.createMediaItem(mVideoEditor, "m3", 941 videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER); 942 mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 2, 943 mediaVideoItem2.getDuration()); 944 mVideoEditor.addMediaItem(mediaVideoItem3); 945 946 final MediaImageItem mediaImageItem4 = 947 mVideoEditorHelper.createMediaItem(mVideoEditor, "m4", 948 imageItemFilename1, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER); 949 950 final MediaImageItem mediaImageItem5 = 951 mVideoEditorHelper.createMediaItem(mVideoEditor, "m5", 952 imageItemFilename2, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER); 953 954 List<MediaItem> mediaList = mVideoEditor.getAllMediaItems(); 955 assertEquals("Media Item List Size", 3, mediaList.size()); 956 957 mVideoEditor.insertMediaItem(mediaImageItem4, mediaVideoItem2.getId()); 958 mediaList = mVideoEditor.getAllMediaItems(); 959 assertEquals("Media Item List Size", 4, mediaList.size()); 960 assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0)); 961 assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1)); 962 assertEquals("Media item 4", mediaImageItem4, mediaList.get(2)); 963 assertEquals("Media item 3", mediaVideoItem3, mediaList.get(3)); 964 965 mVideoEditor.insertMediaItem(mediaImageItem5, mediaImageItem4.getId()); 966 mediaList = mVideoEditor.getAllMediaItems(); 967 assertEquals("Media Item List Size", 5, mediaList.size()); 968 assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0)); 969 assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1)); 970 assertEquals("Media item 4", mediaImageItem4, mediaList.get(2)); 971 assertEquals("Media item 5", mediaImageItem5, mediaList.get(3)); 972 assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4)); 973 974 mVideoEditor.moveMediaItem(mediaVideoItem1.getId(), 975 mediaImageItem5.getId()); 976 mediaList = mVideoEditor.getAllMediaItems(); 977 assertEquals("Media Item List Size", 5, mediaList.size()); 978 assertEquals("Media item 2", mediaVideoItem2, mediaList.get(0)); 979 assertEquals("Media item 4", mediaImageItem4, mediaList.get(1)); 980 assertEquals("Media item 5", mediaImageItem5, mediaList.get(2)); 981 assertEquals("Media item 1", mediaVideoItem1, mediaList.get(3)); 982 assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4)); 983 984 final TransitionCrossfade transition2And4CrossFade = 985 mVideoEditorHelper.createTCrossFade("transition2And4CrossFade", 986 mediaVideoItem2, mediaImageItem4, 2000, 987 Transition.BEHAVIOR_MIDDLE_FAST); 988 mVideoEditor.addTransition(transition2And4CrossFade); 989 990 final TransitionCrossfade transition1And3CrossFade = 991 mVideoEditorHelper.createTCrossFade("transition1And3CrossFade", 992 mediaVideoItem1, mediaVideoItem3, 5000, 993 Transition.BEHAVIOR_MIDDLE_FAST); 994 mVideoEditor.addTransition(transition1And3CrossFade); 995 996 final AudioTrack audioTrack = 997 mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename); 998 audioTrack.setExtractBoundaries(0, 2000); 999 mVideoEditor.addAudioTrack(audioTrack); 1000 1001 audioTrack.enableLoop(); 1002 1003 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 1004 public void onProgress(Object item, int action, int progress) { 1005 } 1006 }); 1007 1008 final SurfaceHolder surfaceHolder = 1009 MediaFrameworkTest.mSurfaceView.getHolder(); 1010 1011 mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration()/4, overlayData1); 1012 Thread.sleep(1000); 1013 mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration()/2, overlayData1); 1014 Thread.sleep(1000); 1015 mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration(), overlayData1); 1016 1017 } 1018 1019 /** 1020 * To Test Preview : Without any Media Items in the story Board 1021 */ 1022 @LargeTest 1023 public void testStartPreviewWithoutMediaItems() throws Exception { 1024 boolean flagForException = false; 1025 1026 final SurfaceHolder surfaceHolder = 1027 MediaFrameworkTest.mSurfaceView.getHolder(); 1028 try{ 1029 mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1, 1030 new PreviewProgressListener() { 1031 public void onProgress(VideoEditor videoEditor, long timeMs, 1032 OverlayData overlayData) { 1033 } 1034 public void onStart(VideoEditor videoEditor) { 1035 setPreviewStart(); 1036 } 1037 public void onStop(VideoEditor videoEditor) { 1038 setPreviewStop(); 1039 } 1040 public void onError(VideoEditor videoEditor, int error) { 1041 setPreviewError(); 1042 } 1043 }); 1044 }catch (IllegalArgumentException e) { 1045 flagForException = true; 1046 } 1047 assertTrue("Preview without Media Items", flagForException); 1048 } 1049 1050 /** 1051 * To Test Preview : Add Media and Remove Media Item (Without any Media 1052 * Items in the story Board) 1053 */ 1054 @LargeTest 1055 public void testStartPreviewAddRemoveMediaItems() throws Exception { 1056 final String videoItemFilename1 = INPUT_FILE_PATH 1057 + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp"; 1058 final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg"; 1059 final String alphaFilename = INPUT_FILE_PATH + 1060 "TransitionSpiral_QVGA.jpg"; 1061 boolean flagForException = false; 1062 1063 final MediaVideoItem mediaVideoItem = 1064 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", 1065 videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER); 1066 mediaVideoItem.setExtractBoundaries(0, 15000); 1067 mVideoEditor.addMediaItem(mediaVideoItem); 1068 1069 final MediaImageItem mediaImageItem = 1070 mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", 1071 imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER); 1072 mVideoEditor.addMediaItem(mediaImageItem); 1073 1074 final TransitionAlpha transition1And2 = 1075 mVideoEditorHelper.createTAlpha("transition", mediaVideoItem, 1076 mediaImageItem, 3000, Transition.BEHAVIOR_SPEED_UP, 1077 alphaFilename, 10, false); 1078 mVideoEditor.addTransition(transition1And2); 1079 1080 final EffectColor effectColor = 1081 mVideoEditorHelper.createEffectItem(mediaImageItem, "effect", 5000, 1082 3000, EffectColor.TYPE_COLOR, EffectColor.PINK); 1083 mediaImageItem.addEffect(effectColor); 1084 1085 assertEquals("removing Media item 1", mediaVideoItem, 1086 mVideoEditor.removeMediaItem(mediaVideoItem.getId())); 1087 assertEquals("removing Media item 2", mediaImageItem, 1088 mVideoEditor.removeMediaItem(mediaImageItem.getId())); 1089 1090 try{ 1091 mVideoEditor.generatePreview(new MediaProcessingProgressListener() { 1092 public void onProgress(Object item, int action, int progress) { 1093 } 1094 }); 1095 final SurfaceHolder surfaceHolder = 1096 MediaFrameworkTest.mSurfaceView.getHolder(); 1097 mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1, 1098 new PreviewProgressListener() { 1099 public void onProgress(VideoEditor videoEditor, long timeMs, 1100 OverlayData overlayData) { 1101 } 1102 public void onStart(VideoEditor videoEditor) { 1103 setPreviewStart(); 1104 } 1105 public void onStop(VideoEditor videoEditor) { 1106 setPreviewStop(); 1107 } 1108 public void onError(VideoEditor videoEditor, int error) { 1109 setPreviewError(); 1110 } 1111 }); 1112 }catch (IllegalArgumentException e) { 1113 flagForException = true; 1114 } 1115 assertTrue("Preview with removed Media Items", flagForException); 1116 1117 } 1118 1119 /** 1120 * To test Preview : Preview of current Effects applied (with Render Preview 1121 * Frame) 1122 */ 1123 @LargeTest 1124 public void testPreviewWithRenderPreviewFrameWithoutGenerate() throws Exception { 1125 final String videoItemFileName = INPUT_FILE_PATH + 1126 "H264_BP_640x480_30fps_256kbps_1_17.mp4"; 1127 boolean flagForException = false; 1128 long duration = 0; 1129 OverlayData overlayData1 = new OverlayData(); 1130 1131 final MediaVideoItem mediaVideoItem = 1132 mVideoEditorHelper.createMediaItem(mVideoEditor, 1133 "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER); 1134 mVideoEditor.addMediaItem(mediaVideoItem); 1135 1136 final SurfaceHolder surfaceHolder = 1137 MediaFrameworkTest.mSurfaceView.getHolder(); 1138 duration = mVideoEditor.getDuration(); 1139 /* RenderPreviewFrame returns -1 to indicate last frame */ 1140 try { 1141 mVideoEditor.renderPreviewFrame(surfaceHolder, duration, 1142 overlayData1); 1143 } catch ( IllegalStateException e) { 1144 flagForException = true; 1145 } 1146 assertTrue (" Render Preview Frame without generate", flagForException); 1147 duration = mVideoEditor.getDuration() + 1000; 1148 try { 1149 mVideoEditor.renderPreviewFrame(surfaceHolder, duration, 1150 overlayData1); 1151 } catch ( IllegalArgumentException e) { 1152 flagForException = true; 1153 } 1154 assertTrue (" Preview time greater than duration", flagForException); 1155 } 1156 } 1157
