VideoEditorStressTest.java revision f1f9ff28c3acae5cb4eb309f28e7872aff35eff6 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.mediaframeworktest.stress;
18
19import java.io.BufferedWriter;
20import java.io.File;
21import java.io.FileOutputStream;
22import java.io.FileWriter;
23import java.io.Writer;
24import java.util.List;
25
26import android.graphics.Bitmap;
27import android.graphics.Rect;
28import android.media.videoeditor.AudioTrack;
29import android.media.videoeditor.EffectColor;
30import android.media.videoeditor.EffectKenBurns;
31import android.media.videoeditor.MediaImageItem;
32import android.media.videoeditor.MediaItem;
33import android.media.videoeditor.MediaProperties;
34import android.media.videoeditor.MediaVideoItem;
35import android.media.videoeditor.OverlayFrame;
36import android.media.videoeditor.Transition;
37import android.media.videoeditor.TransitionCrossfade;
38import android.media.videoeditor.TransitionAlpha;
39import android.media.videoeditor.TransitionFadeBlack;
40import android.media.videoeditor.TransitionSliding;
41import android.media.videoeditor.VideoEditor;
42import android.os.Environment;
43import android.test.ActivityInstrumentationTestCase;
44import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
45import android.os.Environment;
46import android.os.SystemClock;
47import android.test.ActivityInstrumentationTestCase;
48import android.media.videoeditor.VideoEditor.ExportProgressListener;
49import android.media.videoeditor.VideoEditorFactory;
50import android.media.videoeditor.ExtractAudioWaveformProgressListener;
51
52import android.os.Debug;
53import android.util.Log;
54
55import com.android.mediaframeworktest.MediaFrameworkTest;
56import android.test.suitebuilder.annotation.LargeTest;
57import com.android.mediaframeworktest.VideoEditorHelper;
58
59/**
60 * Junit / Instrumentation - performance measurement for media player and
61 * recorder
62 */
63public class VideoEditorStressTest
64        extends ActivityInstrumentationTestCase<MediaFrameworkTest> {
65
66    private final String TAG = "VideoEditorPerformance";
67
68    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
69
70    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
71
72    private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
73        "VideoEditorStressMemOutput.txt";
74
75    private long BeginJavaMemory;
76    private long AfterJavaMemory;
77
78    private long BeginNativeMemory;
79    private long AfterNativeMemory;
80
81    public VideoEditorStressTest() {
82        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
83        new File(VIDEOEDITOR_OUTPUT).delete();
84    }
85
86    private final String PROJECT_CLASS_NAME =
87        "android.media.videoeditor.VideoEditorImpl";
88    private VideoEditor mVideoEditor;
89    private VideoEditorHelper mVideoEditorHelper;
90
91    @Override
92    protected void setUp() throws Exception {
93        // setup for each test case.
94        super.setUp();
95        mVideoEditorHelper = new VideoEditorHelper();
96        // Create a random String which will be used as project path, where all
97        // project related files will be stored.
98        final String projectPath =
99            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
100        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
101    }
102
103    @Override
104    protected void tearDown() throws Exception {
105        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
106        // Clean the directory created as project path
107        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
108        System.gc();
109        super.tearDown();
110    }
111
112    private void writeTimingInfo(String[] information)
113        throws Exception {
114        File outFile = new File(VIDEOEDITOR_OUTPUT);
115        Writer output = new BufferedWriter(new FileWriter(outFile, true));
116        for (int i = 0; i < information.length; i++) {
117            output.write(information[i]);
118        }
119        output.close();
120    }
121
122    private void writeTestCaseHeader(String testCaseName)
123        throws Exception {
124        File outFile = new File(VIDEOEDITOR_OUTPUT);
125        Writer output = new BufferedWriter(new FileWriter(outFile, true));
126        output.write("\n\n" + testCaseName + "\n");
127        output.close();
128    }
129
130    private void getBeginMemory() throws Exception {
131        System.gc();
132        Thread.sleep(2500);
133        BeginNativeMemory = Debug.getNativeHeapAllocatedSize();
134    }
135    private void getAfterMemory_updateLog(String[] loggingInfo, boolean when,
136        int iteration)
137        throws Exception {
138        System.gc();
139        Thread.sleep(2500);
140        AfterNativeMemory = Debug.getNativeHeapAllocatedSize();
141        if(when == false){
142            loggingInfo[0] = "\n Before Remove: iteration No.= " + iteration +
143                "\t " + (AfterNativeMemory - BeginNativeMemory);
144        } else {
145            loggingInfo[0] = "\n After Remove: iteration No.= " + iteration +
146                "\t " + (AfterNativeMemory - BeginNativeMemory);
147        }
148        writeTimingInfo(loggingInfo);
149    }
150
151    /**
152     * To stress test MediaItem(Video Item) adding functionality
153     *
154     * @throws Exception
155     */
156    // TODO : remove TC_STR_001
157    @LargeTest
158    public void testStressAddRemoveVideoItem() throws Exception {
159        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
160
161        final String videoItemFileName1 = INPUT_FILE_PATH +
162            "H264_BP_176x144_15fps_144kbps_AMRNB_8kHz_12.2kbps_m_1_17.3gp";
163        final String videoItemFileName2 = INPUT_FILE_PATH +
164            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
165        final String videoItemFileName3 = INPUT_FILE_PATH +
166            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
167        final String videoItemFileName4 = INPUT_FILE_PATH +
168            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
169        final String[] loggingInfo = new String[1];
170        writeTestCaseHeader("testStressAddRemoveVideoItem");
171        int i = 0;
172        getBeginMemory();
173
174        for ( i = 0; i < 50; i++) {
175            if (i % 4 == 0) {
176                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
177                    "m1" + i, videoItemFileName1, renderingMode);
178                mediaItem1.setExtractBoundaries(0, 5000);
179                mVideoEditor.addMediaItem(mediaItem1);
180            }
181            if (i % 4 == 1) {
182                final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
183                    "m2" + i, videoItemFileName2, renderingMode);
184                mediaItem2.setExtractBoundaries(0, 10000);
185                mVideoEditor.addMediaItem(mediaItem2);
186            }
187            if (i % 4 == 2) {
188                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
189                    "m3" + i, videoItemFileName3, renderingMode);
190                mediaItem3.setExtractBoundaries(30000, 45000);
191                mVideoEditor.addMediaItem(mediaItem3);
192            }
193            if (i % 4 == 3) {
194                final MediaVideoItem mediaItem4 = new MediaVideoItem(mVideoEditor,
195                    "m4" + i, videoItemFileName4, renderingMode);
196                mediaItem4.setExtractBoundaries(10000, 30000);
197                mVideoEditor.addMediaItem(mediaItem4);
198            }
199            if (i % 10 == 0) {
200                getAfterMemory_updateLog(loggingInfo, false, i);
201            }
202        }
203        getAfterMemory_updateLog(loggingInfo, false, i);
204
205        /** Remove items and check for memory leak if any */
206        getBeginMemory();
207        for ( i = 0; i < 50; i++) {
208            if (i % 4 == 0) {
209                mVideoEditor.removeMediaItem("m1" + i);
210            }
211            if (i % 4 == 1) {
212                mVideoEditor.removeMediaItem("m2" + i);
213            }
214            if (i % 4 == 2) {
215                mVideoEditor.removeMediaItem("m3" + i);
216            }
217            if (i % 4 == 3) {
218                mVideoEditor.removeMediaItem("m4" + i);
219            }
220            if (i % 10 == 0) {
221                getAfterMemory_updateLog(loggingInfo, true, i);
222            }
223        }
224        getAfterMemory_updateLog(loggingInfo, true, i);
225    }
226
227    /**
228     * To stress test MediaItem(Image Item) adding functionality
229     *
230     * @throws Exception
231     */
232    // TODO : remove TC_STR_002
233    @LargeTest
234    public void testStressAddRemoveImageItem() throws Exception {
235        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
236        final String ImageItemFileName1 = INPUT_FILE_PATH +
237            "IMG_1600x1200.jpg";
238        final String ImageItemFileName2 = INPUT_FILE_PATH +
239            "IMG_640x480.jpg";
240        final String ImageItemFileName3 = INPUT_FILE_PATH +
241            "IMG_320x240.jpg";
242        final String ImageItemFileName4 = INPUT_FILE_PATH +
243            "IMG_176x144.jpg";
244        final String[] loggingInfo = new String[1];
245        int i = 0;
246        writeTestCaseHeader("testStressAddRemoveImageItem");
247        getBeginMemory();
248        for ( i = 0; i < 50; i++) {
249            if (i % 4 == 0) {
250                final MediaImageItem mediaItem1 = new MediaImageItem(mVideoEditor,
251                    "m1"+ i, ImageItemFileName1, 5000, renderingMode);
252                mVideoEditor.addMediaItem(mediaItem1);
253            }
254            if (i % 4 == 1) {
255                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
256                    "m2"+ i, ImageItemFileName2, 10000, renderingMode);
257                mVideoEditor.addMediaItem(mediaItem2);
258            }
259            if (i % 4 == 2) {
260                final MediaImageItem mediaItem3 = new MediaImageItem(mVideoEditor,
261                    "m3"+ i, ImageItemFileName3, 15000, renderingMode);
262                mVideoEditor.addMediaItem(mediaItem3);
263            }
264            if (i % 4 == 3) {
265                final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
266                    "m4"+ i, ImageItemFileName4, 20000, renderingMode);
267                mVideoEditor.addMediaItem(mediaItem4);
268            }
269            if (i % 10 == 0) {
270                getAfterMemory_updateLog(loggingInfo, false, i);
271            }
272        }
273        getAfterMemory_updateLog(loggingInfo, false, i);
274
275        /** Remove items and check for memory leak if any */
276        getBeginMemory();
277        for ( i = 0; i < 50; i++) {
278            if (i % 4 == 0) {
279                mVideoEditor.removeMediaItem("m1"+i);
280            }
281            if (i % 4 == 1) {
282                mVideoEditor.removeMediaItem("m2"+i);
283            }
284            if (i % 4 == 2) {
285                mVideoEditor.removeMediaItem("m3"+i);
286            }
287            if (i % 4 == 3) {
288                mVideoEditor.removeMediaItem("m4"+i);
289            }
290            if (i % 10 == 0) {
291                getAfterMemory_updateLog(loggingInfo, true, i);
292            }
293        }
294        getAfterMemory_updateLog(loggingInfo, true, i);
295    }
296
297    /**
298     * To stress test transition
299     *
300     * @throws Exception
301     */
302    // TODO : remove TC_STR_003
303    @LargeTest
304    public void testStressAddRemoveTransition() throws Exception {
305        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
306        final String VideoItemFileName1 = INPUT_FILE_PATH +
307            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
308        final String ImageItemFileName2 = INPUT_FILE_PATH +
309            "IMG_1600x1200.jpg";
310        final String VideoItemFileName3 = INPUT_FILE_PATH +
311            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
312        final String maskFilename = INPUT_FILE_PATH +
313            "TransitionSpiral_QVGA.jpg";
314        final String[] loggingInfo = new String[1];
315        int i = 0;
316        writeTestCaseHeader("testStressAddRemoveTransition");
317        getBeginMemory();
318        for ( i = 0; i < 50; i++) {
319            if (i % 4 == 0) {
320                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
321                    "m1"+i, VideoItemFileName1, renderingMode);
322                mVideoEditor.addMediaItem(mediaItem1);
323                mediaItem1.setExtractBoundaries(0, 10000);
324                final TransitionCrossfade tranCrossfade =
325                    new TransitionCrossfade("transCF" + i, null,
326                        mediaItem1, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
327                mVideoEditor.addTransition(tranCrossfade);
328            }
329            if (i % 4 == 1) {
330                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
331                    "m1"+i, VideoItemFileName1, renderingMode);
332                mVideoEditor.addMediaItem(mediaItem1);
333                mediaItem1.setExtractBoundaries(0, 10000);
334
335                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
336                    "m2" +i, ImageItemFileName2, 10000, renderingMode);
337                mVideoEditor.addMediaItem(mediaItem2);
338
339                final TransitionAlpha transitionAlpha =
340                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem1,
341                        mediaItem2, 5000, Transition.BEHAVIOR_SPEED_UP,
342                        maskFilename, 10, false);
343                transitionAlpha.setDuration(4000);
344                mVideoEditor.addTransition(transitionAlpha);
345            }
346            if (i % 4 == 2) {
347                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
348                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
349                mVideoEditor.addMediaItem(mediaItem2);
350
351                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
352                    "m3" + i, VideoItemFileName3, renderingMode);
353                mVideoEditor.addMediaItem(mediaItem3);
354
355                mediaItem3.setExtractBoundaries(0, 10000);
356                final TransitionAlpha transitionAlpha =
357                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem2,
358                        mediaItem3, 5000, Transition.BEHAVIOR_SPEED_UP,
359                        maskFilename, 10, false);
360                transitionAlpha.setDuration(4000);
361                mVideoEditor.addTransition(transitionAlpha);
362
363                mediaItem3.setExtractBoundaries(0, 6000);
364
365                final TransitionSliding transition2And3 =
366                    mVideoEditorHelper.createTSliding("transSlide" +i, mediaItem2,
367                        mediaItem3, 3000, Transition.BEHAVIOR_MIDDLE_FAST,
368                        TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
369                mVideoEditor.addTransition(transition2And3);
370            }
371            if (i % 4 == 3) {
372                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
373                    "m3" + i, VideoItemFileName3, renderingMode);
374                mVideoEditor.addMediaItem(mediaItem3);
375                mediaItem3.setExtractBoundaries(0, 5000);
376
377                final TransitionFadeBlack transition3 =
378                    mVideoEditorHelper.createTFadeBlack("transFB" +i, mediaItem3,
379                        null, 2500, Transition.BEHAVIOR_SPEED_UP);
380                transition3.setDuration(500);
381                mVideoEditor.addTransition(transition3);
382            }
383            if (i % 10 == 0) {
384                getAfterMemory_updateLog(loggingInfo, false, i);
385            }
386        }
387        getAfterMemory_updateLog(loggingInfo, false, i);
388
389        /** Remove items and check for memory leak if any */
390        getBeginMemory();
391        for ( i = 0; i < 50; i++) {
392            if (i % 4 == 0) {
393                mVideoEditor.removeTransition("transCF" + i);
394                mVideoEditor.removeMediaItem("m1" + i);
395            }
396            if (i % 4 == 1) {
397                mVideoEditor.removeTransition("transAlpha" + i);
398                mVideoEditor.removeMediaItem("m1" + i);
399                mVideoEditor.removeMediaItem("m2" + i);
400            }
401            if (i % 4 == 2) {
402                mVideoEditor.removeTransition("transSlide" +i);
403                mVideoEditor.removeMediaItem("m2" + i);
404                mVideoEditor.removeMediaItem("m3" + i);
405            }
406            if (i % 4 == 3) {
407                mVideoEditor.removeMediaItem("m3" + i);
408            }
409            if (i % 10 == 0) {
410                getAfterMemory_updateLog(loggingInfo, true, i);
411            }
412        }
413        getAfterMemory_updateLog(loggingInfo, true, i);
414    }
415
416    /**
417     * To stress test overlay
418     *
419     * @throws Exception
420     */
421    // TODO : remove TC_STR_004
422    @LargeTest
423    public void testStressAddRemoveOverlay() throws Exception {
424        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
425        final String VideoItemFileName1 = INPUT_FILE_PATH +
426            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
427        final String ImageItemFileName2 = INPUT_FILE_PATH +
428            "IMG_640x480.jpg";
429        final String OverlayFile3 = INPUT_FILE_PATH +
430            "IMG_640x480_Overlay1.png";
431        final String OverlayFile4 = INPUT_FILE_PATH +
432            "IMG_640x480_Overlay2.png";
433        final String[] loggingInfo = new String[1];
434        int i = 0;
435        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
436            "m1", VideoItemFileName1, renderingMode);
437        mVideoEditor.addMediaItem(mediaItem1);
438
439        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
440            "m2", ImageItemFileName2, 10000, renderingMode);
441        mVideoEditor.addMediaItem(mediaItem2);
442        writeTestCaseHeader("testStressAddRemoveOverlay");
443        getBeginMemory();
444        for ( i = 0; i < 50; i++) {
445            if (i % 3 == 0) {
446                mediaItem1.setExtractBoundaries(0, 10000);
447                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
448                    OverlayFile3, 640, 480);
449                final OverlayFrame overlayFrame =
450                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
451                        mBitmap, 1000, 5000);
452                mediaItem1.addOverlay(overlayFrame);
453                mediaItem1.removeOverlay("overlay"+i);
454            }
455            if (i % 3 == 1) {
456                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
457                    OverlayFile4, 640, 480);
458                final OverlayFrame overlayFrame =
459                    mVideoEditorHelper.createOverlay(mediaItem2, "overlay" + i,
460                        mBitmap, 1000, 5000);
461                mediaItem2.addOverlay(overlayFrame);
462                mediaItem2.removeOverlay("overlay"+i);
463            }
464            if (i % 3 == 2) {
465                mediaItem1.setExtractBoundaries(0, 10000);
466                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
467                    OverlayFile4, 640, 480);
468                final OverlayFrame overlayFrame =
469                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
470                        mBitmap, 0, mediaItem1.getDuration());
471                mediaItem1.addOverlay(overlayFrame);
472                mediaItem1.removeOverlay("overlay"+i);
473            }
474            if (i % 10 == 0) {
475                getAfterMemory_updateLog(loggingInfo, false, i);
476            }
477        }
478        getAfterMemory_updateLog(loggingInfo, false, i);
479    }
480
481    /**
482     * To stress test Effects
483     *
484     * @throws Exception
485     */
486    // TODO : remove TC_STR_005
487    @LargeTest
488    public void testStressAddRemoveEffects() throws Exception {
489        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
490        final String VideoItemFileName1 = INPUT_FILE_PATH +
491            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
492        final String ImageItemFileName2 = INPUT_FILE_PATH +
493            "IMG_1600x1200.jpg";
494        final String[] loggingInfo = new String[1];
495        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
496            "m1", VideoItemFileName1, renderingMode);
497        mVideoEditor.addMediaItem(mediaItem1);
498        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
499            "m2", ImageItemFileName2, 10000, renderingMode);
500        int i = 0;
501        mVideoEditor.addMediaItem(mediaItem2);
502        writeTestCaseHeader("testStressAddRemoveEffects");
503        getBeginMemory();
504        for ( i = 0; i < 50; i++) {
505            if (i % 5 == 0) {
506                mediaItem1.setExtractBoundaries(10000, 30000);
507                final EffectColor effectColor1 =
508                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
509                        10000, (mediaItem1.getTimelineDuration()-1000),
510                        EffectColor.TYPE_COLOR, EffectColor.GREEN);
511                mediaItem1.addEffect(effectColor1);
512            }
513            if (i % 5 == 1) {
514                mediaItem2.setDuration(20000);
515                final EffectColor effectColor1 =
516                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
517                        0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
518                mediaItem2.addEffect(effectColor1);
519            }
520            if (i % 5 == 2) {
521                mediaItem1.setExtractBoundaries(10000, 30000);
522                final EffectColor effectColor1 =
523                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
524                        (mediaItem1.getTimelineDuration() - 4000), 4000,
525                        EffectColor.TYPE_SEPIA, 0);
526                mediaItem1.addEffect(effectColor1);
527            }
528            if (i % 5 == 3) {
529                mediaItem2.setDuration(20000);
530                final EffectColor effectColor1 =
531                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
532                        10000, 4000, EffectColor.TYPE_NEGATIVE, 0);
533                mediaItem2.addEffect(effectColor1);
534            }
535            if (i % 5 == 4) {
536                mediaItem2.setDuration(20000);
537                final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
538                    (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
539                    (mediaItem2.getWidth() / 2));
540                final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
541                    mediaItem2.getHeight());
542                final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
543                    mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
544                    (mediaItem2.getDuration() - 500));
545                mediaItem2.addEffect(kbEffectOnMediaItem);
546            }
547            if (i % 10 == 0) {
548                getAfterMemory_updateLog(loggingInfo, false, i);
549            }
550        }
551        getAfterMemory_updateLog(loggingInfo, false, i);
552
553        /** Remove items and check for memory leak if any */
554        getBeginMemory();
555        for ( i = 0; i < 50; i++) {
556            if (i % 5 == 0) {
557                mediaItem1.removeEffect("effect1"+i);
558            }
559            if (i % 5 == 1) {
560                mediaItem1.removeEffect("effect1"+i);
561            }
562            if (i % 5 == 2) {
563                mediaItem1.removeEffect("effect1"+i);
564            }
565            if (i % 5 == 3) {
566                mediaItem1.removeEffect("effect1"+i);
567            }
568            if (i % 5 == 4) {
569                mediaItem1.removeEffect("KBOnM2"+i);
570            }
571            if (i % 10 == 0) {
572                getAfterMemory_updateLog(loggingInfo, true, i);
573            }
574        }
575        getAfterMemory_updateLog(loggingInfo, true, i);
576    }
577
578    /**
579     * This method will test thumbnail list extraction in a loop = 200 for Video
580     * Item
581     *
582     * @throws Exception
583     */
584    // TODO : remove TC_STR_006
585    @LargeTest
586    public void testStressThumbnailVideoItem() throws Exception {
587        final String videoItemFileName = INPUT_FILE_PATH
588                + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
589        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
590        final String[] loggingInfo = new String[1];
591        int i = 0;
592        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
593            "m1", videoItemFileName, renderingMode);
594        writeTestCaseHeader("testStressThumbnailVideoItem");
595        getBeginMemory();
596        for ( i = 0; i < 50; i++) {
597            if (i % 4 == 0) {
598                final Bitmap[] thumbNails =
599                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*3,
600                        mediaVideoItem.getHeight()*2, i, 5000, 2);
601                // Recycle this Bitmap array
602                for (int i1 = 0; i1 < thumbNails.length; i1++) {
603                    thumbNails[i1].recycle();
604                }
605            }
606            if (i % 4 == 1) {
607                final Bitmap[] thumbNails =
608                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()/2,
609                        mediaVideoItem.getHeight() * 3, i, 5000, 2);
610                // Recycle this Bitmap array
611                for (int i1 = 0; i1 < thumbNails.length; i1++) {
612                    thumbNails[i1].recycle();
613                }
614            }
615            if (i % 4 == 2) {
616                final Bitmap[] thumbNails =
617                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*2,
618                        mediaVideoItem.getHeight() / 3, i, 5000, 2);
619                // Recycle this Bitmap array
620                for (int i1 = 0; i1 < thumbNails.length; i1++) {
621                    thumbNails[i1].recycle();
622                }
623            }
624            if (i % 4 == 3) {
625                final Bitmap[] thumbNails =
626                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth(),
627                        mediaVideoItem.getHeight(), i, 5000, 2);
628                // Recycle this Bitmap array
629                for (int i1 = 0; i1 < thumbNails.length; i1++) {
630                    thumbNails[i1].recycle();
631                }
632            }
633            if (i % 10 == 0) {
634                getAfterMemory_updateLog(loggingInfo, false, i);
635            }
636        }
637        getAfterMemory_updateLog(loggingInfo, false, i);
638    }
639
640    /**
641     * To stress test media properties
642     *
643     * @throws Exception
644     */
645    // TODO : remove TC_STR_007
646    @LargeTest
647    public void testStressMediaProperties() throws Exception {
648        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
649        final String VideoItemFileName1 = INPUT_FILE_PATH +
650            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
651        final String ImageItemFileName2 = INPUT_FILE_PATH +
652            "IMG_640x480.jpg";
653        final String AudioItemFileName3 = INPUT_FILE_PATH +
654            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
655        final String[] loggingInfo = new String[1];
656        int i = 0;
657        final int videoAspectRatio = MediaProperties.ASPECT_RATIO_3_2;
658        final int videoFileType = MediaProperties.FILE_MP4;
659        final int videoCodecType = MediaProperties.VCODEC_H264BP;
660        final int videoDuration = 77366;
661        final int videoProfile = MediaProperties.H264_PROFILE_0_LEVEL_1_3;
662        final int videoHeight = MediaProperties.HEIGHT_720;
663        final int videoWidth = 1080;
664
665        final int imageAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
666        final int imageFileType = MediaProperties.FILE_JPEG;
667        final int imageWidth = 640;
668        final int imageHeight = MediaProperties.HEIGHT_480;
669
670        final int audioDuration = 77554;
671        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
672        final int audioSamplingFrequency = 44100;
673        final int audioChannel = 2;
674        writeTestCaseHeader("testStressMediaProperties");
675        getBeginMemory();
676        for ( i = 0; i < 50; i++) {
677            if (i % 3 == 0) {
678                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
679                    "m1" + i, VideoItemFileName1, renderingMode);
680                mVideoEditor.addMediaItem(mediaItem1);
681                mediaItem1.setExtractBoundaries(0, 20000);
682                assertEquals("Aspect Ratio Mismatch",
683                    videoAspectRatio, mediaItem1.getAspectRatio());
684                assertEquals("File Type Mismatch",
685                    videoFileType, mediaItem1.getFileType());
686                assertEquals("VideoCodec Mismatch",
687                    videoCodecType, mediaItem1.getVideoType());
688                assertEquals("duration Mismatch",
689                    videoDuration, mediaItem1.getDuration());
690                assertEquals("Video Profile ",
691                    videoProfile, mediaItem1.getVideoProfile());
692                assertEquals("Video height ",
693                    videoHeight, mediaItem1.getHeight());
694                assertEquals("Video width ",
695                    videoWidth, mediaItem1.getWidth());
696                mVideoEditor.removeMediaItem("m1" + i);
697            }
698            if (i % 3 == 1) {
699                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
700                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
701                mVideoEditor.addMediaItem(mediaItem2);
702                assertEquals("Aspect Ratio Mismatch",
703                    imageAspectRatio, mediaItem2.getAspectRatio());
704                assertEquals("File Type Mismatch",
705                    imageFileType, mediaItem2.getFileType());
706                assertEquals("Image height",
707                    imageHeight, mediaItem2.getHeight());
708                assertEquals("Image width",
709                    imageWidth, mediaItem2.getWidth());
710                mVideoEditor.removeMediaItem("m2" + i);
711            }
712            if (i % 3 == 2) {
713                final AudioTrack mediaItem3 = new AudioTrack(mVideoEditor,
714                    "m3" + i, AudioItemFileName3);
715                mVideoEditor.addAudioTrack(mediaItem3);
716                assertEquals("AudioType Mismatch", audioCodecType,
717                    mediaItem3.getAudioType());
718                assertEquals("Audio Sampling", audioSamplingFrequency,
719                    mediaItem3.getAudioSamplingFrequency());
720                assertEquals("Audio Channels",
721                    audioChannel, mediaItem3.getAudioChannels());
722                assertEquals("duration Mismatch", audioDuration,
723                    mediaItem3.getDuration());
724                mVideoEditor.removeAudioTrack("m3" + i);
725            }
726            if (i % 10 == 0) {
727                getAfterMemory_updateLog(loggingInfo, false, i);
728            }
729        }
730        getAfterMemory_updateLog(loggingInfo, false, i);
731    }
732
733    /**
734     * To stress test insert and move of mediaitems
735     *
736     * @throws Exception
737     */
738    // TODO : remove TC_STR_008
739    @LargeTest
740    public void testStressInsertMovieItems() throws Exception {
741        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
742        final String VideoItemFileName1 = INPUT_FILE_PATH +
743            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
744        final String VideoItemFileName2 = INPUT_FILE_PATH +
745            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
746        final String VideoItemFileName3 = INPUT_FILE_PATH +
747            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
748        final String[] loggingInfo = new String[1];
749        int i = 0;
750        writeTestCaseHeader("testStressInsertMoveItems");
751
752        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
753            "m1", VideoItemFileName1, renderingMode);
754        mVideoEditor.addMediaItem(mediaItem1);
755        mediaItem1.setExtractBoundaries(0, 10000);
756
757        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
758            "m2", VideoItemFileName2, renderingMode);
759        mVideoEditor.addMediaItem(mediaItem2);
760        mediaItem2.setExtractBoundaries(0, 15000);
761
762        getBeginMemory();
763        for ( i = 0; i < 50; i++) {
764            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
765                "m3" + i, VideoItemFileName3, renderingMode);
766            mediaItem3.setExtractBoundaries(0, 15000);
767            mVideoEditor.insertMediaItem(mediaItem3, "m1");
768            mVideoEditor.moveMediaItem("m2", "m3" + i);
769            if (i % 10 == 0) {
770                getAfterMemory_updateLog(loggingInfo, false, i);
771            }
772        }
773        getAfterMemory_updateLog(loggingInfo, false, i);
774
775        /** Remove items and check for memory leak if any */
776        getBeginMemory();
777        for ( i = 0; i < 50; i++) {
778            mVideoEditor.removeMediaItem("m3" + i);
779            if (i % 10 == 0) {
780                getAfterMemory_updateLog(loggingInfo, true, i);
781            }
782        }
783            mVideoEditor.removeMediaItem("m2");
784            mVideoEditor.removeMediaItem("m1");
785        getAfterMemory_updateLog(loggingInfo, true, i);
786    }
787
788    /**
789     * To stress test : load and save
790     *
791     * @throws Exception
792     */
793    // TODO : remove TC_STR_009
794    @LargeTest
795    public void testStressLoadAndSave() throws Exception {
796        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
797        final String VideoItemFileName1 = INPUT_FILE_PATH +
798            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
799        final String VideoItemFileName2 = INPUT_FILE_PATH +
800            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
801        final String VideoItemFileName3 = INPUT_FILE_PATH +
802            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
803        final String ImageItemFileName4 = INPUT_FILE_PATH +
804            "IMG_640x480.jpg";
805        final String ImageItemFileName5 = INPUT_FILE_PATH +
806            "IMG_176x144.jpg";
807        final String OverlayFile6 = INPUT_FILE_PATH +
808            "IMG_640x480_Overlay1.png";
809        final String[] loggingInfo = new String[1];
810        int i = 0;
811        final String[] projectPath = new String[10];
812        writeTestCaseHeader("testStressLoadAndSave");
813        getBeginMemory();
814        for( i=0; i < 10; i++){
815
816            projectPath[i] =
817                mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
818            final VideoEditor mVideoEditor1 =
819                mVideoEditorHelper.createVideoEditor(projectPath[i]);
820
821            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor1,
822                "m1", VideoItemFileName1, renderingMode);
823            mVideoEditor1.addMediaItem(mediaItem1);
824            mediaItem1.setExtractBoundaries(0, 10000);
825
826            final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor1,
827                "m2", VideoItemFileName2, renderingMode);
828            mVideoEditor1.addMediaItem(mediaItem2);
829            mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
830                mediaItem2.getDuration()/2);
831
832            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor1,
833                "m3", VideoItemFileName3, renderingMode);
834            mVideoEditor1.addMediaItem(mediaItem3);
835            mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
836                mediaItem3.getDuration());
837
838            final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor1,
839                "m4", ImageItemFileName4, 5000, renderingMode);
840            mVideoEditor1.addMediaItem(mediaItem4);
841
842            final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor1,
843                "m5", ImageItemFileName5, 5000, renderingMode);
844            mVideoEditor1.addMediaItem(mediaItem5);
845
846            final EffectColor effectColor1 =
847                mVideoEditorHelper.createEffectItem(mediaItem3, "effect1",
848                    10000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
849            mediaItem3.addEffect(effectColor1);
850
851            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile6,
852                640, 480);
853            final OverlayFrame overlayFrame =
854                mVideoEditorHelper.createOverlay(mediaItem4, "overlay",
855                    mBitmap, 4000, 1000);
856            mediaItem4.addOverlay(overlayFrame);
857
858            final TransitionCrossfade tranCrossfade =
859                new TransitionCrossfade("transCF", mediaItem1,
860                    mediaItem2, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
861            mVideoEditor1.addTransition(tranCrossfade);
862
863            final EffectColor effectColor2 =
864                mVideoEditorHelper.createEffectItem(mediaItem4, "effect2", 0,
865                    mediaItem4.getDuration(), EffectColor.TYPE_COLOR,
866                    EffectColor.PINK);
867            mediaItem4.addEffect(effectColor2);
868
869            mVideoEditor1.generatePreview(new MediaProcessingProgressListener() {
870                public void onProgress(Object item, int action, int progress) {
871                }
872            });
873
874            mVideoEditor1.save();
875            mVideoEditor1.release();
876
877            getAfterMemory_updateLog(loggingInfo, false, i);
878        }
879        getAfterMemory_updateLog(loggingInfo, false, i);
880
881        /** Remove items and check for memory leak if any */
882        getBeginMemory();
883        for( i=0; i<10; i++){
884            final VideoEditor mVideoEditor1b =
885                VideoEditorFactory.load(projectPath[i], true);
886            List<MediaItem> mediaList = mVideoEditor1b.getAllMediaItems();
887            assertEquals("Media Item List Size", 5, mediaList.size());
888
889            mediaList.get(3).removeEffect("effect1");
890            mediaList.get(3).removeEffect("effect2");
891            mediaList.get(2).removeOverlay("overlay");
892            mVideoEditor1b.removeTransition("transCF");
893            mVideoEditor1b.removeMediaItem("m5");
894            mVideoEditor1b.removeMediaItem("m4");
895            mVideoEditor1b.removeMediaItem("m3");
896            mVideoEditor1b.removeMediaItem("m2");
897            mVideoEditor1b.removeMediaItem("m1");
898            mVideoEditor1b.release();
899            getAfterMemory_updateLog(loggingInfo, true, i);
900        }
901        getAfterMemory_updateLog(loggingInfo, true, i);
902    }
903
904    /**
905     * To stress test : Multiple Export
906     *
907     * @throws Exception
908     */
909    // TODO : remove TC_STR_010
910    @LargeTest
911    public void testStressMultipleExport() throws Exception {
912        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
913        final String VideoItemFileName1 = INPUT_FILE_PATH +
914            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
915        final String VideoItemFileName2 = INPUT_FILE_PATH +
916            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
917        final String[] loggingInfo = new String[1];
918        final String outFilename = mVideoEditorHelper.createRandomFile(
919            mVideoEditor.getPath() + "/") + ".3gp";
920        int i = 0;
921        writeTestCaseHeader("testStressMultipleExport");
922        getBeginMemory();
923        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
924            "m1", VideoItemFileName1, renderingMode);
925        mVideoEditor.addMediaItem(mediaItem1);
926        mediaItem1.setExtractBoundaries(0, 10000);
927
928        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
929            "m2", VideoItemFileName2, renderingMode);
930        mVideoEditor.addMediaItem(mediaItem2);
931        mediaItem2.setExtractBoundaries(0, 15000);
932
933        for ( i = 0; i < 50; i++) {
934            if(i%4 ==0){
935                final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
936                mVideoEditor.setAspectRatio(aspectRatio);
937                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
938                    MediaProperties.BITRATE_256K,MediaProperties.ACODEC_AAC_LC,
939                        MediaProperties.VCODEC_H263,
940                        new ExportProgressListener() {
941                        public void onProgress(VideoEditor ve, String outFileName,
942                            int progress) {
943                        }
944                    });
945            }
946            if(i%4 ==1){
947                final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
948                mVideoEditor.setAspectRatio(aspectRatio);
949                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
950                    MediaProperties.BITRATE_384K,MediaProperties.ACODEC_AAC_LC,
951                        MediaProperties.VCODEC_MPEG4,
952                        new ExportProgressListener() {
953                        public void onProgress(VideoEditor ve, String outFileName,
954                            int progress) {
955                        }
956                    });
957            }
958            if(i%4 ==2){
959                final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
960                mVideoEditor.setAspectRatio(aspectRatio);
961                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
962                    MediaProperties.BITRATE_512K,MediaProperties.ACODEC_AAC_LC,
963                        MediaProperties.VCODEC_H264BP,
964                        new ExportProgressListener() {
965                        public void onProgress(VideoEditor ve, String outFileName,
966                            int progress) {
967                        }
968                    });
969            }
970            if(i%4 ==3){
971                final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
972                mVideoEditor.setAspectRatio(aspectRatio);
973                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
974                    MediaProperties.BITRATE_800K,MediaProperties.ACODEC_AAC_LC,
975                        MediaProperties.VCODEC_H264BP,
976                        new ExportProgressListener() {
977                        public void onProgress(VideoEditor ve, String outFileName,
978                            int progress) {
979                        }
980                    });
981            }
982            if (i % 10 == 0) {
983                getAfterMemory_updateLog(loggingInfo, false, i);
984            }
985        }
986        getAfterMemory_updateLog(loggingInfo, false, i);
987
988        /** Remove items and check for memory leak if any */
989        getBeginMemory();
990        mVideoEditor.removeMediaItem("m2");
991        mVideoEditor.removeMediaItem("m1");
992
993        getAfterMemory_updateLog(loggingInfo, true, i);
994    }
995
996    /**
997     * To stress test Media Item,Overlays,Transitions and Ken Burn
998     *
999     * @throws Exception
1000     */
1001    // TODO : remove TC_STR_011
1002    @LargeTest
1003    public void testStressOverlayTransKenBurn() throws Exception {
1004        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1005        final String VideoItemFileName1 = INPUT_FILE_PATH +
1006            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
1007        final String ImageItemFileName2 = INPUT_FILE_PATH +
1008            "IMG_640x480.jpg";
1009        final String OverlayFile3 = INPUT_FILE_PATH +
1010            "IMG_640x480_Overlay1.png";
1011        final String audioFilename4 = INPUT_FILE_PATH +
1012            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1013        int i = 0;
1014        final String[] loggingInfo = new String[1];
1015        writeTestCaseHeader("testStressOverlayTransKenBurn");
1016        getBeginMemory();
1017        for ( i = 0; i < 10; i++) {
1018            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
1019                "m1" + i, VideoItemFileName1, renderingMode);
1020            mVideoEditor.addMediaItem(mediaItem1);
1021            mediaItem1.setExtractBoundaries(0, 10000);
1022
1023            final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
1024                "m2" + i, ImageItemFileName2, 10000, renderingMode);
1025            mVideoEditor.addMediaItem(mediaItem2);
1026
1027            final EffectColor effectColor1 =
1028                mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
1029                    (mediaItem1.getDuration() - 4000), 4000,
1030                    EffectColor.TYPE_SEPIA, 0);
1031            mediaItem1.addEffect(effectColor1);
1032
1033            final TransitionCrossfade tranCrossfade =
1034                new TransitionCrossfade("transCF" + i, mediaItem1,
1035                    mediaItem2, 4000, Transition.BEHAVIOR_MIDDLE_FAST);
1036            mVideoEditor.addTransition(tranCrossfade);
1037
1038            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile3,
1039                640, 480);
1040            final OverlayFrame overlayFrame =
1041                mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
1042                    mBitmap, 1000, 5000);
1043            mediaItem1.addOverlay(overlayFrame);
1044
1045            final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
1046                (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
1047                (mediaItem2.getWidth() / 2));
1048            final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
1049                mediaItem2.getHeight());
1050
1051            final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
1052                mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
1053                (mediaItem2.getDuration()-500));
1054            mediaItem2.addEffect(kbEffectOnMediaItem);
1055
1056            if(i == 5) {
1057                final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1058                    "Audio Track1", audioFilename4);
1059                mVideoEditor.addAudioTrack(audioTrack1);
1060            }
1061            getAfterMemory_updateLog(loggingInfo, false, i);
1062        }
1063        getAfterMemory_updateLog(loggingInfo, false, i);
1064
1065        /** Remove items and check for memory leak if any */
1066        getBeginMemory();
1067        for ( i = 0; i < 10; i++) {
1068            MediaImageItem m2 = (MediaImageItem)mVideoEditor.getMediaItem("m2"+i);
1069            MediaVideoItem m1 = (MediaVideoItem)mVideoEditor.getMediaItem("m1"+i);
1070            m2.removeEffect("KBOnM2" + i);
1071            m1.removeOverlay("overlay" + i);
1072            mVideoEditor.removeTransition("transCF" + i);
1073            m1.removeEffect("effect1" + i);
1074            mVideoEditor.removeMediaItem("m2" + i);
1075            mVideoEditor.removeMediaItem("m1" + i);
1076            if(i == 5) {
1077                mVideoEditor.removeAudioTrack("Audio Track1");
1078            }
1079            getAfterMemory_updateLog(loggingInfo, true, i);
1080        }
1081        getAfterMemory_updateLog(loggingInfo, true, i);
1082    }
1083
1084    /**
1085     * To test the performance : With an audio track with Video
1086     *
1087     * @throws Exception
1088     */
1089    // TODO : remove TC_STR_012
1090    @LargeTest
1091    public void testStressAudioTrackVideo() throws Exception {
1092        final String videoItemFileName1 = INPUT_FILE_PATH +
1093            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
1094        final String audioFilename1 = INPUT_FILE_PATH +
1095            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1096        final String audioFilename2 = INPUT_FILE_PATH +
1097            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
1098        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1099        final int audioVolume = 50;
1100        final String[] loggingInfo = new String[1];
1101        int i = 1;
1102        writeTestCaseHeader("testStressAudioTrackVideo");
1103        getBeginMemory();
1104        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
1105            "mediaItem1", videoItemFileName1, renderingMode);
1106        mVideoEditor.addMediaItem(mediaVideoItem);
1107
1108        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1109            "Audio Track1", audioFilename1);
1110        audioTrack1.disableDucking();
1111        audioTrack1.setVolume(audioVolume);
1112        mVideoEditor.addAudioTrack(audioTrack1);
1113
1114        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
1115            public void onProgress(Object item, int action, int progress) {
1116            }
1117        });
1118
1119        mVideoEditor.removeAudioTrack("Audio Track1");
1120
1121        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
1122            "Audio Track2", audioFilename2);
1123        audioTrack2.enableLoop();
1124
1125        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
1126            public void onProgress(Object item, int action, int progress) {
1127            }
1128        });
1129        getAfterMemory_updateLog(loggingInfo, false, i);
1130
1131        /** Remove items and check for memory leak if any */
1132        getBeginMemory();
1133        mVideoEditor.removeMediaItem("mediaItem1");
1134
1135        getAfterMemory_updateLog(loggingInfo, true, i);
1136    }
1137
1138    /**
1139     * To Test Stress : Story Board creation with out preview or export
1140     *
1141     * @throws Exception
1142     */
1143    // TODO : remove TC_STR_013
1144    @LargeTest
1145    public void testStressStoryBoard() throws Exception {
1146        final String videoItemFileName1 = INPUT_FILE_PATH +
1147            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
1148        final String videoItemFileName2 = INPUT_FILE_PATH +
1149            "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
1150        final String videoItemFileName3= INPUT_FILE_PATH +
1151            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
1152        final String imageItemFileName4 = INPUT_FILE_PATH +
1153            "IMG_1600x1200.jpg";
1154        final String imageItemFileName5 = INPUT_FILE_PATH +
1155            "IMG_176x144.jpg";
1156        final String audioFilename6 = INPUT_FILE_PATH +
1157            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
1158        final String audioFilename7 = INPUT_FILE_PATH +
1159            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1160
1161        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1162        final int audioVolume = 50;
1163        final String[] loggingInfo = new String[1];
1164        int i = 1;
1165
1166        writeTestCaseHeader("testStressStoryBoard");
1167        getBeginMemory();
1168        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
1169            "m1", videoItemFileName1, renderingMode);
1170        mediaItem1.setExtractBoundaries(0, 10000);
1171        mVideoEditor.addMediaItem(mediaItem1);
1172
1173        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
1174            "m2", videoItemFileName2, renderingMode);
1175        mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
1176            mediaItem2.getDuration()/2);
1177        mVideoEditor.addMediaItem(mediaItem2);
1178
1179        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
1180            "m3", videoItemFileName3, renderingMode);
1181        mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
1182            mediaItem3.getDuration());
1183        mVideoEditor.addMediaItem(mediaItem3);
1184
1185        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
1186            "m4", imageItemFileName4, 5000, renderingMode);
1187        mVideoEditor.addMediaItem(mediaItem4);
1188
1189        final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor,
1190            "m5", imageItemFileName5, 5000, renderingMode);
1191        mVideoEditor.addMediaItem(mediaItem5);
1192
1193        final TransitionCrossfade tranCrossfade =
1194            new TransitionCrossfade("transCF", mediaItem2, mediaItem3, 2500,
1195                Transition.BEHAVIOR_MIDDLE_FAST);
1196        mVideoEditor.addTransition(tranCrossfade);
1197
1198        final TransitionCrossfade tranCrossfade1 =
1199            new TransitionCrossfade("transCF1", mediaItem3, mediaItem4, 2500,
1200                Transition.BEHAVIOR_MIDDLE_FAST);
1201        mVideoEditor.addTransition(tranCrossfade1);
1202
1203        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1204            "Audio Track1", audioFilename6);
1205        mVideoEditor.addAudioTrack(audioTrack1);
1206
1207        mVideoEditor.removeAudioTrack("Audio Track1");
1208        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
1209            "Audio Track2", audioFilename7);
1210        mVideoEditor.addAudioTrack(audioTrack2);
1211        audioTrack2.enableLoop();
1212        getAfterMemory_updateLog(loggingInfo, false, i);
1213
1214        /** Remove items and check for memory leak if any */
1215        getBeginMemory();
1216        mVideoEditor.removeAudioTrack("Audio Track2");
1217        mVideoEditor.removeTransition("transCF");
1218        mVideoEditor.removeTransition("transCF1");
1219        mVideoEditor.removeMediaItem("m5");
1220        mVideoEditor.removeMediaItem("m4");
1221        mVideoEditor.removeMediaItem("m3");
1222        mVideoEditor.removeMediaItem("m2");
1223        mVideoEditor.removeMediaItem("m1");
1224
1225        getAfterMemory_updateLog(loggingInfo, true, i);
1226    }
1227
1228     /**
1229     * To test the performance : With an audio track Only
1230     *
1231     * @throws Exception
1232     */
1233    // TODO : remove TC_STR_014
1234    @LargeTest
1235    public void testStressAudioTrackOnly() throws Exception {
1236
1237        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1238        final String AudioItemFileName1 = INPUT_FILE_PATH +
1239            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1240        final String[] loggingInfo = new String[1];
1241        int i = 0;
1242        writeTestCaseHeader("testStressAudioTrackOnly");
1243        getBeginMemory();
1244        for ( i = 0; i < 50; i++) {
1245            final AudioTrack mediaItem1 = new AudioTrack(mVideoEditor,
1246                "m1" + i, AudioItemFileName1);
1247            mVideoEditor.addAudioTrack(mediaItem1);
1248            mediaItem1.enableLoop();
1249            mVideoEditor.removeAudioTrack("m1" + i);
1250            if (i % 10 == 0) {
1251                getAfterMemory_updateLog(loggingInfo, false, i);
1252            }
1253        }
1254        getAfterMemory_updateLog(loggingInfo, false, i);
1255    }
1256
1257    /**
1258     * This method will test thumbnail list extraction in a loop = 200 for Image
1259     * Item
1260     *
1261     * @throws Exception
1262     */
1263    // TODO : remove TC_STR_016  -- New Test Case
1264    @LargeTest
1265    public void testStressThumbnailImageItem() throws Exception {
1266        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
1267        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1268        final String[] loggingInfo = new String[1];
1269        int i = 0;
1270        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
1271            "m1", imageItemFileName, 5000, renderingMode);
1272        writeTestCaseHeader("testStressThumbnailImageItem");
1273        getBeginMemory();
1274        for ( i = 0; i < 50; i++) {
1275            if (i % 4 == 0) {
1276                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1277                    mediaImageItem.getWidth() / 2 ,
1278                    mediaImageItem.getHeight() / 2, i, 5000, 2);
1279                // Recycle this Bitmap array
1280                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1281                    thumbNails[i1].recycle();
1282                }
1283            }
1284            if (i % 4 == 1) {
1285                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1286                    mediaImageItem.getWidth() / 2,
1287                    mediaImageItem.getHeight() * 3, i, 5000, 2);
1288                // Recycle this Bitmap array
1289                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1290                    thumbNails[i1].recycle();
1291                }
1292            }
1293            if (i % 4 == 2) {
1294                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1295                    mediaImageItem.getWidth() * 2,
1296                    mediaImageItem.getHeight() / 3, i, 5000, 2);
1297                // Recycle this Bitmap array
1298                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1299                    thumbNails[i1].recycle();
1300                }
1301            }
1302            if (i % 4 == 3) {
1303                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1304                    mediaImageItem.getWidth(),
1305                    mediaImageItem.getHeight(), i, 5000, 2);
1306                // Recycle this Bitmap array
1307                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1308                    thumbNails[i1].recycle();
1309                }
1310            }
1311            if (i % 10 == 0) {
1312                getAfterMemory_updateLog(loggingInfo, false, i);
1313            }
1314        }
1315        getAfterMemory_updateLog(loggingInfo, false, i);
1316    }
1317}
1318