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