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