xref: /frameworks/base/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.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.performance;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;

import android.graphics.Bitmap;
import android.graphics.Rect;
import android.media.videoeditor.AudioTrack;
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.OverlayFrame;
import android.media.videoeditor.Transition;
import android.media.videoeditor.TransitionCrossfade;
import android.media.videoeditor.TransitionAlpha;
import android.media.videoeditor.TransitionFadeBlack;
import android.media.videoeditor.TransitionSliding;
import android.media.videoeditor.VideoEditor;
import android.os.Environment;
import android.test.ActivityInstrumentationTestCase;
import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
import android.os.Environment;
import android.os.SystemClock;
import android.test.ActivityInstrumentationTestCase;
import android.media.videoeditor.VideoEditor.ExportProgressListener;

import android.util.Log;

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

/**
 * Junit / Instrumentation - performance measurement for media player and
 * recorder
 */
public class VideoEditorPerformance extends
    ActivityInstrumentationTestCase<MediaFrameworkTest> {

    private final String TAG = "VideoEditorPerformance";

    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;

    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;

    private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
        "VideoEditorPerformance.txt";

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

    private final String PROJECT_CLASS_NAME =
        "android.media.videoeditor.VideoEditorImpl";
    private VideoEditor mVideoEditor;
    private VideoEditorHelper mVideoEditorHelper;

    @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();
    }

    private void writeTimingInfo(String testCaseName, String[] information)
        throws Exception {
        File outFile = new File(VIDEOEDITOR_OUTPUT);
        Writer output = new BufferedWriter(new FileWriter(outFile, true));
        output.write(testCaseName + "\n\t");
        for (int i = 0; i < information.length; i++) {
            output.write(information[i]);
        }
        output.write("\n\n");
        output.close();
    }

    private final int NUM_OF_ITERATIONS=20;

    private int calculateTimeTaken(long beginTime, int numIterations)
        throws Exception {
        final long duration2 = SystemClock.uptimeMillis();
        final long durationToCreateMediaItem = (duration2 - beginTime);
        final int timeTaken1 = (int)(durationToCreateMediaItem / numIterations);
        return (timeTaken1);
    }

    private void createVideoItems(MediaVideoItem[] mediaVideoItem,
        String videoItemFileName, int renderingMode, int startTime, int endTime) throws Exception {
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
                mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
                    videoItemFileName, renderingMode);
                mediaVideoItem[i].setExtractBoundaries(startTime, endTime);
            } catch (Exception e1) {
                assertTrue(
                    "Can not create an object of Video Item with file name = "
                    + videoItemFileName + "------ID:m" + i + "       Issue = "
                    + e1.toString(), false);
            }
        }
    }

    private void addVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
                mVideoEditor.addMediaItem(mediaVideoItem[i]);
            } catch (Exception e1) {
                assertTrue(
                    "Can not add an object of Video Item with ID:m" + i +
                    "    Issue = " + e1.toString(), false);
            }
        }
    }

    private void removeVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
            for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
            mVideoEditor.removeMediaItem(mediaVideoItem[i].getId());
            } catch (Exception e1) {
                assertTrue(
                    "Can not Remove an object of Video Item with ID:m" + i +
                    "    Issue = " + e1.toString(), false);
            }
        }
    }

    private void createImageItems(MediaImageItem[] mIi,
        String imageItemFileName, int renderingMode, int duration) throws Exception {
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
                mIi[i] = new MediaImageItem(mVideoEditor, "m" + i,
                    imageItemFileName, duration, renderingMode);
            } catch (Exception e1) {
                assertTrue( " Cannot create Image Item", false);
            }
        }
    }

    private void addImageItems(MediaImageItem[] mIi) throws Exception {
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
                mVideoEditor.addMediaItem(mIi[i]);
            } catch (Exception e1) {
                assertTrue("Cannot add Image item", false);
            }
        }
    }

    private void removeImageItems(MediaImageItem[] mIi) throws Exception {
            for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            try {
            mVideoEditor.removeMediaItem(mIi[i].getId());
            } catch (Exception e1) {
                assertTrue("Cannot remove image item", false);
            }
        }
    }
    /**
     * To test the performance of adding and removing the video media item
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceAddRemoveVideoItem() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final int videoItemStartTime = 0;
        final int videoItemEndTime = 5000;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[3];
        final MediaVideoItem[] mediaVideoItem =
            new MediaVideoItem[NUM_OF_ITERATIONS];
        int timeTaken = 0;
        long startTime = 0;

        /** Time Take for creation of Media Video Item */
        startTime = SystemClock.uptimeMillis();
        createVideoItems(mediaVideoItem, videoItemFileName, renderingMode,
            videoItemStartTime, videoItemEndTime);

        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
        loggingInfo[0] = "Time taken to Create Media Video Item :" +
            timeTaken;

        /** Time Take for Addition of Media Video Item */
        startTime = SystemClock.uptimeMillis();
        addVideoItems(mediaVideoItem);
        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
        loggingInfo[1] = "\n\tTime taken to Add  Media Video Item :"
            + timeTaken;

        /** Time Take for Removal of Media Video Item */
        startTime = SystemClock.uptimeMillis();
        removeVideoItems(mediaVideoItem);
        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
        loggingInfo[2] = "\n\tTime taken to remove  Media Video Item :"
            + timeTaken;

        writeTimingInfo("testPerformanceAddRemoveVideoItem (in mSec)", loggingInfo);
    }

    /**
     * To test the performance of adding and removing the image media item
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceAddRemoveImageItem() throws Exception {
        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
        final int imageItemDuration = 0;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[3];
        final MediaImageItem[] mediaImageItem =
            new MediaImageItem[NUM_OF_ITERATIONS];
        int timeTaken = 0;

        long beginTime = SystemClock.uptimeMillis();
        createImageItems(mediaImageItem, imageItemFileName, renderingMode,
            imageItemDuration);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[0] = "Time taken to Create  Media Image Item :" +
            timeTaken;

        beginTime = SystemClock.uptimeMillis();
        addImageItems(mediaImageItem);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[1] = "\n\tTime taken to add  Media Image Item :" +
            timeTaken;

        beginTime = SystemClock.uptimeMillis();
        removeImageItems(mediaImageItem);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[2] = "\n\tTime taken to remove  Media Image Item :"
            + timeTaken;

        writeTimingInfo("testPerformanceAddRemoveImageItem (in mSec)",
            loggingInfo);
    }

    /**
     * To test the performance of adding and removing the transition
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceAddRemoveTransition() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
        "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final int videoItemStartTime1 = 0;
        final int videoItemEndTime1 = 20000;
        final String videoItemFileName2 = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final int videoItemStartTime2 = 0;
        final int videoItemEndTime2 = 20000;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int transitionDuration = 5000;
        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
        final String[] loggingInfo = new String[3];
        int timeTaken = 0;

        final MediaVideoItem[] mediaVideoItem =
            new MediaVideoItem[(NUM_OF_ITERATIONS *10) + 1];

        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i+=2) {
            try {
                mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
                    videoItemFileName1, renderingMode);
                mediaVideoItem[i+1] = new MediaVideoItem(mVideoEditor,
                    "m" + (i+1), videoItemFileName2, renderingMode);
                mediaVideoItem[i].setExtractBoundaries(videoItemStartTime1,
                    videoItemEndTime1);
                mediaVideoItem[i+1].setExtractBoundaries(videoItemStartTime2,
                    videoItemEndTime2);
            } catch (Exception e1) {
                assertTrue("Can not create Video Object Item with file name = "
                    + e1.toString(), false);
            }
            mVideoEditor.addMediaItem(mediaVideoItem[i]);
            mVideoEditor.addMediaItem(mediaVideoItem[i+1]);
        }
        mediaVideoItem[(NUM_OF_ITERATIONS *10)] = new MediaVideoItem(mVideoEditor,
            "m" + (NUM_OF_ITERATIONS *10), videoItemFileName1, renderingMode);
        mediaVideoItem[(NUM_OF_ITERATIONS *10)].setExtractBoundaries(
            videoItemStartTime1, videoItemEndTime1);
        mVideoEditor.addMediaItem(mediaVideoItem[(NUM_OF_ITERATIONS *10)]);
        final TransitionCrossfade tranCrossfade[] =
            new TransitionCrossfade[(NUM_OF_ITERATIONS *10)];

        long beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
            tranCrossfade[i] = new TransitionCrossfade("transition" + i,
                mediaVideoItem[i], mediaVideoItem[i+1], transitionDuration,
                transitionBehavior);
        }
        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
        loggingInfo[0] = "Time taken to Create CrossFade Transition :" +
            timeTaken;

        beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
            mVideoEditor.addTransition(tranCrossfade[i]);
        }
        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
        loggingInfo[1] = "\n\tTime taken to add CrossFade Transition :" +
            timeTaken;

        beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
            assertEquals("Removing Transitions", tranCrossfade[i], mVideoEditor
                .removeTransition(tranCrossfade[i].getId()));
        }
        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
        loggingInfo[2] = "\n\tTime taken to remove CrossFade Transition :" +
            timeTaken;

        writeTimingInfo("testPerformanceAddRemoveTransition (in mSec)", loggingInfo);
    }

    /**
     * To test performance of Export
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceExport() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int outHeight = MediaProperties.HEIGHT_480;
        final int outBitrate = MediaProperties.BITRATE_256K;
        final int outVcodec = MediaProperties.VCODEC_H264;
        final String[] loggingInfo = new String[1];
        final String outFilename = mVideoEditorHelper
            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_12Mbps_AACLC_44.1khz_64kbps_s_1_17.mp4";
        final String imageItemFileName1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
        final String videoItemFileName2 = INPUT_FILE_PATH +
            "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_32kbps_m_1_17.3gp";
        final String imageItemFileName2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
        final String videoItemFileName3 = INPUT_FILE_PATH +
            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
        final String overlayFile = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
        final String audioTrackFilename = INPUT_FILE_PATH +
            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
        final String maskFilename = INPUT_FILE_PATH +
            "TransitionSpiral_QVGA.jpg";

        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFileName1, renderingMode);
        mediaItem1.setExtractBoundaries(0, 20000);
        mVideoEditor.addMediaItem(mediaItem1);

        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
            "m2", imageItemFileName1, 10000, renderingMode);
        mVideoEditor.addMediaItem(mediaItem2);

        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
            "m3", videoItemFileName2, renderingMode);
        mediaItem3.setExtractBoundaries(0, 20000);
        mVideoEditor.addMediaItem(mediaItem3);

        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
            "m4", imageItemFileName2, 10000, renderingMode);
        mVideoEditor.addMediaItem(mediaItem4);

        final MediaVideoItem mediaItem5 = new MediaVideoItem(mVideoEditor,
            "m5", videoItemFileName3, renderingMode);
        mediaItem5.setExtractBoundaries(0, 20000);
        mVideoEditor.addMediaItem(mediaItem5);
        /**
         * 7.Add TransitionAlpha, Apply this  Transition as Begin for Media Item 1
         *  with duration = 2 sec behavior = BEHAVIOR_LINEAR, mask file name =
         * TransitionSpiral_QVGA.jpg , blending percent = 50%, invert = true;
         * */
        final TransitionAlpha transition1 =
            mVideoEditorHelper.createTAlpha("transition1", null, mediaItem1,
                2000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, true);
        mVideoEditor.addTransition(transition1);

        /**
         * 8.Add Transition Sliding between MediaItem 2 and 3 ,
         *  Sliding Direction  = DIRECTION_RIGHT_OUT_LEFT_IN,
         *  behavior  = BEHAVIOR_MIDDLE_FAST and duration = 4sec
         * */
        final TransitionSliding transition2And3 =
            mVideoEditorHelper.createTSliding("transition2", mediaItem2,
                mediaItem3, 4000, Transition.BEHAVIOR_MIDDLE_FAST,
                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
        mVideoEditor.addTransition(transition2And3);

        /**
         * 9.Add Transition Crossfade between  Media Item 3 and 4,
         *  behavior = BEHAVIOR_MIDDLE_SLOW, duration = 3.5 sec
         * */
        final TransitionCrossfade transition3And4 =
            mVideoEditorHelper.createTCrossFade("transition3", mediaItem3,
                mediaItem4, 3500, Transition.BEHAVIOR_MIDDLE_SLOW);
        mVideoEditor.addTransition(transition3And4);

        /**
         * 10.Add Transition Fadeblack between  Media Item 4 and 5,
         *  behavior = BEHAVIOR_SPEED_DOWN, duration = 3.5 sec
         * */
        final TransitionFadeBlack transition4And5 =
            mVideoEditorHelper.createTFadeBlack("transition4", mediaItem4,
                mediaItem5, 3500, Transition.BEHAVIOR_SPEED_DOWN);
        mVideoEditor.addTransition(transition4And5);

        /**
         * 11.Add Effect 1 type="TYPE_SEPIA" to the MediaItem 1,
         *  start time=1sec and duration =4secs
         * */
        final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
            mediaItem1, "effect1", 1000, 4000, EffectColor.TYPE_SEPIA, 0);
        mediaItem1.addEffect(effectColor1);

        /**
         * 12.Add Overlay 1  to the MediaItem 3: Frame Overlay with start time = 1 sec
         * duration = 4 sec with item  = IMG_640x480_Overlay1.png
         * */
        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile, 640,
            480);
        final OverlayFrame overlayFrame =
            mVideoEditorHelper.createOverlay(mediaItem3, "overlay",
                mBitmap, 1000, 4000);
        mediaItem3.addOverlay(overlayFrame);
        /**
         * 13.Add Effect 2 type="TYPE_NEGATIVE" to the MediaItem 2,
         *  start time=8sec and duration =2secs
         * */
        final EffectColor effectColor2 = mVideoEditorHelper.createEffectItem(
            mediaItem2, "effect2", 8000, 2000, EffectColor.TYPE_NEGATIVE, 0);
        mediaItem2.addEffect(effectColor2);
        /**
         * 14.Add Effect 3 type="TYPE_COLOR" to the MediaItem 3, color param = "PINK",
         *  start time=5 sec and duration =3secs
         * */
        final EffectColor effectColor3 = mVideoEditorHelper.createEffectItem(
            mediaItem3, "effect3", 5000, 3000, EffectColor.TYPE_COLOR,
            EffectColor.PINK);
        mediaItem3.addEffect(effectColor3);
        /**
         * 15.Add Effect 4 type="TYPE_FIFTIES" to the MediaItem 4,
         *  start time=2 sec and duration =1secs
        * */
        final EffectColor effectColor4 = mVideoEditorHelper.createEffectItem(
            mediaItem4, "effect4", 2000, 1000, EffectColor.TYPE_FIFTIES, 0);
        mediaItem4.addEffect(effectColor4);
        /**
         * 16.Add KenBurnsEffect for MediaItem 4 with
         *  duration = 3 sec and startTime = 4 sec
         *  StartRect
         *  left = org_height/3  ;  top = org_width/3
         *  bottom = org_width/2  ;  right = org_height/2
         *  EndRect
         *  left = 0  ;  top = 0
         *  bottom =  org_height;  right =  org_width
         * */

        final Rect startRect = new Rect((mediaItem4.getHeight() / 3),
            (mediaItem4.getWidth() / 3), (mediaItem4.getHeight() / 2),
            (mediaItem4.getWidth() / 2));
        final Rect endRect = new Rect(0, 0, mediaItem4.getWidth(),
            mediaItem4.getHeight());
        final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
            mediaItem4, "KBOnM2", startRect, endRect,4000 , 3000);
        mediaItem4.addEffect(kbEffectOnMediaItem);

        /** 17.Add Audio Track,Set extract boundaries o to 10 sec.
         * */
        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
            mVideoEditor, "audioTrack", audioTrackFilename);
        mVideoEditor.addAudioTrack(audioTrack);
        /** 18.Enable Looping for Audio Track.
         * */
        audioTrack.enableLoop();
        int timeTaken = 0;
        final long beginTime = SystemClock.uptimeMillis();
            try {
                mVideoEditor.export(outFilename, outHeight, outBitrate,
                    new ExportProgressListener() {
                        public void onProgress(VideoEditor ve,
                            String outFileName, int progress) {
                        }
                    });
            } catch (Exception e) {
                assertTrue("Error in Export" + e.toString(), false);
            }
        mVideoEditorHelper.checkDeleteExistingFile(outFilename);

        timeTaken = calculateTimeTaken(beginTime, 1);
        loggingInfo[0] = "Time taken to do ONE export of storyboard duration "
            + mVideoEditor.getDuration() + " is :" + timeTaken;

        writeTimingInfo("testPerformanceExport (in mSec)", loggingInfo);
        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
    }


    /**
     * To test the performance of thumbnail extraction
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceThumbnailVideoItem() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final int videoItemStartTime = 0;
        final int videoItemEndTime = 20000;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[1];

        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFileName, renderingMode);
        mediaVideoItem.setExtractBoundaries(videoItemStartTime,
            videoItemEndTime);

        int timeTaken = 0;
        long beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            mediaVideoItem.getThumbnail(mediaVideoItem.getWidth() / 2,
                mediaVideoItem.getHeight() / 2, i);
        }
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[0] = "Duration taken to get Video Thumbnails :" +
            timeTaken;

        writeTimingInfo("testPerformanceThumbnailVideoItem (in mSec)", loggingInfo);
    }

    /**
     * To test the performance of adding and removing the overlay to media item
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceOverlayVideoItem() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final int videoItemStartTime1 = 0;
        final int videoItemEndTime1 = 10000;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String overlayFilename = INPUT_FILE_PATH
            + "IMG_640x480_Overlay1.png";
        final int overlayStartTime = 1000;
        final int overlayDuration = 5000;

        final String[] loggingInfo = new String[2];
        MediaVideoItem mediaVideoItem = null;

        try {
            mediaVideoItem = new MediaVideoItem(mVideoEditor, "m0",
                videoItemFileName1, renderingMode);
            mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
                videoItemEndTime1);
        } catch (Exception e1) {
            assertTrue("Can not create Video Item with file name = "
                + e1.toString(), false);
        }
        final OverlayFrame overlayFrame[] = new OverlayFrame[NUM_OF_ITERATIONS];
        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFilename,
            640, 480);
        int timeTaken = 0;
        long beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            overlayFrame[i] = new OverlayFrame(mediaVideoItem, "overlay" + i,
            mBitmap, overlayStartTime, overlayDuration);
            mediaVideoItem.addOverlay(overlayFrame[i]);
        }
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[0] = "Time taken to add & create Overlay :" + timeTaken;

        beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            assertEquals("Removing Overlays", overlayFrame[i],
                mediaVideoItem.removeOverlay((overlayFrame[i].getId())));
        }
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[1] = "\n\tTime taken to remove  Overlay :" +
            timeTaken;

        writeTimingInfo("testPerformanceOverlayVideoItem (in mSec)", loggingInfo);
    }

    /**
     * To test the performance of get properties of a Video media item
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceVideoItemProperties() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final int videoItemStartTime1 = 0;
        final int videoItemEndTime1 = 10100;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
        final int fileType = MediaProperties.FILE_MP4;
        final int videoCodecType = MediaProperties.VCODEC_H264;
        final int duration = 77366;
        final int videoBitrate = 3169971;
        final int fps = 30;
        final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline;
        final int videoLevel = MediaProperties.H264Level.H264Level13;
        final int width = 1080;
        final int height = MediaProperties.HEIGHT_720;
        int timeTaken = 0;
        final String[] loggingInfo = new String[1];
        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "m0", videoItemFileName1, renderingMode);
        mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
            videoItemEndTime1);
        long beginTime = SystemClock.uptimeMillis();
        for (int i = 0; i < (NUM_OF_ITERATIONS*10); i++) {
            try {
                assertEquals("Aspect Ratio Mismatch",
                    aspectRatio, mediaVideoItem.getAspectRatio());
                assertEquals("File Type Mismatch",
                    fileType, mediaVideoItem.getFileType());
                assertEquals("VideoCodec Mismatch",
                    videoCodecType, mediaVideoItem.getVideoType());
                assertEquals("duration Mismatch",
                    duration, mediaVideoItem.getDuration());
                assertEquals("Video Profile ",
                    videoProfile, mediaVideoItem.getVideoProfile());
                assertEquals("Video Level ",
                    videoLevel, mediaVideoItem.getVideoLevel());
                assertEquals("Video height ",
                    height, mediaVideoItem.getHeight());
                assertEquals("Video width ",
                    width, mediaVideoItem.getWidth());
            } catch (Exception e1) {
                assertTrue("Can not create Video Item with file name = "
                    + e1.toString(), false);
            }
        }
        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS*10));
        loggingInfo[0] = "Time taken to get Media Properties :"
            + timeTaken;
        writeTimingInfo("testPerformanceVideoItemProperties:", loggingInfo);
    }

    /**
     * To test the performance of generatePreview : with Transitions
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceGeneratePreviewWithTransitions()
        throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String imageItemFileName = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
        long averageTime = 0;
        final String[] loggingInfo = new String[1];

        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "mediaItem1", videoItemFileName, renderingMode);
        mediaVideoItem.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
            "mediaItem2", imageItemFileName, 10000, renderingMode);
        mVideoEditor.addMediaItem(mediaImageItem);

        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
            "transitionCrossFade", mediaVideoItem, mediaImageItem,
            5000, transitionBehavior);
        mVideoEditor.addTransition(transitionCrossFade);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
                public void onProgress(Object item, int action, int progress) {
                }
            });
            final long duration2 = SystemClock.uptimeMillis();
            mVideoEditor.removeTransition(transitionCrossFade.getId());
            mVideoEditor.addTransition(transitionCrossFade);
            averageTime += (duration2 - duration1);
        }
        final long durationToAddObjects = averageTime;
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] = "Time taken to Generate Preview with transition :"
            + timeTaken;
        writeTimingInfo("testPerformanceGeneratePreviewWithTransitions:",
            loggingInfo);
    }

    /**
     * To test the performance of generatePreview : with KenBurn
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceWithKenBurn() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String imageItemFileName = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        long averageTime = 0;
        final String[] loggingInfo = new String[1];
        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "mediaItem1", videoItemFileName, renderingMode);
        mediaVideoItem.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
            "mediaItem2", imageItemFileName, 10000, renderingMode);
        mVideoEditor.addMediaItem(mediaImageItem);

        final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
            (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
            (mediaImageItem.getWidth() / 2));
        final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
            mediaImageItem.getHeight());
        final EffectKenBurns kbEffectOnMediaItem =
            new EffectKenBurns(mediaImageItem, "KBOnM2", startRect, endRect,
                500, 3000);
        mediaImageItem.addEffect(kbEffectOnMediaItem);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
                public void onProgress(Object item, int action, int progress) {
                }
            });
            final long duration2 = SystemClock.uptimeMillis();
            mediaImageItem.removeEffect(kbEffectOnMediaItem.getId());
            mediaImageItem.addEffect(kbEffectOnMediaItem);
            averageTime += duration2 - duration1;
        }

        final long durationToAddObjects = (averageTime);
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] = "Time taken to Generate KenBurn Effect :"
            + timeTaken;
        writeTimingInfo("testPerformanceWithKenBurn", loggingInfo);
    }

    /**
     * To test the performance of generatePreview : with Transitions and
     * Effect,Overlapping scenario
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceEffectOverlappingTransition() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final int videoStartTime1 = 0;
        final int videoEndTime1 = 10000;
        final int videoStartTime2 = 0;
        final int videoEndTime2 = 10000;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int transitionDuration = 5000;
        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
        final int effectItemStartTime = 5000;
        final int effectItemDurationTime = 5000;
        final int effectType = EffectColor.TYPE_COLOR;
        final int effectColorType = EffectColor.GREEN;
        long averageDuration = 0;

        final String[] loggingInfo = new String[1];
        final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
            "mediaItem1", videoItemFileName1, renderingMode);
        mediaVideoItem1.setExtractBoundaries(videoStartTime1, videoEndTime1);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
            "mediaItem2", videoItemFileName2, renderingMode);
        mediaVideoItem2.setExtractBoundaries(videoStartTime2, videoEndTime2);
        mVideoEditor.addMediaItem(mediaVideoItem2);

        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
            "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
            transitionDuration, transitionBehavior);
        mVideoEditor.addTransition(transitionCrossFade);

        final EffectColor effectColor = new EffectColor(mediaVideoItem1,
            "effect", effectItemStartTime, effectItemDurationTime, effectType,
             effectColorType);
        mediaVideoItem1.addEffect(effectColor);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
                public void onProgress(Object item, int action, int progress) {
                }
            });
            final long duration2 = SystemClock.uptimeMillis();
            mVideoEditor.removeTransition(transitionCrossFade.getId());
            mVideoEditor.addTransition(transitionCrossFade);
            averageDuration += (duration2 - duration1);
        }
        SystemClock.uptimeMillis();
        final long durationToAddObjects = (averageDuration);
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] =
            "Time taken to testPerformanceEffectOverlappingTransition :"
            + timeTaken;
        writeTimingInfo("testPerformanceEffectOverlappingTransition:",
            loggingInfo);
    }

    /**
     * To test creation of story board with Transition and Two Effects, Effect
     * overlapping transitions
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceTransitionWithEffectOverlapping() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH
            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int transitionDuration = 5000;
        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
        final int effectItemStartTime1 = 5000;
        final int effectItemDurationTime1 = 5000;
        final int effectType1 = EffectColor.TYPE_COLOR;
        final int effectColorType1 = EffectColor.GREEN;
        final int effectItemStartTime2 = 5000;
        final int effectItemDurationTime2 = 5000;
        final int effectType2 = EffectColor.TYPE_COLOR;
        final int effectColorType2 = EffectColor.GREEN;
        int averageTime = 0;
        final String[] loggingInfo = new String[1];

        final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
            "mediaItem1", videoItemFileName1, renderingMode);
        mVideoEditor.addMediaItem(mediaVideoItem1);

        final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
            "mediaItem2", videoItemFileName2, renderingMode);
        mVideoEditor.addMediaItem(mediaVideoItem2);

        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
            "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
            transitionDuration, transitionBehavior);
        mVideoEditor.addTransition(transitionCrossFade);

        final EffectColor effectColor1 = new EffectColor(mediaVideoItem1,
            "effect1", effectItemStartTime1, effectItemDurationTime1,
            effectType1, effectColorType1);
        mediaVideoItem1.addEffect(effectColor1);

        final EffectColor effectColor2 = new EffectColor(mediaVideoItem2,
            "effect2", effectItemStartTime2, effectItemDurationTime2,
            effectType2, effectColorType2);
        mediaVideoItem2.addEffect(effectColor2);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
                public void onProgress(Object item, int action, int progress) {
                }
            });
            final long duration2 = SystemClock.uptimeMillis();
            mVideoEditor.removeTransition(transitionCrossFade.getId());
            mVideoEditor.addTransition(transitionCrossFade);
            averageTime += duration2 - duration1;
        }
        final long durationToAddObjects = (averageTime);
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] = "Time taken to TransitionWithEffectOverlapping :"
            + timeTaken;
        writeTimingInfo("testPerformanceTransitionWithEffectOverlapping",
            loggingInfo);
    }

    /**
     *To test ThumbnailList for H264
     */
    @LargeTest
    public void testThumbnailH264NonIFrame() throws Exception {
        final String videoItemFilename = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final int outWidth = 1080;
        final int outHeight = 720;
        final int atTime = 2400;
        long durationToAddObjects = 0;
        int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[1];
        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFilename, renderingMode);
        assertNotNull("MediaVideoItem", mediaVideoItem);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
            final long duration2 = SystemClock.uptimeMillis();
            durationToAddObjects += (duration2 - duration1);
        }
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] = "Time taken for Thumbnail generation :"
            + timeTaken;
        writeTimingInfo("testThumbnailH264NonIFrame", loggingInfo);
    }

    /**
     *To test ThumbnailList for H264
     */
    @LargeTest
    public void testThumbnailH264AnIFrame() throws Exception {
        final String videoItemFilename = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final int outWidth = 1080;
        final int outHeight = 720;
        final int atTime = 3000;
        int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[1];
        long durationToAddObjects = 0;

        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFilename, renderingMode);
        assertNotNull("MediaVideoItem", mediaVideoItem);

        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
            final long duration1 = SystemClock.uptimeMillis();
            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
            final long duration2 = SystemClock.uptimeMillis();
            durationToAddObjects += (duration2 - duration1);
        }
        final float timeTaken = (float)durationToAddObjects *
            1.0f/(float)NUM_OF_ITERATIONS;
        loggingInfo[0] = "Time taken Thumbnail generation :"
            + timeTaken;
        writeTimingInfo("testThumbnailH264AnIFrame", loggingInfo);
    }

    /**
     * To test the performance : With an audio track
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceWithAudioTrack() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String audioFilename1 = INPUT_FILE_PATH +
            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
        final String audioFilename2 = INPUT_FILE_PATH +
            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int audioVolume = 50;
        final String[] loggingInfo = new String[2];
        int timeTaken = 0;

        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "mediaItem1", videoItemFileName1, renderingMode);
        mVideoEditor.addMediaItem(mediaVideoItem);

        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
            "Audio Track1", audioFilename1);
        audioTrack1.disableDucking();
        audioTrack1.setVolume(audioVolume);
        mVideoEditor.addAudioTrack(audioTrack1);

        long beginTime = SystemClock.uptimeMillis();
        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            public void onProgress(Object item, int action, int progress) {
            }
        });
        timeTaken = calculateTimeTaken(beginTime, 1);
        loggingInfo[0] = "Time taken for 1st Audio Track (AACLC) :"
            + timeTaken;

        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
            "Audio Track2", audioFilename2);
        audioTrack2.enableLoop();

        beginTime = SystemClock.uptimeMillis();
        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
            public void onProgress(Object item, int action, int progress) {
            }
        });
        timeTaken = calculateTimeTaken(beginTime, 1);
        loggingInfo[1] = "\n\tTime taken for 2nd Audio Track(AMRNB) :"
            + timeTaken;

        writeTimingInfo("testPerformanceWithAudioTrack", loggingInfo);
    }

    /**
     * To test the performance of adding and removing the
     * image media item with 640 x 480
     *
     * @throws Exception
     */
    @LargeTest
    public void testPerformanceAddRemoveImageItem640x480() throws Exception {
        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
        final int imageItemDuration = 0;
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[3];

        int timeTaken = 0;

        final MediaImageItem[] mediaImageItem =
            new MediaImageItem[NUM_OF_ITERATIONS];
        long beginTime = SystemClock.uptimeMillis();
        createImageItems(mediaImageItem, imageItemFileName, renderingMode,
            imageItemDuration);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[0] = "Time taken to Create  Media Image Item (640x480) :"
            + timeTaken;

        beginTime = SystemClock.uptimeMillis();
        addImageItems(mediaImageItem);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[1] = "\n\tTime taken to add  Media Image Item (640x480) :"
            + timeTaken;

        beginTime = SystemClock.uptimeMillis();
        removeImageItems(mediaImageItem);
        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
        loggingInfo[2] = "\n\tTime taken to remove  Media Image Item (640x480) :"
            + timeTaken;
        writeTimingInfo("testPerformanceAddRemoveImageItem640x480 (in mSec)", loggingInfo);
    }


}