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