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    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