xref: /frameworks/base/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/videoeditor/VideoEditorPreviewTest.java

/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.mediaframeworktest.functional.videoeditor;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.Semaphore;

import android.graphics.Bitmap;
import android.graphics.Rect;
import android.media.videoeditor.AudioTrack;
import android.media.videoeditor.Effect;
import android.media.videoeditor.EffectColor;
import android.media.videoeditor.EffectKenBurns;
import android.media.videoeditor.MediaImageItem;
import android.media.videoeditor.MediaItem;
import android.media.videoeditor.MediaProperties;
import android.media.videoeditor.MediaVideoItem;
import android.media.videoeditor.Overlay;
import android.media.videoeditor.OverlayFrame;
import android.media.videoeditor.Transition;
import android.media.videoeditor.TransitionAlpha;
import android.media.videoeditor.TransitionCrossfade;
import android.media.videoeditor.TransitionFadeBlack;
import android.media.videoeditor.TransitionSliding;
import android.media.videoeditor.VideoEditor;
import android.media.videoeditor.VideoEditor.ExportProgressListener;
import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
import android.media.videoeditor.VideoEditor.PreviewProgressListener;
import android.media.videoeditor.VideoEditor.OverlayData;
import android.os.Environment;
import android.test.ActivityInstrumentationTestCase;
import android.view.SurfaceHolder;


import com.android.mediaframeworktest.MediaFrameworkTest;
import android.test.suitebuilder.annotation.LargeTest;
import com.android.mediaframeworktest.VideoEditorHelper;

import android.os.Handler;
import android.os.Looper;
import android.os.Message;

import java.util.concurrent.TimeUnit;

import android.util.Log;

