/*
 * 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.stress;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.Writer;
import java.util.List;

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.media.videoeditor.VideoEditorFactory;
import android.media.videoeditor.ExtractAudioWaveformProgressListener;

import android.os.Debug;
import android.util.Log;
import com.android.mediaframeworktest.MediaFrameworkPerfTestRunner;
import com.android.mediaframeworktest.MediaFrameworkTest;
import android.test.suitebuilder.annotation.LargeTest;
import com.android.mediaframeworktest.VideoEditorHelper;
import com.android.mediaframeworktest.MediaTestUtil;

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

    private final String TAG = "VideoEditorStressTest";

    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 +
        "VideoEditorStressMemOutput.txt";

    private long BeginJavaMemory;
    private long AfterJavaMemory;

    private long BeginNativeMemory;
    private long AfterNativeMemory;

    public VideoEditorStressTest() {
        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
        new File(VIDEOEDITOR_OUTPUT).delete();
    }

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

    @Override
    protected void setUp() throws Exception {
        // setup for each test case.
        super.setUp();
        getActivity();
        mMediaTestUtil = new MediaTestUtil(
            "/sdcard/VideoEditorMediaServerMemoryLog.txt",
             this.getName(), "mediaserver");
        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 {
        final String[] loggingInfo = new String[1];
        mMediaTestUtil.getMemorySummary();
        loggingInfo[0] = "\n" +this.getName();
        writeTimingInfo(loggingInfo);
        loggingInfo[0] = " diff :  " + (AfterNativeMemory - BeginNativeMemory);
        writeTimingInfo(loggingInfo);
        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
        // Clean the directory created as project path
        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
        System.gc();
        super.tearDown();
    }

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

    private void writeTestCaseHeader(String testCaseName)
        throws Exception {
        File outFile = new File(VIDEOEDITOR_OUTPUT);
        Writer output = new BufferedWriter(new FileWriter(outFile, true));
        output.write("\n\n" + testCaseName + "\n");
        output.close();
    }

    private void getBeginMemory() throws Exception {
        System.gc();
        Thread.sleep(2500);
        BeginNativeMemory = Debug.getNativeHeapAllocatedSize();
        mMediaTestUtil.getStartMemoryLog();
    }
    private void getAfterMemory_updateLog(String[] loggingInfo, boolean when,
        int iteration)
        throws Exception {
        System.gc();
        Thread.sleep(2500);
        AfterNativeMemory = Debug.getNativeHeapAllocatedSize();
        if(when == false){
            loggingInfo[0] = "\n Before Remove: iteration No.= " + iteration +
                "\t " + (AfterNativeMemory - BeginNativeMemory);
        } else {
            loggingInfo[0] = "\n After Remove: iteration No.= " + iteration +
                "\t " + (AfterNativeMemory - BeginNativeMemory);
        }
        writeTimingInfo(loggingInfo);
        mMediaTestUtil.getMemoryLog();
    }

    /**
     * To stress test MediaItem(Video Item) adding functionality
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAddRemoveVideoItem() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;

        final String videoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_176x144_15fps_144kbps_AMRNB_8kHz_12.2kbps_m_1_17.3gp";
        final String videoItemFileName2 = INPUT_FILE_PATH +
            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
        final String videoItemFileName3 = INPUT_FILE_PATH +
            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
        final String videoItemFileName4 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
        final String[] loggingInfo = new String[1];
        writeTestCaseHeader("testStressAddRemoveVideoItem");
        int i = 0;
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
                    "m1" + i, videoItemFileName1, renderingMode);
                mediaItem1.setExtractBoundaries(0, 5000);
                mVideoEditor.addMediaItem(mediaItem1);
            }
            if (i % 4 == 1) {
                final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
                    "m2" + i, videoItemFileName2, renderingMode);
                mediaItem2.setExtractBoundaries(0, 10000);
                mVideoEditor.addMediaItem(mediaItem2);
            }
            if (i % 4 == 2) {
                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
                    "m3" + i, videoItemFileName3, renderingMode);
                mediaItem3.setExtractBoundaries(30000, 45000);
                mVideoEditor.addMediaItem(mediaItem3);
            }
            if (i % 4 == 3) {
                final MediaVideoItem mediaItem4 = new MediaVideoItem(mVideoEditor,
                    "m4" + i, videoItemFileName4, renderingMode);
                mediaItem4.setExtractBoundaries(10000, 30000);
                mVideoEditor.addMediaItem(mediaItem4);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                mVideoEditor.removeMediaItem("m1" + i);
            }
            if (i % 4 == 1) {
                mVideoEditor.removeMediaItem("m2" + i);
            }
            if (i % 4 == 2) {
                mVideoEditor.removeMediaItem("m3" + i);
            }
            if (i % 4 == 3) {
                mVideoEditor.removeMediaItem("m4" + i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, true, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test MediaItem(Image Item) adding functionality
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAddRemoveImageItem() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String ImageItemFileName1 = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_640x480.jpg";
        final String ImageItemFileName3 = INPUT_FILE_PATH +
            "IMG_320x240.jpg";
        final String ImageItemFileName4 = INPUT_FILE_PATH +
            "IMG_176x144.jpg";
        final String[] loggingInfo = new String[1];
        int i = 0;
        writeTestCaseHeader("testStressAddRemoveImageItem");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                final MediaImageItem mediaItem1 = new MediaImageItem(mVideoEditor,
                    "m1"+ i, ImageItemFileName1, 5000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem1);
            }
            if (i % 4 == 1) {
                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
                    "m2"+ i, ImageItemFileName2, 10000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem2);
            }
            if (i % 4 == 2) {
                final MediaImageItem mediaItem3 = new MediaImageItem(mVideoEditor,
                    "m3"+ i, ImageItemFileName3, 15000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem3);
            }
            if (i % 4 == 3) {
                final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
                    "m4"+ i, ImageItemFileName4, 20000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem4);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                mVideoEditor.removeMediaItem("m1"+i);
            }
            if (i % 4 == 1) {
                mVideoEditor.removeMediaItem("m2"+i);
            }
            if (i % 4 == 2) {
                mVideoEditor.removeMediaItem("m3"+i);
            }
            if (i % 4 == 3) {
                mVideoEditor.removeMediaItem("m4"+i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, true, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test transition
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAddRemoveTransition() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final String VideoItemFileName3 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final String maskFilename = INPUT_FILE_PATH +
            "TransitionSpiral_QVGA.jpg";
        final String[] loggingInfo = new String[1];
        int i = 0;
        writeTestCaseHeader("testStressAddRemoveTransition");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
                    "m1"+i, VideoItemFileName1, renderingMode);
                mVideoEditor.addMediaItem(mediaItem1);
                mediaItem1.setExtractBoundaries(0, 10000);
                final TransitionCrossfade tranCrossfade =
                    new TransitionCrossfade("transCF" + i, null,
                        mediaItem1, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
                mVideoEditor.addTransition(tranCrossfade);
            }
            if (i % 4 == 1) {
                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
                    "m1"+i, VideoItemFileName1, renderingMode);
                mVideoEditor.addMediaItem(mediaItem1);
                mediaItem1.setExtractBoundaries(0, 10000);

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

                final TransitionAlpha transitionAlpha =
                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem1,
                        mediaItem2, 5000, Transition.BEHAVIOR_SPEED_UP,
                        maskFilename, 10, false);
                transitionAlpha.setDuration(4000);
                mVideoEditor.addTransition(transitionAlpha);
            }
            if (i % 4 == 2) {
                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem2);

                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
                    "m3" + i, VideoItemFileName3, renderingMode);
                mVideoEditor.addMediaItem(mediaItem3);

                mediaItem3.setExtractBoundaries(0, 10000);
                final TransitionAlpha transitionAlpha =
                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem2,
                        mediaItem3, 5000, Transition.BEHAVIOR_SPEED_UP,
                        maskFilename, 10, false);
                transitionAlpha.setDuration(4000);
                mVideoEditor.addTransition(transitionAlpha);

                mediaItem3.setExtractBoundaries(0, 6000);

                final TransitionSliding transition2And3 =
                    mVideoEditorHelper.createTSliding("transSlide" +i, mediaItem2,
                        mediaItem3, 3000, Transition.BEHAVIOR_MIDDLE_FAST,
                        TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
                mVideoEditor.addTransition(transition2And3);
            }
            if (i % 4 == 3) {
                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
                    "m3" + i, VideoItemFileName3, renderingMode);
                mVideoEditor.addMediaItem(mediaItem3);
                mediaItem3.setExtractBoundaries(0, 5000);

                final TransitionFadeBlack transition3 =
                    mVideoEditorHelper.createTFadeBlack("transFB" +i, mediaItem3,
                        null, 2500, Transition.BEHAVIOR_SPEED_UP);
                transition3.setDuration(500);
                mVideoEditor.addTransition(transition3);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                mVideoEditor.removeTransition("transCF" + i);
                mVideoEditor.removeMediaItem("m1" + i);
            }
            if (i % 4 == 1) {
                mVideoEditor.removeTransition("transAlpha" + i);
                mVideoEditor.removeMediaItem("m1" + i);
                mVideoEditor.removeMediaItem("m2" + i);
            }
            if (i % 4 == 2) {
                mVideoEditor.removeTransition("transSlide" +i);
                mVideoEditor.removeMediaItem("m2" + i);
                mVideoEditor.removeMediaItem("m3" + i);
            }
            if (i % 4 == 3) {
                mVideoEditor.removeMediaItem("m3" + i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, true, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test overlay
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAddRemoveOverlay() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_640x480.jpg";
        final String OverlayFile3 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";
        final String OverlayFile4 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay2.png";
        final String[] loggingInfo = new String[1];
        int i = 0;
        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
            "m1", VideoItemFileName1, renderingMode);
        mVideoEditor.addMediaItem(mediaItem1);

        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
            "m2", ImageItemFileName2, 10000, renderingMode);
        mVideoEditor.addMediaItem(mediaItem2);
        writeTestCaseHeader("testStressAddRemoveOverlay");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 3 == 0) {
                mediaItem1.setExtractBoundaries(0, 10000);
                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
                    OverlayFile3, 640, 480);
                final OverlayFrame overlayFrame =
                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
                        mBitmap, 1000, 5000);
                mediaItem1.addOverlay(overlayFrame);
                mediaItem1.removeOverlay("overlay"+i);
            }
            if (i % 3 == 1) {
                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
                    OverlayFile4, 640, 480);
                final OverlayFrame overlayFrame =
                    mVideoEditorHelper.createOverlay(mediaItem2, "overlay" + i,
                        mBitmap, 1000, 5000);
                mediaItem2.addOverlay(overlayFrame);
                mediaItem2.removeOverlay("overlay"+i);
            }
            if (i % 3 == 2) {
                mediaItem1.setExtractBoundaries(0, 10000);
                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
                    OverlayFile4, 640, 480);
                final OverlayFrame overlayFrame =
                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
                        mBitmap, 0, mediaItem1.getDuration());
                mediaItem1.addOverlay(overlayFrame);
                mediaItem1.removeOverlay("overlay"+i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);
    }

    /**
     * To stress test Effects
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAddRemoveEffects() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final String[] loggingInfo = new String[1];
        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
            "m1", VideoItemFileName1, renderingMode);
        mVideoEditor.addMediaItem(mediaItem1);
        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
            "m2", ImageItemFileName2, 10000, renderingMode);
        int i = 0;
        mVideoEditor.addMediaItem(mediaItem2);
        writeTestCaseHeader("testStressAddRemoveEffects");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 5 == 0) {
                mediaItem1.setExtractBoundaries(10000, 30000);
                final EffectColor effectColor1 =
                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
                        10000, (mediaItem1.getTimelineDuration()-1000),
                        EffectColor.TYPE_COLOR, EffectColor.GREEN);
                mediaItem1.addEffect(effectColor1);
            }
            if (i % 5 == 1) {
                mediaItem2.setDuration(20000);
                final EffectColor effectColor1 =
                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
                        0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
                mediaItem2.addEffect(effectColor1);
            }
            if (i % 5 == 2) {
                mediaItem1.setExtractBoundaries(10000, 30000);
                final EffectColor effectColor1 =
                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
                        (mediaItem1.getTimelineDuration() - 4000), 4000,
                        EffectColor.TYPE_SEPIA, 0);
                mediaItem1.addEffect(effectColor1);
            }
            if (i % 5 == 3) {
                mediaItem2.setDuration(20000);
                final EffectColor effectColor1 =
                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
                        10000, 4000, EffectColor.TYPE_NEGATIVE, 0);
                mediaItem2.addEffect(effectColor1);
            }
            if (i % 5 == 4) {
                mediaItem2.setDuration(20000);
                final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
                    (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
                    (mediaItem2.getWidth() / 2));
                final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
                    mediaItem2.getHeight());
                final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
                    mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
                    (mediaItem2.getDuration() - 500));
                mediaItem2.addEffect(kbEffectOnMediaItem);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 50; i++) {
            if (i % 5 == 0) {
                mediaItem1.removeEffect("effect1"+i);
            }
            if (i % 5 == 1) {
                mediaItem1.removeEffect("effect1"+i);
            }
            if (i % 5 == 2) {
                mediaItem1.removeEffect("effect1"+i);
            }
            if (i % 5 == 3) {
                mediaItem1.removeEffect("effect1"+i);
            }
            if (i % 5 == 4) {
                mediaItem1.removeEffect("KBOnM2"+i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, true, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * This method will test thumbnail list extraction in a loop = 200 for Video
     * Item
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressThumbnailVideoItem() throws Exception {
        final String videoItemFileName = INPUT_FILE_PATH
                + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[1];
        int i = 0;
        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFileName, renderingMode);
        writeTestCaseHeader("testStressThumbnailVideoItem");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                final Bitmap[] thumbNails =
                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*3,
                        mediaVideoItem.getHeight()/2, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 1) {
                final Bitmap[] thumbNails =
                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()/2,
                        mediaVideoItem.getHeight() * 3, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 2) {
                final Bitmap[] thumbNails =
                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*2,
                        mediaVideoItem.getHeight() / 3, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 3) {
                final Bitmap[] thumbNails =
                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth(),
                        mediaVideoItem.getHeight(), i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);
    }

    /**
     * To stress test media properties
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressMediaProperties() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_640x480.jpg";
        final String AudioItemFileName3 = INPUT_FILE_PATH +
            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
        final String[] loggingInfo = new String[1];
        int i = 0;
        final int videoAspectRatio = MediaProperties.ASPECT_RATIO_3_2;
        final int videoFileType = MediaProperties.FILE_MP4;
        final int videoCodecType = MediaProperties.VCODEC_H264;
        final int videoDuration = 77366;
        final int videoProfile = MediaProperties.H264Profile.H264ProfileBaseline;
        final int videoLevel = MediaProperties.H264Level.H264Level13;
        final int videoHeight = MediaProperties.HEIGHT_720;
        final int videoWidth = 1080;

        final int imageAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
        final int imageFileType = MediaProperties.FILE_JPEG;
        final int imageWidth = 640;
        final int imageHeight = MediaProperties.HEIGHT_480;

        final int audioDuration = 77554;
        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
        final int audioSamplingFrequency = 44100;
        final int audioChannel = 2;
        writeTestCaseHeader("testStressMediaProperties");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 3 == 0) {
                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
                    "m1" + i, VideoItemFileName1, renderingMode);
                mVideoEditor.addMediaItem(mediaItem1);
                mediaItem1.setExtractBoundaries(0, 20000);
                assertEquals("Aspect Ratio Mismatch",
                    videoAspectRatio, mediaItem1.getAspectRatio());
                assertEquals("File Type Mismatch",
                    videoFileType, mediaItem1.getFileType());
                assertEquals("VideoCodec Mismatch",
                    videoCodecType, mediaItem1.getVideoType());
                assertEquals("duration Mismatch",
                    videoDuration, mediaItem1.getDuration());
                assertEquals("Video Profile ",
                    videoProfile, mediaItem1.getVideoProfile());
                assertEquals("Video Level ",
                    videoLevel, mediaItem1.getVideoLevel());
                assertEquals("Video height ",
                    videoHeight, mediaItem1.getHeight());
                assertEquals("Video width ",
                    videoWidth, mediaItem1.getWidth());
                mVideoEditor.removeMediaItem("m1" + i);
            }
            if (i % 3 == 1) {
                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
                mVideoEditor.addMediaItem(mediaItem2);
                assertEquals("Aspect Ratio Mismatch",
                    imageAspectRatio, mediaItem2.getAspectRatio());
                assertEquals("File Type Mismatch",
                    imageFileType, mediaItem2.getFileType());
                assertEquals("Image height",
                    imageHeight, mediaItem2.getHeight());
                assertEquals("Image width",
                    imageWidth, mediaItem2.getWidth());
                mVideoEditor.removeMediaItem("m2" + i);
            }
            if (i % 3 == 2) {
                final AudioTrack mediaItem3 = new AudioTrack(mVideoEditor,
                    "m3" + i, AudioItemFileName3);
                mVideoEditor.addAudioTrack(mediaItem3);
                assertEquals("AudioType Mismatch", audioCodecType,
                    mediaItem3.getAudioType());
                assertEquals("Audio Sampling", audioSamplingFrequency,
                    mediaItem3.getAudioSamplingFrequency());
                assertEquals("Audio Channels",
                    audioChannel, mediaItem3.getAudioChannels());
                assertEquals("duration Mismatch", audioDuration,
                    mediaItem3.getDuration());
                mVideoEditor.removeAudioTrack("m3" + i);
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);
    }

    /**
     * To stress test insert and move of mediaitems
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressInsertMovieItems() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String VideoItemFileName2 = INPUT_FILE_PATH +
            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
        final String VideoItemFileName3 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
        final String[] loggingInfo = new String[1];
        int i = 0;
        writeTestCaseHeader("testStressInsertMovieItems");

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

        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
            "m2", VideoItemFileName2, renderingMode);
        mVideoEditor.addMediaItem(mediaItem2);
        mediaItem2.setExtractBoundaries(0, 15000);

        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
                "m3" + i, VideoItemFileName3, renderingMode);
            mediaItem3.setExtractBoundaries(0, 15000);
            mVideoEditor.insertMediaItem(mediaItem3, "m1");
            mVideoEditor.moveMediaItem("m2", "m3" + i);
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 50; i++) {
            mVideoEditor.removeMediaItem("m3" + i);
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, true, i);
            }
        }
        mVideoEditor.removeMediaItem("m2");
        mVideoEditor.removeMediaItem("m1");
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test : load and save
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressLoadAndSave() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String VideoItemFileName2 = INPUT_FILE_PATH +
            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
        final String VideoItemFileName3 = INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
        final String ImageItemFileName4 = INPUT_FILE_PATH +
            "IMG_640x480.jpg";
        final String ImageItemFileName5 = INPUT_FILE_PATH +
            "IMG_176x144.jpg";
        final String OverlayFile6 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";
        final String[] loggingInfo = new String[1];
        int i = 0;
        final String[] projectPath = new String[10];
        writeTestCaseHeader("testStressLoadAndSave");
        getBeginMemory();
        for( i=0; i < 10; i++){

            projectPath[i] =
                mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
            final VideoEditor mVideoEditor1 =
                mVideoEditorHelper.createVideoEditor(projectPath[i]);

            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor1,
                "m1", VideoItemFileName1, renderingMode);
            mVideoEditor1.addMediaItem(mediaItem1);
            mediaItem1.setExtractBoundaries(0, 10000);

            final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor1,
                "m2", VideoItemFileName2, renderingMode);
            mVideoEditor1.addMediaItem(mediaItem2);
            mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
                mediaItem2.getDuration()/2);

            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor1,
                "m3", VideoItemFileName3, renderingMode);
            mVideoEditor1.addMediaItem(mediaItem3);
            mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
                mediaItem3.getDuration());

            final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor1,
                "m4", ImageItemFileName4, 5000, renderingMode);
            mVideoEditor1.addMediaItem(mediaItem4);

            final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor1,
                "m5", ImageItemFileName5, 5000, renderingMode);
            mVideoEditor1.addMediaItem(mediaItem5);

            final EffectColor effectColor1 =
                mVideoEditorHelper.createEffectItem(mediaItem3, "effect1",
                    10000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
            mediaItem3.addEffect(effectColor1);

            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile6,
                640, 480);
            final OverlayFrame overlayFrame =
                mVideoEditorHelper.createOverlay(mediaItem4, "overlay",
                    mBitmap, 4000, 1000);
            mediaItem4.addOverlay(overlayFrame);

            final TransitionCrossfade tranCrossfade =
                new TransitionCrossfade("transCF", mediaItem1,
                    mediaItem2, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
            mVideoEditor1.addTransition(tranCrossfade);

            final EffectColor effectColor2 =
                mVideoEditorHelper.createEffectItem(mediaItem4, "effect2", 0,
                    mediaItem4.getDuration(), EffectColor.TYPE_COLOR,
                    EffectColor.PINK);
            mediaItem4.addEffect(effectColor2);

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

            mVideoEditor1.save();
            mVideoEditor1.release();

            getAfterMemory_updateLog(loggingInfo, false, i);
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for( i=0; i<10; i++){
            final VideoEditor mVideoEditor1b =
                VideoEditorFactory.load(projectPath[i], true);
            List<MediaItem> mediaList = mVideoEditor1b.getAllMediaItems();
            assertEquals("Media Item List Size", 5, mediaList.size());

            mediaList.get(3).removeEffect("effect1");
            mediaList.get(3).removeEffect("effect2");
            mediaList.get(2).removeOverlay("overlay");
            mVideoEditor1b.removeTransition("transCF");
            mVideoEditor1b.removeMediaItem("m5");
            mVideoEditor1b.removeMediaItem("m4");
            mVideoEditor1b.removeMediaItem("m3");
            mVideoEditor1b.removeMediaItem("m2");
            mVideoEditor1b.removeMediaItem("m1");
            mVideoEditor1b.release();
            getAfterMemory_updateLog(loggingInfo, true, i);
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test : Multiple Export
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressMultipleExport() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
        final String VideoItemFileName2 = INPUT_FILE_PATH +
            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
        final String[] loggingInfo = new String[1];
        final String outFilename = mVideoEditorHelper.createRandomFile(
            mVideoEditor.getPath() + "/") + ".3gp";
        int i = 0;
        writeTestCaseHeader("testStressMultipleExport");
        getBeginMemory();
        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
            "m1", VideoItemFileName1, renderingMode);
        mVideoEditor.addMediaItem(mediaItem1);
        mediaItem1.setExtractBoundaries(0, 10000);

        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
            "m2", VideoItemFileName2, renderingMode);
        mVideoEditor.addMediaItem(mediaItem2);
        mediaItem2.setExtractBoundaries(0, 15000);

        for ( i = 0; i < 50; i++) {
            if(i%4 ==0){
                final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
                mVideoEditor.setAspectRatio(aspectRatio);
                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_288,
                    MediaProperties.BITRATE_256K,MediaProperties.ACODEC_AAC_LC,
                        MediaProperties.VCODEC_H263,
                        new ExportProgressListener() {
                        public void onProgress(VideoEditor ve, String outFileName,
                            int progress) {
                        }
                    });
            }
            if(i%4 ==1){
                final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
                mVideoEditor.setAspectRatio(aspectRatio);
                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
                    MediaProperties.BITRATE_384K,MediaProperties.ACODEC_AAC_LC,
                        MediaProperties.VCODEC_MPEG4,
                        new ExportProgressListener() {
                        public void onProgress(VideoEditor ve, String outFileName,
                            int progress) {
                        }
                    });
            }
            if(i%4 ==2){
                final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
                mVideoEditor.setAspectRatio(aspectRatio);
                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
                    MediaProperties.BITRATE_512K,MediaProperties.ACODEC_AAC_LC,
                        MediaProperties.VCODEC_H264,
                        new ExportProgressListener() {
                        public void onProgress(VideoEditor ve, String outFileName,
                            int progress) {
                        }
                    });
            }
            if(i%4 ==3){
                final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
                mVideoEditor.setAspectRatio(aspectRatio);
                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
                    MediaProperties.BITRATE_800K,MediaProperties.ACODEC_AAC_LC,
                        MediaProperties.VCODEC_H264,
                        new ExportProgressListener() {
                        public void onProgress(VideoEditor ve, String outFileName,
                            int progress) {
                        }
                    });
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        mVideoEditor.removeMediaItem("m2");
        mVideoEditor.removeMediaItem("m1");

        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To stress test Media Item,Overlays,Transitions and Ken Burn
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressOverlayTransKenBurn() throws Exception {
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String VideoItemFileName1 = INPUT_FILE_PATH +
            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
        final String ImageItemFileName2 = INPUT_FILE_PATH +
            "IMG_640x480.jpg";
        final String OverlayFile3 = INPUT_FILE_PATH +
            "IMG_640x480_Overlay1.png";
        final String audioFilename4 = INPUT_FILE_PATH +
            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
        int i = 0;
        final String[] loggingInfo = new String[1];
        writeTestCaseHeader("testStressOverlayTransKenBurn");
        getBeginMemory();
        for ( i = 0; i < 10; i++) {
            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
                "m1" + i, VideoItemFileName1, renderingMode);
            mVideoEditor.addMediaItem(mediaItem1);
            mediaItem1.setExtractBoundaries(0, 10000);

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

            final EffectColor effectColor1 =
                mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
                    (mediaItem1.getDuration() - 4000), 4000,
                    EffectColor.TYPE_SEPIA, 0);
            mediaItem1.addEffect(effectColor1);

            final TransitionCrossfade tranCrossfade =
                new TransitionCrossfade("transCF" + i, mediaItem1,
                    mediaItem2, 4000, Transition.BEHAVIOR_MIDDLE_FAST);
            mVideoEditor.addTransition(tranCrossfade);

            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile3,
                640, 480);
            final OverlayFrame overlayFrame =
                mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
                    mBitmap, 1000, 5000);
            mediaItem1.addOverlay(overlayFrame);

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

            final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
                mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
                (mediaItem2.getDuration()-500));
            mediaItem2.addEffect(kbEffectOnMediaItem);

            if(i == 5) {
                final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
                    "Audio Track1", audioFilename4);
                mVideoEditor.addAudioTrack(audioTrack1);
            }
            getAfterMemory_updateLog(loggingInfo, false, i);
        }
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        for ( i = 0; i < 10; i++) {
            MediaImageItem m2 = (MediaImageItem)mVideoEditor.getMediaItem("m2"+i);
            MediaVideoItem m1 = (MediaVideoItem)mVideoEditor.getMediaItem("m1"+i);
            m2.removeEffect("KBOnM2" + i);
            m1.removeOverlay("overlay" + i);
            mVideoEditor.removeTransition("transCF" + i);
            m1.removeEffect("effect1" + i);
            mVideoEditor.removeMediaItem("m2" + i);
            mVideoEditor.removeMediaItem("m1" + i);
            if(i == 5) {
                mVideoEditor.removeAudioTrack("Audio Track1");
            }
            getAfterMemory_updateLog(loggingInfo, true, i);
        }
        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To test the performance : With an audio track with Video
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAudioTrackVideo() 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[1];
        int i = 1;
        writeTestCaseHeader("testStressAudioTrackVideo");
        getBeginMemory();
        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);

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

        mVideoEditor.removeAudioTrack("Audio Track1");

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

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

        /** Remove items and check for memory leak if any */
        mVideoEditor.removeMediaItem("mediaItem1");

        getAfterMemory_updateLog(loggingInfo, true, i);
    }

    /**
     * To Test Stress : Story Board creation with out preview or export
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressStoryBoard() throws Exception {
        final String videoItemFileName1 = INPUT_FILE_PATH +
            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
        final String videoItemFileName2 = INPUT_FILE_PATH +
            "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
        final String videoItemFileName3= INPUT_FILE_PATH +
            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
        final String imageItemFileName4 = INPUT_FILE_PATH +
            "IMG_1600x1200.jpg";
        final String imageItemFileName5 = INPUT_FILE_PATH +
            "IMG_176x144.jpg";
        final String audioFilename6 = INPUT_FILE_PATH +
            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
        final String audioFilename7 = INPUT_FILE_PATH +
            "AACLC_44.1kHz_256kbps_s_1_17.mp4";

        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final int audioVolume = 50;
        final String[] loggingInfo = new String[1];
        int i = 1;

        writeTestCaseHeader("testStressStoryBoard");
        getBeginMemory();
        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
            "m1", videoItemFileName1, renderingMode);
        mediaItem1.setExtractBoundaries(0, 10000);
        mVideoEditor.addMediaItem(mediaItem1);

        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
            "m2", videoItemFileName2, renderingMode);
        mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
            mediaItem2.getDuration()/2);
        mVideoEditor.addMediaItem(mediaItem2);

        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
            "m3", videoItemFileName3, renderingMode);
        mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
            mediaItem3.getDuration());
        mVideoEditor.addMediaItem(mediaItem3);

        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
            "m4", imageItemFileName4, 5000, renderingMode);
        mVideoEditor.addMediaItem(mediaItem4);

        final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor,
            "m5", imageItemFileName5, 5000, renderingMode);
        mVideoEditor.addMediaItem(mediaItem5);

        final TransitionCrossfade tranCrossfade =
            new TransitionCrossfade("transCF", mediaItem2, mediaItem3, 2500,
                Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(tranCrossfade);

        final TransitionCrossfade tranCrossfade1 =
            new TransitionCrossfade("transCF1", mediaItem3, mediaItem4, 2500,
                Transition.BEHAVIOR_MIDDLE_FAST);
        mVideoEditor.addTransition(tranCrossfade1);

        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
            "Audio Track1", audioFilename6);
        mVideoEditor.addAudioTrack(audioTrack1);

        mVideoEditor.removeAudioTrack("Audio Track1");
        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
            "Audio Track2", audioFilename7);
        mVideoEditor.addAudioTrack(audioTrack2);
        audioTrack2.enableLoop();
        getAfterMemory_updateLog(loggingInfo, false, i);

        /** Remove items and check for memory leak if any */
        getBeginMemory();
        mVideoEditor.removeAudioTrack("Audio Track2");
        mVideoEditor.removeTransition("transCF");
        mVideoEditor.removeTransition("transCF1");
        mVideoEditor.removeMediaItem("m5");
        mVideoEditor.removeMediaItem("m4");
        mVideoEditor.removeMediaItem("m3");
        mVideoEditor.removeMediaItem("m2");
        mVideoEditor.removeMediaItem("m1");

        getAfterMemory_updateLog(loggingInfo, true, i);
    }

     /**
     * To test the performance : With an audio track Only
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressAudioTrackOnly() throws Exception {

        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String AudioItemFileName1 = INPUT_FILE_PATH +
            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
        final String[] loggingInfo = new String[1];
        int i = 0;
        writeTestCaseHeader("testStressAudioTrackOnly");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            final AudioTrack mediaItem1 = new AudioTrack(mVideoEditor,
                "m1" + i, AudioItemFileName1);
            mVideoEditor.addAudioTrack(mediaItem1);
            mediaItem1.enableLoop();
            mVideoEditor.removeAudioTrack("m1" + i);
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);
    }

    /**
     * This method will test thumbnail list extraction in a loop = 200 for Image
     * Item
     *
     * @throws Exception
     */
    @LargeTest
    public void testStressThumbnailImageItem() throws Exception {
        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
        final String[] loggingInfo = new String[1];
        int i = 0;
        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
            "m1", imageItemFileName, 5000, renderingMode);
        writeTestCaseHeader("testStressThumbnailImageItem");
        getBeginMemory();
        for ( i = 0; i < 50; i++) {
            if (i % 4 == 0) {
                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
                    mediaImageItem.getWidth() / 2 ,
                    mediaImageItem.getHeight() / 2, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 1) {
                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
                    mediaImageItem.getWidth() / 2,
                    mediaImageItem.getHeight() * 3, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 2) {
                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
                    mediaImageItem.getWidth() * 2,
                    mediaImageItem.getHeight() / 3, i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 4 == 3) {
                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
                    mediaImageItem.getWidth(),
                    mediaImageItem.getHeight(), i, 5000, 2);
                // Recycle this Bitmap array
                for (int i1 = 0; i1 < thumbNails.length; i1++) {
                    thumbNails[i1].recycle();
                }
            }
            if (i % 10 == 0) {
                getAfterMemory_updateLog(loggingInfo, false, i);
            }
        }
        getAfterMemory_updateLog(loggingInfo, false, i);
    }
}
