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