public class VideoEditorPreviewTest extends
    ActivityInstrumentationTestCase<MediaFrameworkTest> {
    private final String TAG = "VideoEditorTest";

    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;

    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;

    private final String PROJECT_CLASS_NAME =
        "android.media.videoeditor.VideoEditorImpl";

    private VideoEditor mVideoEditor;

    private VideoEditorHelper mVideoEditorHelper;

    private class EventHandler extends Handler {
        public EventHandler( Looper lp)
        {
            super(lp);
        }
        public void handleMessage(Message msg)
        {
            switch (msg.what)
            {
                default:
                MediaFrameworkTest.testInvalidateOverlay();
            }
        }
    }
    private EventHandler mEventHandler;

    private boolean previewStart;
    private boolean previewStop;
    private boolean previewError;

    /* Minimum waiting time for Semaphore to wait for release */
    private final long minWaitingTime = 3000;

    // Declares the annotation for Preview Test Cases
    public @interface Preview {
    }

    public VideoEditorPreviewTest() {
        super("com.android.mediaframeworktest", MediaFrameworkTest.class);

        Looper looper;
        if ((looper = Looper.myLooper()) != null) {
            mEventHandler = new EventHandler(looper);

        } else {
            //Handle error when looper can not be created.
            ;
        }
    }

    @Override
    protected void setUp() throws Exception {
        // setup for each test case.
        super.setUp();
        mVideoEditorHelper = new VideoEditorHelper();
        // Create a random String which will be used as project path, where all
        // project related files will be stored.
        final String projectPath =
            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
    }

    @Override
    protected void tearDown() throws Exception {
        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
        // Clean the directory created as project path
        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
        System.gc();
        super.tearDown();
    }

    protected void setPreviewStart() {
        previewStart = true;
    }
    protected void setPreviewStop() {
        previewStop = true;
    }
    protected void setPreviewError() {
        previewError = true;
    }
    protected void validatePreviewProgress(int startMs, int endMs,
        boolean loop, long duration) throws Exception {

        final int[] progressUpdate = new int[100];
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        previewError = false;
        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            int i = 0;
            public void onProgress(Object item, int action, int progress) {
                progressUpdate[i++] = progress;
            }
        });
        mVideoEditorHelper.checkProgressCBValues(progressUpdate);
        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();

        long waitingTime = minWaitingTime;
        if (endMs == -1) {
            waitingTime += duration;
        }
        else {
            waitingTime += (endMs - startMs);
        }
        blockTillPreviewCompletes.acquire();
        try {
        mVideoEditor.startPreview(surfaceHolder, startMs, endMs, loop, 1,
            new PreviewProgressListener() {
                public void onProgress(VideoEditor videoEditor, long timeMs,
                    OverlayData overlayData) {

                        if ( overlayData != null) {
                            if(overlayData.needsRendering()) {
                                overlayData.renderOverlay(MediaFrameworkTest.mDestBitmap);
                                mEventHandler.sendMessage(mEventHandler.obtainMessage(1, 2, 3));
                            }
                        }
                }
                public void onStart(VideoEditor videoEditor) {
                    setPreviewStart();
                }
                public void onStop(VideoEditor videoEditor) {
                    setPreviewStop();
                    blockTillPreviewCompletes.release();
                }
                public void onError(VideoEditor videoEditor, int error) {
                    setPreviewError();
                    blockTillPreviewCompletes.release();
                }
        });
        } catch (Exception e) {
            blockTillPreviewCompletes.release();
        }
        blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS);

        mVideoEditor.stopPreview();
        assertTrue("Preview Failed to start", previewStart);
        assertTrue("Preview Failed to stop", previewStop);
        assertFalse("Preview Error occurred", previewError);

        blockTillPreviewCompletes.release();
    }

    // -----------------------------------------------------------------
    // Preview
    // -----------------------------------------------------------------

    /**
     *To test Preview : FULL Preview of current work (beginning till end)
     */
    @LargeTest
    public void testPreviewTheStoryBoard() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH
            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
        final String videoItemFileName3 = INPUT_FILE_PATH
            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
        previewStart = false;
        previewStop = false;
        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaVideoItem mediaVideoItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2",
                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem2);
        mediaVideoItem2.setExtractBoundaries(0, 10000);

        final MediaVideoItem mediaVideoItem3 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3",
                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem3.setExtractBoundaries(0, 10000);

        mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId());
        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0));
        assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1));
        assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2));

        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
        assertEquals("Media Item 1 Rendering Mode",
            MediaItem.RENDERING_MODE_BLACK_BORDER,
            mediaVideoItem1.getRenderingMode());

        mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
        assertEquals("Media Item 2 Rendering Mode",
            MediaItem.RENDERING_MODE_BLACK_BORDER,
            mediaVideoItem2.getRenderingMode());

        mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
        assertEquals("Media Item 3 Rendering Mode",
            MediaItem.RENDERING_MODE_STRETCH,
            mediaVideoItem3.getRenderingMode());

        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3);
        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3,
            mVideoEditor.getAspectRatio());

        validatePreviewProgress(0, -1, false, mVideoEditor.getDuration());
    }

    /**
     * To test Preview : Preview of start + 10 sec till end of story board
     */
    @LargeTest
    public void testPreviewTheStoryBoardFromDuration() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH
            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
        final String videoItemFileName3 = INPUT_FILE_PATH
            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaVideoItem mediaVideoItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2",
                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem2.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem2);

        final MediaVideoItem mediaVideoItem3 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3",
                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem3.setExtractBoundaries(0, 10000);

        mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId());

        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0));
        assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1));
        assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2));
        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);

        assertEquals("Media Item 1 Rendering Mode",
            MediaItem.RENDERING_MODE_BLACK_BORDER,
            mediaVideoItem1.getRenderingMode());
        mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);

        assertEquals("Media Item 2 Rendering Mode",
            MediaItem.RENDERING_MODE_BLACK_BORDER,
            mediaVideoItem2.getRenderingMode());
        mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);

        assertEquals("Media Item 3 Rendering Mode",
            MediaItem.RENDERING_MODE_STRETCH,
            mediaVideoItem3.getRenderingMode());

        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3);
        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3,
            mVideoEditor.getAspectRatio());

        validatePreviewProgress(10000, -1, false, mVideoEditor.getDuration());
    }

    /**
     * To test Preview : Preview of current Effects applied
     */
    @LargeTest
    public void testPreviewOfEffects() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_256kbps_1_17.mp4";

        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final EffectColor effectNegative =
            mVideoEditorHelper.createEffectItem(mediaVideoItem1,
                "effectNegative", 0, 2000, EffectColor.TYPE_NEGATIVE, 0);
        mediaVideoItem1.addEffect(effectNegative);

        final EffectColor effectGreen =
            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effectGreen",
                2000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
        mediaVideoItem1.addEffect(effectGreen);

        final EffectColor effectFifties =
            mVideoEditorHelper.createEffectItem(mediaVideoItem1,
                "effectFifties", 5000, 4000, EffectColor.TYPE_FIFTIES, 0);
        mediaVideoItem1.addEffect(effectFifties);

        List<Effect> effectList = mediaVideoItem1.getAllEffects();
        assertEquals("Effect List Size", 3, effectList.size());
        assertEquals("Effect negative", effectNegative, effectList.get(0));
        assertEquals("Effect Green", effectGreen, effectList.get(1));
        assertEquals("Effect Fifties", effectFifties, effectList.get(2));

        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3);
        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_4_3,
            mVideoEditor.getAspectRatio());

        final long storyboardDuration = mVideoEditor.getDuration() ;
        validatePreviewProgress(0, (int)(storyboardDuration/2), false, (storyboardDuration/2));

        assertEquals("Removing Effect : Negative", effectNegative,
            mediaVideoItem1.removeEffect(effectNegative.getId()));

        effectList = mediaVideoItem1.getAllEffects();

        assertEquals("Effect List Size", 2, effectList.size());
        assertEquals("Effect Green", effectGreen, effectList.get(0));
        assertEquals("Effect Fifties", effectFifties, effectList.get(1));

        validatePreviewProgress(0, -1, false, mVideoEditor.getDuration());
    }

    /**
     *To test Preview : Preview of current Transitions applied (with multiple
     * generatePreview)
     */
    @LargeTest
    public void testPreviewWithTransition() throws Exception {

        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
        final String imageItemFileName1 = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final String videoItemFileName2 = INPUT_FILE_PATH +
            "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
        final String maskFilename = INPUT_FILE_PATH +
            "TransitionSpiral_QVGA.jpg";
        previewStart = false;
        previewStop = false;
        previewError = false;

        final Semaphore blockTillPreviewCompletes = new Semaphore(1);

        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaImageItem mediaImageItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
                imageItemFileName1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaImageItem1);

        final MediaVideoItem mediaVideoItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem2.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem2);

        final TransitionCrossfade transition1And2CrossFade =
            mVideoEditorHelper.createTCrossFade("transition_1_2_CF",
                mediaVideoItem1, mediaImageItem1, 2000,
                Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(transition1And2CrossFade);

        final TransitionAlpha transition2And3Alpha =
            mVideoEditorHelper.createTAlpha("transition_2_3", mediaImageItem1,
                mediaVideoItem2, 4000, Transition.BEHAVIOR_SPEED_UP,
                maskFilename, 50, true);
        mVideoEditor.addTransition(transition2And3Alpha);

        final TransitionFadeBlack transition1FadeBlack =
            mVideoEditorHelper.createTFadeBlack("transition_1FB", null,
                mediaVideoItem1, 2000, Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(transition1FadeBlack);

        List<Transition> transitionList = mVideoEditor.getAllTransitions();
        assertEquals("Transition List Size", 3, transitionList.size());
        assertEquals("Transition 1", transition1And2CrossFade,
            transitionList.get(0));
        assertEquals("Transition 2", transition2And3Alpha, transitionList.get(1));
        assertEquals("Transition 3", transition1FadeBlack, transitionList.get(2));

        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_3_2);

        final int[] progressValues = new int[300];
        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            int i = 0;

            public void onProgress(Object item, int action, int progress) {
                if (item instanceof TransitionCrossfade) {
                    progressValues[i] = progress;
                    assertEquals("Object", item, transition1And2CrossFade);
                    assertEquals("Action", action,
                        MediaProcessingProgressListener.ACTION_ENCODE);
                } else if (item instanceof TransitionAlpha) {
                    progressValues[i] = progress;
                    assertEquals("Object", item, transition2And3Alpha);
                    assertEquals("Action", action,
                        MediaProcessingProgressListener.ACTION_ENCODE);
                } else if (item instanceof TransitionFadeBlack) {
                    progressValues[i] = progress;
                    assertEquals("Object", item, transition1FadeBlack);
                    assertEquals("Action", action,
                        MediaProcessingProgressListener.ACTION_ENCODE);
                }
                i++;
            }
        });

        mVideoEditorHelper.checkProgressCBValues(progressValues);
        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();
        /* As transition takes more time buffer of 10 sec is added */
        long waitingTime = minWaitingTime + 10000 + 10000;

        blockTillPreviewCompletes.acquire();
        try {
        mVideoEditor.startPreview(surfaceHolder, 0, 10000, false, 1,
            new PreviewProgressListener() {
            public void onProgress(VideoEditor videoEditor, long timeMs,
                OverlayData overlayData) {
                }
                public void onStart(VideoEditor videoEditor) {
                    setPreviewStart();
                }
                public void onStop(VideoEditor videoEditor) {
                    setPreviewStop();
                    blockTillPreviewCompletes.release();
                }
                public void onError(VideoEditor videoEditor, int error) {
                    setPreviewError();
                    blockTillPreviewCompletes.release();
                }
        });
        } catch (Exception e) {
            blockTillPreviewCompletes.release();
        }
        blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS);
        mVideoEditor.stopPreview();
        blockTillPreviewCompletes.release();
        assertTrue("Preview Failed to start", previewStart);
        assertTrue("Preview Failed to stop", previewStop);
        assertFalse("Preview Error occurred", previewError);

        assertEquals("Removing Transition " + transition1And2CrossFade.getId(),
            transition1And2CrossFade,
            mVideoEditor.removeTransition(transition1And2CrossFade.getId()));
        transitionList = mVideoEditor.getAllTransitions();
        assertEquals("Transition List Size", 2, transitionList.size());
        assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0));
        assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1));

        validatePreviewProgress(0, -1, false, mVideoEditor.getDuration());


        final TransitionSliding transition1And2Sliding =
            mVideoEditorHelper.createTSliding("transition_1_2Sliding",
                mediaVideoItem1, mediaImageItem1, 4000,
                Transition.BEHAVIOR_MIDDLE_FAST,
                TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
        mVideoEditor.addTransition(transition1And2Sliding);

        transitionList = mVideoEditor.getAllTransitions();
        assertEquals("Transition List Size", 3, transitionList.size());
        assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0));
        assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1));
        assertEquals("Transition 3", transition1And2Sliding,
            transitionList.get(2));

        validatePreviewProgress(5000, -1, false, (mVideoEditor.getDuration()));

    }

    /**
     * To test Preview : Preview of current Overlay applied
     */
    @LargeTest
    public void testPreviewWithOverlay() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
        final String overlayFilename1 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";
        final String overlayFilename2 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay2.png";
        final int previewFrom = 5000;
        final int previewTo = 10000;
        final boolean previewLoop = false;
        final int previewCallbackFrameCount = 1;
        final int setAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        boolean flagForException = false;
        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName, renderingMode);
        mVideoEditor.addMediaItem(mediaVideoItem);
        mediaVideoItem.setExtractBoundaries(0, 10000);

        final Bitmap mBitmap1 =  mVideoEditorHelper.getBitmap(overlayFilename1,
            640, 480);
        final OverlayFrame overlayOnMvi1 =
            mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi1",
                mBitmap1, 0, 5000);
        mediaVideoItem.addOverlay(overlayOnMvi1);

        final Bitmap mBitmap2 =  mVideoEditorHelper.getBitmap(overlayFilename2,
            640, 480);
        final OverlayFrame overlayOnMvi2 =
            mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi2",
                mBitmap2, 5000, 9000);
        mediaVideoItem.addOverlay(overlayOnMvi2);

        List<Overlay> overlayList = mediaVideoItem.getAllOverlays();
        assertEquals("Overlay Size", 2, overlayList.size());
        assertEquals("Overlay 1", overlayOnMvi1, overlayList.get(0));
        assertEquals("Overlay 2", overlayOnMvi2, overlayList.get(1));

        mVideoEditor.setAspectRatio(setAspectRatio);

        validatePreviewProgress(0 /* previewFrom */, -1, previewLoop,
            mVideoEditor.getDuration());
    }

    /**
     * To test Preview : Preview of current Trim applied (with default aspect
     * ratio)
     */
    @LargeTest
    public void testPreviewWithTrim() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName, MediaItem.RENDERING_MODE_CROPPING);
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        boolean flagForException = false;
        previewStart = false;
        previewStop = false;
        mediaVideoItem.setExtractBoundaries(mediaVideoItem.getDuration() / 2,
            mediaVideoItem.getDuration());
        mVideoEditor.addMediaItem(mediaVideoItem);

        validatePreviewProgress(1000, -1, false, mVideoEditor.getDuration());
    }

    /**
     * To test Preview : Preview of current work having Overlay and Effect
     * applied
     */

    @LargeTest
    public void testPreviewWithOverlayEffectKenBurn() throws Exception {

        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final String overlayFilename = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaImageItem mediaImageItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
                imageItemFileName, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaImageItem2);

        final MediaVideoItem mediaVideoItem3 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem3);

        final EffectColor effectColor =
            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "Effect1",
                1000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
        mediaVideoItem1.addEffect(effectColor);

        final Rect startRect = new Rect((mediaImageItem2.getHeight() / 3),
            (mediaImageItem2.getWidth() / 3), (mediaImageItem2.getHeight() / 2),
            (mediaImageItem2.getWidth() / 2));
        final Rect endRect = new Rect(0, 0, mediaImageItem2.getWidth(),
            mediaImageItem2.getHeight());

        final EffectKenBurns kbeffectOnMI2 = new EffectKenBurns(mediaImageItem2,
            "KBOnM2", startRect, endRect, 0, 10000);
        assertNotNull("EffectKenBurns", kbeffectOnMI2);
        mediaImageItem2.addEffect(kbeffectOnMI2);

        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFilename,
            640, 480);
        final OverlayFrame overlayFrame =
            mVideoEditorHelper.createOverlay(mediaVideoItem3, "OverlayID",
                mBitmap, (mediaImageItem2.getDuration() / 4),
                (mediaVideoItem3.getDuration() / 3));
        mediaVideoItem3.addOverlay(overlayFrame);

        validatePreviewProgress(5000, -1, false, mVideoEditor.getDuration());
    }

    /**
     *To test Preview : Export during preview
     */
    @LargeTest
    public void testPreviewDuringExport() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        previewStart = false;
        previewStop = false;
        previewError = false;

        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(0, 20000);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            public void onProgress(Object item, int action, int progress) {
            }
        });

        long waitingTime = minWaitingTime + mVideoEditor.getDuration();


        blockTillPreviewCompletes.acquire();
                    final String fileName = mVideoEditor.getPath() + "/test.3gp";
                    final int height = MediaProperties.HEIGHT_480;
                    final int bitrate = MediaProperties.BITRATE_512K;

            try {
                mVideoEditor.export(fileName, height, bitrate,
                    new ExportProgressListener() {
                        public void onProgress(VideoEditor ve,
                            String outFileName,int progress) {

                        }
                    });
            } catch (IOException e) {
                assertTrue("UnExpected Error in Export" +
                    e.toString(), false);
            }

        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();
        try {

            mVideoEditor.startPreview(surfaceHolder, 5000, -1, false, 1,
                new PreviewProgressListener() {

                    public void onProgress(VideoEditor videoEditor, long timeMs,
                        OverlayData overlayData) {
                    }
                public void onStart(VideoEditor videoEditor) {
                    setPreviewStart();
                }
                public void onStop(VideoEditor videoEditor) {
                    setPreviewStop();
                    blockTillPreviewCompletes.release();
                }
                public void onError(VideoEditor videoEditor, int error) {
                    setPreviewError();
                    blockTillPreviewCompletes.release();
                }
            });

        } catch (Exception e) {
            blockTillPreviewCompletes.release();
        }
        blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS);
        mVideoEditor.stopPreview();
        assertTrue("Preview Failed to start", previewStart);
        assertTrue("Preview Failed to stop", previewStop);
        assertFalse("Preview Error occurred", previewError);

        blockTillPreviewCompletes.release();
    }

    /**
     * To test Preview : Preview of current Effects applied (with from time >
     * total duration)
     */
    @LargeTest
    public void testPreviewWithDurationGreaterThanMediaDuration()
        throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        boolean flagForException = false;
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);

        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName, renderingMode);
        try {
            mediaVideoItem1.setExtractBoundaries(0, 20000);
        } catch (Exception e) {
            assertTrue("Exception during setExtract Boundaries", false);
        }
        mVideoEditor.addMediaItem(mediaVideoItem1);
        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();
        long waitingTime = minWaitingTime + (mVideoEditor.getDuration() - 30000);
        if(waitingTime < 0)
        {
            waitingTime = minWaitingTime;
        }

        blockTillPreviewCompletes.acquire();
        try {
            mVideoEditor.startPreview(surfaceHolder, 30000, -1, true, 1,
            new PreviewProgressListener() {
                public void onProgress(VideoEditor videoEditor, long timeMs,
                    OverlayData overlayData) {
            }
                public void onStart(VideoEditor videoEditor) {
                    setPreviewStart();
                }
                public void onStop(VideoEditor videoEditor) {
                    setPreviewStop();
                    blockTillPreviewCompletes.release();
                }
                public void onError(VideoEditor videoEditor, int error) {
                    setPreviewError();
                    blockTillPreviewCompletes.release();
                }
        });

        } catch (IllegalArgumentException e) {
            blockTillPreviewCompletes.release();
            flagForException = true;
        }
        blockTillPreviewCompletes.tryAcquire(waitingTime, TimeUnit.MILLISECONDS);
        assertTrue("Expected Error in Preview", flagForException);
        mVideoEditor.stopPreview();
        blockTillPreviewCompletes.release();
    }

    /**
     * To test Preview : Preview of current Effects applied (with Render Preview
     * Frame)
     */
    @LargeTest
    public void testPreviewWithRenderPreviewFrame() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
        boolean flagForException = false;
        OverlayData overlayData1 = new OverlayData();
        previewStart = false;
        previewStop = false;

        final String overlayFilename1 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";

        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor,
            "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final EffectColor effectPink =
            mVideoEditorHelper.createEffectItem(mediaVideoItem,
                "effectNegativeOnMvi", 1000, 3000, EffectColor.TYPE_COLOR,
                 EffectColor.PINK);
        mediaVideoItem.addEffect(effectPink);

        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            public void onProgress(Object item, int action, int progress) {
            }
        });
        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();

        assertEquals("Render preview Frame at 5 Sec", 5000,
            mVideoEditor.renderPreviewFrame(surfaceHolder, 5000,
            overlayData1));

        assertEquals("Render preview Frame at 7 Sec", 7000,
            mVideoEditor.renderPreviewFrame(surfaceHolder, 7000,
            overlayData1));

        validatePreviewProgress(5000, -1, false, mVideoEditor.getDuration());
    }

    /**
     * To test Preview : Preview of current work from selected jump location
     * till end with Audio Track
     */
    @LargeTest
    public void testPreviewWithEndAudioTrack() throws Exception {
        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
        final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_640x480.jpg";
        final String audioFilename = INPUT_FILE_PATH +
            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";

        boolean flagForException = false;
        previewStart = false;
        previewStop = false;
        final MediaImageItem mediaImageItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                imageItemFilename1, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaImageItem1);

        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem.setExtractBoundaries(1000, 8000);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final MediaImageItem mediaImageItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
                imageItemFilename2, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaImageItem2);

        final AudioTrack audioTrack =
            mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename);
        mVideoEditor.addAudioTrack(audioTrack);

        List<AudioTrack> audioList = mVideoEditor.getAllAudioTracks();
        assertEquals("Audio Track List size", 1, audioList.size());
        assertEquals("Audio Track", audioTrack, audioList.get(0));
        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3);

        validatePreviewProgress(10000, -1, false, mVideoEditor.getDuration());
    }

    /**
     * To test render Preview Frame
     */
    @LargeTest
    public void testRenderPreviewFrame() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH
            + "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH
            + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
        final String videoItemFileName3 = INPUT_FILE_PATH
            + "H264_BP_640x480_30fps_256kbps_1_17.mp4";
        final String imageItemFilename1 = INPUT_FILE_PATH
            + "IMG_1600x1200.jpg";
        final String imageItemFilename2 = INPUT_FILE_PATH
            + "IMG_176x144.jpg";
        final String audioFilename = INPUT_FILE_PATH
            + "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
        OverlayData overlayData1 = new OverlayData();
        previewStart = false;
        previewStop = false;
        final MediaVideoItem mediaVideoItem1 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaVideoItem mediaVideoItem2 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 4,
            mediaVideoItem2.getDuration() / 2);
        mVideoEditor.addMediaItem(mediaVideoItem2);

        final MediaVideoItem mediaVideoItem3 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 2,
            mediaVideoItem2.getDuration());
        mVideoEditor.addMediaItem(mediaVideoItem3);

        final MediaImageItem mediaImageItem4 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
                imageItemFilename1, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER);

        final MediaImageItem mediaImageItem5 =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
                imageItemFilename2, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER);

        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item List Size", 3, mediaList.size());

        mVideoEditor.insertMediaItem(mediaImageItem4, mediaVideoItem2.getId());
        mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item List Size", 4, mediaList.size());
        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
        assertEquals("Media item 4", mediaImageItem4, mediaList.get(2));
        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(3));

        mVideoEditor.insertMediaItem(mediaImageItem5, mediaImageItem4.getId());
        mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item List Size", 5, mediaList.size());
        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
        assertEquals("Media item 4", mediaImageItem4, mediaList.get(2));
        assertEquals("Media item 5", mediaImageItem5, mediaList.get(3));
        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));

        mVideoEditor.moveMediaItem(mediaVideoItem1.getId(),
            mediaImageItem5.getId());
        mediaList = mVideoEditor.getAllMediaItems();
        assertEquals("Media Item List Size", 5, mediaList.size());
        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(0));
        assertEquals("Media item 4", mediaImageItem4, mediaList.get(1));
        assertEquals("Media item 5", mediaImageItem5, mediaList.get(2));
        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(3));
        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));

        final TransitionCrossfade transition2And4CrossFade =
            mVideoEditorHelper.createTCrossFade("transition2And4CrossFade",
                mediaVideoItem2, mediaImageItem4, 2000,
                Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(transition2And4CrossFade);

        final TransitionCrossfade transition1And3CrossFade =
            mVideoEditorHelper.createTCrossFade("transition1And3CrossFade",
                mediaVideoItem1, mediaVideoItem3, 5000,
                Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(transition1And3CrossFade);

        final AudioTrack audioTrack =
            mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename);
        audioTrack.setExtractBoundaries(0, 2000);
        mVideoEditor.addAudioTrack(audioTrack);

        audioTrack.enableLoop();

        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            public void onProgress(Object item, int action, int progress) {
            }
        });

        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();

        mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration()/4, overlayData1);
        Thread.sleep(1000);
        mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration()/2, overlayData1);
        Thread.sleep(1000);
        mVideoEditor.renderPreviewFrame(surfaceHolder, mVideoEditor.getDuration(), overlayData1);

    }

    /**
     * To Test Preview : Without any Media Items in the story Board
     */
    @LargeTest
    public void testStartPreviewWithoutMediaItems() throws Exception {
        boolean flagForException = false;

        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();
        try{
            mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1,
                new PreviewProgressListener() {
                    public void onProgress(VideoEditor videoEditor, long timeMs,
                        OverlayData overlayData) {
                    }
                    public void onStart(VideoEditor videoEditor) {
                        setPreviewStart();
                    }
                    public void onStop(VideoEditor videoEditor) {
                        setPreviewStop();
                    }
                    public void onError(VideoEditor videoEditor, int error) {
                        setPreviewError();
                    }
            });
        }catch (IllegalArgumentException e) {
            flagForException = true;
        }
        assertTrue("Preview without Media Items", flagForException);
    }

    /**
     * To Test Preview : Add Media and Remove Media Item (Without any Media
     * Items in the story Board)
     */
    @LargeTest
    public void testStartPreviewAddRemoveMediaItems() throws Exception {
        final String videoItemFilename1 = INPUT_FILE_PATH
            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
        final String alphaFilename = INPUT_FILE_PATH +
            "TransitionSpiral_QVGA.jpg";
        boolean flagForException = false;

        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mediaVideoItem.setExtractBoundaries(0, 15000);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final MediaImageItem mediaImageItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaImageItem);

        final TransitionAlpha transition1And2 =
            mVideoEditorHelper.createTAlpha("transition", mediaVideoItem,
                mediaImageItem, 3000, Transition.BEHAVIOR_SPEED_UP,
                alphaFilename, 10, false);
        mVideoEditor.addTransition(transition1And2);

        final EffectColor effectColor =
            mVideoEditorHelper.createEffectItem(mediaImageItem, "effect", 5000,
                3000, EffectColor.TYPE_COLOR, EffectColor.PINK);
        mediaImageItem.addEffect(effectColor);

        assertEquals("removing Media item 1", mediaVideoItem,
            mVideoEditor.removeMediaItem(mediaVideoItem.getId()));
        assertEquals("removing Media item 2", mediaImageItem,
            mVideoEditor.removeMediaItem(mediaImageItem.getId()));

        try{
            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
                public void onProgress(Object item, int action, int progress) {
                }
            });
            final SurfaceHolder surfaceHolder =
                MediaFrameworkTest.mSurfaceView.getHolder();
            mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1,
                new PreviewProgressListener() {
                    public void onProgress(VideoEditor videoEditor, long timeMs,
                        OverlayData overlayData) {
                    }
                    public void onStart(VideoEditor videoEditor) {
                        setPreviewStart();
                    }
                    public void onStop(VideoEditor videoEditor) {
                        setPreviewStop();
                    }
                    public void onError(VideoEditor videoEditor, int error) {
                        setPreviewError();
                    }
            });
        }catch (IllegalArgumentException e) {
            flagForException = true;
        }
        assertTrue("Preview with removed Media Items", flagForException);

    }

    /**
     * To test Preview : Preview of current Effects applied (with Render Preview
     * Frame)
     */
    @LargeTest
    public void testPreviewWithRenderPreviewFrameWithoutGenerate() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
        boolean flagForException = false;
        long duration = 0;
        OverlayData overlayData1 = new OverlayData();

        final MediaVideoItem mediaVideoItem =
            mVideoEditorHelper.createMediaItem(mVideoEditor,
            "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final SurfaceHolder surfaceHolder =
            MediaFrameworkTest.mSurfaceView.getHolder();
        duration = mVideoEditor.getDuration();
        /* RenderPreviewFrame returns -1 to indicate last frame */
        try {
            mVideoEditor.renderPreviewFrame(surfaceHolder, duration,
            overlayData1);
        } catch ( IllegalStateException e) {
            flagForException = true;
        }
        assertTrue (" Render Preview Frame without generate", flagForException);
        duration = mVideoEditor.getDuration() + 1000;
        try {
            mVideoEditor.renderPreviewFrame(surfaceHolder, duration,
            overlayData1);
        } catch ( IllegalArgumentException e) {
            flagForException = true;
        }
        assertTrue (" Preview time greater than duration", flagForException);
    }
}