VideoEditorStressTest.java revision 2d06aee09507252ba6703ecd2c4f9f356048e6ad 
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_H264BP;
669        final int videoDuration = 77366;
670        final int videoProfile = MediaProperties.H264_PROFILE_0_LEVEL_1_3;
671        final int videoHeight = MediaProperties.HEIGHT_720;
672        final int videoWidth = 1080;
673
674        final int imageAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
675        final int imageFileType = MediaProperties.FILE_JPEG;
676        final int imageWidth = 640;
677        final int imageHeight = MediaProperties.HEIGHT_480;
678
679        final int audioDuration = 77554;
680        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
681        final int audioSamplingFrequency = 44100;
682        final int audioChannel = 2;
683        writeTestCaseHeader("testStressMediaProperties");
684        getBeginMemory();
685        for ( i = 0; i < 50; i++) {
686            if (i % 3 == 0) {
687                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
688                    "m1" + i, VideoItemFileName1, renderingMode);
689                mVideoEditor.addMediaItem(mediaItem1);
690                mediaItem1.setExtractBoundaries(0, 20000);
691                assertEquals("Aspect Ratio Mismatch",
692                    videoAspectRatio, mediaItem1.getAspectRatio());
693                assertEquals("File Type Mismatch",
694                    videoFileType, mediaItem1.getFileType());
695                assertEquals("VideoCodec Mismatch",
696                    videoCodecType, mediaItem1.getVideoType());
697                assertEquals("duration Mismatch",
698                    videoDuration, mediaItem1.getDuration());
699                assertEquals("Video Profile ",
700                    videoProfile, mediaItem1.getVideoProfile());
701                assertEquals("Video height ",
702                    videoHeight, mediaItem1.getHeight());
703                assertEquals("Video width ",
704                    videoWidth, mediaItem1.getWidth());
705                mVideoEditor.removeMediaItem("m1" + i);
706            }
707            if (i % 3 == 1) {
708                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
709                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
710                mVideoEditor.addMediaItem(mediaItem2);
711                assertEquals("Aspect Ratio Mismatch",
712                    imageAspectRatio, mediaItem2.getAspectRatio());
713                assertEquals("File Type Mismatch",
714                    imageFileType, mediaItem2.getFileType());
715                assertEquals("Image height",
716                    imageHeight, mediaItem2.getHeight());
717                assertEquals("Image width",
718                    imageWidth, mediaItem2.getWidth());
719                mVideoEditor.removeMediaItem("m2" + i);
720            }
721            if (i % 3 == 2) {
722                final AudioTrack mediaItem3 = new AudioTrack(mVideoEditor,
723                    "m3" + i, AudioItemFileName3);
724                mVideoEditor.addAudioTrack(mediaItem3);
725                assertEquals("AudioType Mismatch", audioCodecType,
726                    mediaItem3.getAudioType());
727                assertEquals("Audio Sampling", audioSamplingFrequency,
728                    mediaItem3.getAudioSamplingFrequency());
729                assertEquals("Audio Channels",
730                    audioChannel, mediaItem3.getAudioChannels());
731                assertEquals("duration Mismatch", audioDuration,
732                    mediaItem3.getDuration());
733                mVideoEditor.removeAudioTrack("m3" + i);
734            }
735            if (i % 10 == 0) {
736                getAfterMemory_updateLog(loggingInfo, false, i);
737            }
738        }
739        getAfterMemory_updateLog(loggingInfo, false, i);
740    }
741
742    /**
743     * To stress test insert and move of mediaitems
744     *
745     * @throws Exception
746     */
747    // TODO : remove TC_STR_008
748    @LargeTest
749    public void testStressInsertMovieItems() throws Exception {
750        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
751        final String VideoItemFileName1 = INPUT_FILE_PATH +
752            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
753        final String VideoItemFileName2 = INPUT_FILE_PATH +
754            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
755        final String VideoItemFileName3 = INPUT_FILE_PATH +
756            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
757        final String[] loggingInfo = new String[1];
758        int i = 0;
759        writeTestCaseHeader("testStressInsertMoveItems");
760
761        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
762            "m1", VideoItemFileName1, renderingMode);
763        mVideoEditor.addMediaItem(mediaItem1);
764        mediaItem1.setExtractBoundaries(0, 10000);
765
766        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
767            "m2", VideoItemFileName2, renderingMode);
768        mVideoEditor.addMediaItem(mediaItem2);
769        mediaItem2.setExtractBoundaries(0, 15000);
770
771        getBeginMemory();
772        for ( i = 0; i < 50; i++) {
773            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
774                "m3" + i, VideoItemFileName3, renderingMode);
775            mediaItem3.setExtractBoundaries(0, 15000);
776            mVideoEditor.insertMediaItem(mediaItem3, "m1");
777            mVideoEditor.moveMediaItem("m2", "m3" + i);
778            if (i % 10 == 0) {
779                getAfterMemory_updateLog(loggingInfo, false, i);
780            }
781        }
782        getAfterMemory_updateLog(loggingInfo, false, i);
783
784        /** Remove items and check for memory leak if any */
785        for ( i = 0; i < 50; i++) {
786            mVideoEditor.removeMediaItem("m3" + i);
787            if (i % 10 == 0) {
788                getAfterMemory_updateLog(loggingInfo, true, i);
789            }
790        }
791        mVideoEditor.removeMediaItem("m2");
792        mVideoEditor.removeMediaItem("m1");
793        getAfterMemory_updateLog(loggingInfo, true, i);
794    }
795
796    /**
797     * To stress test : load and save
798     *
799     * @throws Exception
800     */
801    // TODO : remove TC_STR_009
802    @LargeTest
803    public void testStressLoadAndSave() throws Exception {
804        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
805        final String VideoItemFileName1 = INPUT_FILE_PATH +
806            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
807        final String VideoItemFileName2 = INPUT_FILE_PATH +
808            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
809        final String VideoItemFileName3 = INPUT_FILE_PATH +
810            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
811        final String ImageItemFileName4 = INPUT_FILE_PATH +
812            "IMG_640x480.jpg";
813        final String ImageItemFileName5 = INPUT_FILE_PATH +
814            "IMG_176x144.jpg";
815        final String OverlayFile6 = INPUT_FILE_PATH +
816            "IMG_640x480_Overlay1.png";
817        final String[] loggingInfo = new String[1];
818        int i = 0;
819        final String[] projectPath = new String[10];
820        writeTestCaseHeader("testStressLoadAndSave");
821        getBeginMemory();
822        for( i=0; i < 10; i++){
823
824            projectPath[i] =
825                mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
826            final VideoEditor mVideoEditor1 =
827                mVideoEditorHelper.createVideoEditor(projectPath[i]);
828
829            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor1,
830                "m1", VideoItemFileName1, renderingMode);
831            mVideoEditor1.addMediaItem(mediaItem1);
832            mediaItem1.setExtractBoundaries(0, 10000);
833
834            final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor1,
835                "m2", VideoItemFileName2, renderingMode);
836            mVideoEditor1.addMediaItem(mediaItem2);
837            mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
838                mediaItem2.getDuration()/2);
839
840            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor1,
841                "m3", VideoItemFileName3, renderingMode);
842            mVideoEditor1.addMediaItem(mediaItem3);
843            mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
844                mediaItem3.getDuration());
845
846            final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor1,
847                "m4", ImageItemFileName4, 5000, renderingMode);
848            mVideoEditor1.addMediaItem(mediaItem4);
849
850            final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor1,
851                "m5", ImageItemFileName5, 5000, renderingMode);
852            mVideoEditor1.addMediaItem(mediaItem5);
853
854            final EffectColor effectColor1 =
855                mVideoEditorHelper.createEffectItem(mediaItem3, "effect1",
856                    10000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
857            mediaItem3.addEffect(effectColor1);
858
859            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile6,
860                640, 480);
861            final OverlayFrame overlayFrame =
862                mVideoEditorHelper.createOverlay(mediaItem4, "overlay",
863                    mBitmap, 4000, 1000);
864            mediaItem4.addOverlay(overlayFrame);
865
866            final TransitionCrossfade tranCrossfade =
867                new TransitionCrossfade("transCF", mediaItem1,
868                    mediaItem2, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
869            mVideoEditor1.addTransition(tranCrossfade);
870
871            final EffectColor effectColor2 =
872                mVideoEditorHelper.createEffectItem(mediaItem4, "effect2", 0,
873                    mediaItem4.getDuration(), EffectColor.TYPE_COLOR,
874                    EffectColor.PINK);
875            mediaItem4.addEffect(effectColor2);
876
877            mVideoEditor1.generatePreview(new MediaProcessingProgressListener() {
878                public void onProgress(Object item, int action, int progress) {
879                }
880            });
881
882            mVideoEditor1.save();
883            mVideoEditor1.release();
884
885            getAfterMemory_updateLog(loggingInfo, false, i);
886        }
887        getAfterMemory_updateLog(loggingInfo, false, i);
888
889        /** Remove items and check for memory leak if any */
890        for( i=0; i<10; i++){
891            final VideoEditor mVideoEditor1b =
892                VideoEditorFactory.load(projectPath[i], true);
893            List<MediaItem> mediaList = mVideoEditor1b.getAllMediaItems();
894            assertEquals("Media Item List Size", 5, mediaList.size());
895
896            mediaList.get(3).removeEffect("effect1");
897            mediaList.get(3).removeEffect("effect2");
898            mediaList.get(2).removeOverlay("overlay");
899            mVideoEditor1b.removeTransition("transCF");
900            mVideoEditor1b.removeMediaItem("m5");
901            mVideoEditor1b.removeMediaItem("m4");
902            mVideoEditor1b.removeMediaItem("m3");
903            mVideoEditor1b.removeMediaItem("m2");
904            mVideoEditor1b.removeMediaItem("m1");
905            mVideoEditor1b.release();
906            getAfterMemory_updateLog(loggingInfo, true, i);
907        }
908        getAfterMemory_updateLog(loggingInfo, true, i);
909    }
910
911    /**
912     * To stress test : Multiple Export
913     *
914     * @throws Exception
915     */
916    // TODO : remove TC_STR_010
917    @LargeTest
918    public void testStressMultipleExport() throws Exception {
919        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
920        final String VideoItemFileName1 = INPUT_FILE_PATH +
921            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
922        final String VideoItemFileName2 = INPUT_FILE_PATH +
923            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
924        final String[] loggingInfo = new String[1];
925        final String outFilename = mVideoEditorHelper.createRandomFile(
926            mVideoEditor.getPath() + "/") + ".3gp";
927        int i = 0;
928        writeTestCaseHeader("testStressMultipleExport");
929        getBeginMemory();
930        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
931            "m1", VideoItemFileName1, renderingMode);
932        mVideoEditor.addMediaItem(mediaItem1);
933        mediaItem1.setExtractBoundaries(0, 10000);
934
935        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
936            "m2", VideoItemFileName2, renderingMode);
937        mVideoEditor.addMediaItem(mediaItem2);
938        mediaItem2.setExtractBoundaries(0, 15000);
939
940        for ( i = 0; i < 50; i++) {
941            if(i%4 ==0){
942                final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
943                mVideoEditor.setAspectRatio(aspectRatio);
944                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
945                    MediaProperties.BITRATE_256K,MediaProperties.ACODEC_AAC_LC,
946                        MediaProperties.VCODEC_H263,
947                        new ExportProgressListener() {
948                        public void onProgress(VideoEditor ve, String outFileName,
949                            int progress) {
950                        }
951                    });
952            }
953            if(i%4 ==1){
954                final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
955                mVideoEditor.setAspectRatio(aspectRatio);
956                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
957                    MediaProperties.BITRATE_384K,MediaProperties.ACODEC_AAC_LC,
958                        MediaProperties.VCODEC_MPEG4,
959                        new ExportProgressListener() {
960                        public void onProgress(VideoEditor ve, String outFileName,
961                            int progress) {
962                        }
963                    });
964            }
965            if(i%4 ==2){
966                final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
967                mVideoEditor.setAspectRatio(aspectRatio);
968                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
969                    MediaProperties.BITRATE_512K,MediaProperties.ACODEC_AAC_LC,
970                        MediaProperties.VCODEC_H264BP,
971                        new ExportProgressListener() {
972                        public void onProgress(VideoEditor ve, String outFileName,
973                            int progress) {
974                        }
975                    });
976            }
977            if(i%4 ==3){
978                final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
979                mVideoEditor.setAspectRatio(aspectRatio);
980                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
981                    MediaProperties.BITRATE_800K,MediaProperties.ACODEC_AAC_LC,
982                        MediaProperties.VCODEC_H264BP,
983                        new ExportProgressListener() {
984                        public void onProgress(VideoEditor ve, String outFileName,
985                            int progress) {
986                        }
987                    });
988            }
989            if (i % 10 == 0) {
990                getAfterMemory_updateLog(loggingInfo, false, i);
991            }
992        }
993        getAfterMemory_updateLog(loggingInfo, false, i);
994
995        /** Remove items and check for memory leak if any */
996        mVideoEditor.removeMediaItem("m2");
997        mVideoEditor.removeMediaItem("m1");
998
999        getAfterMemory_updateLog(loggingInfo, true, i);
1000    }
1001
1002    /**
1003     * To stress test Media Item,Overlays,Transitions and Ken Burn
1004     *
1005     * @throws Exception
1006     */
1007    // TODO : remove TC_STR_011
1008    @LargeTest
1009    public void testStressOverlayTransKenBurn() throws Exception {
1010        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1011        final String VideoItemFileName1 = INPUT_FILE_PATH +
1012            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
1013        final String ImageItemFileName2 = INPUT_FILE_PATH +
1014            "IMG_640x480.jpg";
1015        final String OverlayFile3 = INPUT_FILE_PATH +
1016            "IMG_640x480_Overlay1.png";
1017        final String audioFilename4 = INPUT_FILE_PATH +
1018            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1019        int i = 0;
1020        final String[] loggingInfo = new String[1];
1021        writeTestCaseHeader("testStressOverlayTransKenBurn");
1022        getBeginMemory();
1023        for ( i = 0; i < 10; i++) {
1024            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
1025                "m1" + i, VideoItemFileName1, renderingMode);
1026            mVideoEditor.addMediaItem(mediaItem1);
1027            mediaItem1.setExtractBoundaries(0, 10000);
1028
1029            final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
1030                "m2" + i, ImageItemFileName2, 10000, renderingMode);
1031            mVideoEditor.addMediaItem(mediaItem2);
1032
1033            final EffectColor effectColor1 =
1034                mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
1035                    (mediaItem1.getDuration() - 4000), 4000,
1036                    EffectColor.TYPE_SEPIA, 0);
1037            mediaItem1.addEffect(effectColor1);
1038
1039            final TransitionCrossfade tranCrossfade =
1040                new TransitionCrossfade("transCF" + i, mediaItem1,
1041                    mediaItem2, 4000, Transition.BEHAVIOR_MIDDLE_FAST);
1042            mVideoEditor.addTransition(tranCrossfade);
1043
1044            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile3,
1045                640, 480);
1046            final OverlayFrame overlayFrame =
1047                mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
1048                    mBitmap, 1000, 5000);
1049            mediaItem1.addOverlay(overlayFrame);
1050
1051            final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
1052                (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
1053                (mediaItem2.getWidth() / 2));
1054            final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
1055                mediaItem2.getHeight());
1056
1057            final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
1058                mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
1059                (mediaItem2.getDuration()-500));
1060            mediaItem2.addEffect(kbEffectOnMediaItem);
1061
1062            if(i == 5) {
1063                final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1064                    "Audio Track1", audioFilename4);
1065                mVideoEditor.addAudioTrack(audioTrack1);
1066            }
1067            getAfterMemory_updateLog(loggingInfo, false, i);
1068        }
1069        getAfterMemory_updateLog(loggingInfo, false, i);
1070
1071        /** Remove items and check for memory leak if any */
1072        for ( i = 0; i < 10; i++) {
1073            MediaImageItem m2 = (MediaImageItem)mVideoEditor.getMediaItem("m2"+i);
1074            MediaVideoItem m1 = (MediaVideoItem)mVideoEditor.getMediaItem("m1"+i);
1075            m2.removeEffect("KBOnM2" + i);
1076            m1.removeOverlay("overlay" + i);
1077            mVideoEditor.removeTransition("transCF" + i);
1078            m1.removeEffect("effect1" + i);
1079            mVideoEditor.removeMediaItem("m2" + i);
1080            mVideoEditor.removeMediaItem("m1" + i);
1081            if(i == 5) {
1082                mVideoEditor.removeAudioTrack("Audio Track1");
1083            }
1084            getAfterMemory_updateLog(loggingInfo, true, i);
1085        }
1086        getAfterMemory_updateLog(loggingInfo, true, i);
1087    }
1088
1089    /**
1090     * To test the performance : With an audio track with Video
1091     *
1092     * @throws Exception
1093     */
1094    // TODO : remove TC_STR_012
1095    @LargeTest
1096    public void testStressAudioTrackVideo() throws Exception {
1097        final String videoItemFileName1 = INPUT_FILE_PATH +
1098            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
1099        final String audioFilename1 = INPUT_FILE_PATH +
1100            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1101        final String audioFilename2 = INPUT_FILE_PATH +
1102            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
1103        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1104        final int audioVolume = 50;
1105        final String[] loggingInfo = new String[1];
1106        int i = 1;
1107        writeTestCaseHeader("testStressAudioTrackVideo");
1108        getBeginMemory();
1109        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
1110            "mediaItem1", videoItemFileName1, renderingMode);
1111        mVideoEditor.addMediaItem(mediaVideoItem);
1112
1113        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1114            "Audio Track1", audioFilename1);
1115        audioTrack1.disableDucking();
1116        audioTrack1.setVolume(audioVolume);
1117        mVideoEditor.addAudioTrack(audioTrack1);
1118
1119        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
1120            public void onProgress(Object item, int action, int progress) {
1121            }
1122        });
1123
1124        mVideoEditor.removeAudioTrack("Audio Track1");
1125
1126        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
1127            "Audio Track2", audioFilename2);
1128        audioTrack2.enableLoop();
1129
1130        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
1131            public void onProgress(Object item, int action, int progress) {
1132            }
1133        });
1134        getAfterMemory_updateLog(loggingInfo, false, i);
1135
1136        /** Remove items and check for memory leak if any */
1137        mVideoEditor.removeMediaItem("mediaItem1");
1138
1139        getAfterMemory_updateLog(loggingInfo, true, i);
1140    }
1141
1142    /**
1143     * To Test Stress : Story Board creation with out preview or export
1144     *
1145     * @throws Exception
1146     */
1147    // TODO : remove TC_STR_013
1148    @LargeTest
1149    public void testStressStoryBoard() throws Exception {
1150        final String videoItemFileName1 = INPUT_FILE_PATH +
1151            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
1152        final String videoItemFileName2 = INPUT_FILE_PATH +
1153            "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
1154        final String videoItemFileName3= INPUT_FILE_PATH +
1155            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
1156        final String imageItemFileName4 = INPUT_FILE_PATH +
1157            "IMG_1600x1200.jpg";
1158        final String imageItemFileName5 = INPUT_FILE_PATH +
1159            "IMG_176x144.jpg";
1160        final String audioFilename6 = INPUT_FILE_PATH +
1161            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
1162        final String audioFilename7 = INPUT_FILE_PATH +
1163            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1164
1165        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1166        final int audioVolume = 50;
1167        final String[] loggingInfo = new String[1];
1168        int i = 1;
1169
1170        writeTestCaseHeader("testStressStoryBoard");
1171        getBeginMemory();
1172        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
1173            "m1", videoItemFileName1, renderingMode);
1174        mediaItem1.setExtractBoundaries(0, 10000);
1175        mVideoEditor.addMediaItem(mediaItem1);
1176
1177        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
1178            "m2", videoItemFileName2, renderingMode);
1179        mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
1180            mediaItem2.getDuration()/2);
1181        mVideoEditor.addMediaItem(mediaItem2);
1182
1183        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
1184            "m3", videoItemFileName3, renderingMode);
1185        mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
1186            mediaItem3.getDuration());
1187        mVideoEditor.addMediaItem(mediaItem3);
1188
1189        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
1190            "m4", imageItemFileName4, 5000, renderingMode);
1191        mVideoEditor.addMediaItem(mediaItem4);
1192
1193        final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor,
1194            "m5", imageItemFileName5, 5000, renderingMode);
1195        mVideoEditor.addMediaItem(mediaItem5);
1196
1197        final TransitionCrossfade tranCrossfade =
1198            new TransitionCrossfade("transCF", mediaItem2, mediaItem3, 2500,
1199                Transition.BEHAVIOR_MIDDLE_FAST);
1200        mVideoEditor.addTransition(tranCrossfade);
1201
1202        final TransitionCrossfade tranCrossfade1 =
1203            new TransitionCrossfade("transCF1", mediaItem3, mediaItem4, 2500,
1204                Transition.BEHAVIOR_MIDDLE_FAST);
1205        mVideoEditor.addTransition(tranCrossfade1);
1206
1207        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
1208            "Audio Track1", audioFilename6);
1209        mVideoEditor.addAudioTrack(audioTrack1);
1210
1211        mVideoEditor.removeAudioTrack("Audio Track1");
1212        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
1213            "Audio Track2", audioFilename7);
1214        mVideoEditor.addAudioTrack(audioTrack2);
1215        audioTrack2.enableLoop();
1216        getAfterMemory_updateLog(loggingInfo, false, i);
1217
1218        /** Remove items and check for memory leak if any */
1219        getBeginMemory();
1220        mVideoEditor.removeAudioTrack("Audio Track2");
1221        mVideoEditor.removeTransition("transCF");
1222        mVideoEditor.removeTransition("transCF1");
1223        mVideoEditor.removeMediaItem("m5");
1224        mVideoEditor.removeMediaItem("m4");
1225        mVideoEditor.removeMediaItem("m3");
1226        mVideoEditor.removeMediaItem("m2");
1227        mVideoEditor.removeMediaItem("m1");
1228
1229        getAfterMemory_updateLog(loggingInfo, true, i);
1230    }
1231
1232     /**
1233     * To test the performance : With an audio track Only
1234     *
1235     * @throws Exception
1236     */
1237    // TODO : remove TC_STR_014
1238    @LargeTest
1239    public void testStressAudioTrackOnly() throws Exception {
1240
1241        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1242        final String AudioItemFileName1 = INPUT_FILE_PATH +
1243            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
1244        final String[] loggingInfo = new String[1];
1245        int i = 0;
1246        writeTestCaseHeader("testStressAudioTrackOnly");
1247        getBeginMemory();
1248        for ( i = 0; i < 50; i++) {
1249            final AudioTrack mediaItem1 = new AudioTrack(mVideoEditor,
1250                "m1" + i, AudioItemFileName1);
1251            mVideoEditor.addAudioTrack(mediaItem1);
1252            mediaItem1.enableLoop();
1253            mVideoEditor.removeAudioTrack("m1" + i);
1254            if (i % 10 == 0) {
1255                getAfterMemory_updateLog(loggingInfo, false, i);
1256            }
1257        }
1258        getAfterMemory_updateLog(loggingInfo, false, i);
1259    }
1260
1261    /**
1262     * This method will test thumbnail list extraction in a loop = 200 for Image
1263     * Item
1264     *
1265     * @throws Exception
1266     */
1267    // TODO : remove TC_STR_016  -- New Test Case
1268    @LargeTest
1269    public void testStressThumbnailImageItem() throws Exception {
1270        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
1271        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
1272        final String[] loggingInfo = new String[1];
1273        int i = 0;
1274        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
1275            "m1", imageItemFileName, 5000, renderingMode);
1276        writeTestCaseHeader("testStressThumbnailImageItem");
1277        getBeginMemory();
1278        for ( i = 0; i < 50; i++) {
1279            if (i % 4 == 0) {
1280                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1281                    mediaImageItem.getWidth() / 2 ,
1282                    mediaImageItem.getHeight() / 2, i, 5000, 2);
1283                // Recycle this Bitmap array
1284                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1285                    thumbNails[i1].recycle();
1286                }
1287            }
1288            if (i % 4 == 1) {
1289                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1290                    mediaImageItem.getWidth() / 2,
1291                    mediaImageItem.getHeight() * 3, i, 5000, 2);
1292                // Recycle this Bitmap array
1293                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1294                    thumbNails[i1].recycle();
1295                }
1296            }
1297            if (i % 4 == 2) {
1298                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1299                    mediaImageItem.getWidth() * 2,
1300                    mediaImageItem.getHeight() / 3, i, 5000, 2);
1301                // Recycle this Bitmap array
1302                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1303                    thumbNails[i1].recycle();
1304                }
1305            }
1306            if (i % 4 == 3) {
1307                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
1308                    mediaImageItem.getWidth(),
1309                    mediaImageItem.getHeight(), i, 5000, 2);
1310                // Recycle this Bitmap array
1311                for (int i1 = 0; i1 < thumbNails.length; i1++) {
1312                    thumbNails[i1].recycle();
1313                }
1314            }
1315            if (i % 10 == 0) {
1316                getAfterMemory_updateLog(loggingInfo, false, i);
1317            }
1318        }
1319        getAfterMemory_updateLog(loggingInfo, false, i);
1320    }
1321}
1322