summaryrefslogtreecommitdiffstats
path: root/media/tests/MediaFrameworkTest
diff options
context:
space:
mode:
authorBasavapatna Dattaguru <dattaguru@google.com>2011-02-13 19:26:27 -0800
committerBasavapatna Dattaguru <dattaguru@google.com>2011-02-18 18:42:56 -0800
commitf1f9ff28c3acae5cb4eb309f28e7872aff35eff6 (patch)
treee6854fe4010f56f5d35cbb36fb21cfe793694aae /media/tests/MediaFrameworkTest
parent82314c013fbd94fdbad6a8f9687a6204c7966e12 (diff)
downloadframeworks_base-f1f9ff28c3acae5cb4eb309f28e7872aff35eff6.zip
frameworks_base-f1f9ff28c3acae5cb4eb309f28e7872aff35eff6.tar.gz
frameworks_base-f1f9ff28c3acae5cb4eb309f28e7872aff35eff6.tar.bz2
VideoEditor:IssueID:3396697: Added Performance test code
Updated with review comments: MediaFrameworkStressTestRunner.java deleted Updated with growing heap report in Stress test case Change-Id: I847f8810e2b844015c47b7d24e488a611d85287c
Diffstat (limited to 'media/tests/MediaFrameworkTest')
-rwxr-xr-xmedia/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkPerfTestRunner.java7
-rwxr-xr-xmedia/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaPlayerStressTestRunner.java4
-rw-r--r--media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java1086
-rwxr-xr-xmedia/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java1317
4 files changed, 2412 insertions, 2 deletions
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkPerfTestRunner.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkPerfTestRunner.java
index eaaa798..988b229 100755
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkPerfTestRunner.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkPerfTestRunner.java
@@ -17,7 +17,8 @@
package com.android.mediaframeworktest;
import com.android.mediaframeworktest.performance.MediaPlayerPerformance;
-
+/*Video Editor performance Test cases*/
+import com.android.mediaframeworktest.performance.VideoEditorPerformance;
import junit.framework.TestSuite;
import android.test.InstrumentationTestRunner;
@@ -26,7 +27,7 @@ import android.test.InstrumentationTestSuite;
/**
* Instrumentation Test Runner for all MediaPlayer tests.
- *
+ *
* Running all tests:
*
* adb shell am instrument \
@@ -40,6 +41,8 @@ public class MediaFrameworkPerfTestRunner extends InstrumentationTestRunner {
public TestSuite getAllTests() {
TestSuite suite = new InstrumentationTestSuite(this);
suite.addTestSuite(MediaPlayerPerformance.class);
+ /*Video Editor performance Test cases*/
+ suite.addTestSuite(VideoEditorPerformance.class);
return suite;
}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaPlayerStressTestRunner.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaPlayerStressTestRunner.java
index 5438061..0cd784c 100755
--- a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaPlayerStressTestRunner.java
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaPlayerStressTestRunner.java
@@ -19,6 +19,8 @@ package com.android.mediaframeworktest;
import android.test.InstrumentationTestRunner;
import android.test.InstrumentationTestSuite;
import com.android.mediaframeworktest.stress.MediaPlayerStressTest;
+/** Import for Video Editor Stress Test cases*/
+import com.android.mediaframeworktest.stress.VideoEditorStressTest;
import junit.framework.TestSuite;
@@ -28,6 +30,8 @@ public class MediaPlayerStressTestRunner extends InstrumentationTestRunner {
public TestSuite getAllTests() {
TestSuite suite = new InstrumentationTestSuite(this);
suite.addTestSuite(MediaPlayerStressTest.class);
+ /** Video Editor Stress Test cases*/
+ suite.addTestSuite(VideoEditorStressTest.class);
return suite;
}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java
new file mode 100644
index 0000000..4481d00
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java
@@ -0,0 +1,1086 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.android.mediaframeworktest.performance;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.Writer;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.os.Environment;
+import android.os.SystemClock;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+/**
+ * Junit / Instrumentation - performance measurement for media player and
+ * recorder
+ */
+public class VideoEditorPerformance extends
+ ActivityInstrumentationTestCase<MediaFrameworkTest> {
+
+ private final String TAG = "VideoEditorPerformance";
+
+ private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+ private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+ private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
+ "VideoEditorPerformance.txt";
+
+ public VideoEditorPerformance() {
+ super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+ }
+
+ private final String PROJECT_CLASS_NAME =
+ "android.media.videoeditor.VideoEditorImpl";
+ private VideoEditor mVideoEditor;
+ private VideoEditorHelper mVideoEditorHelper;
+
+ @Override
+ protected void setUp() throws Exception {
+ // setup for each test case.
+ super.setUp();
+ mVideoEditorHelper = new VideoEditorHelper();
+ // Create a random String which will be used as project path, where all
+ // project related files will be stored.
+ final String projectPath =
+ mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+ mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+ // Clean the directory created as project path
+ mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+ System.gc();
+ super.tearDown();
+ }
+
+ private void writeTimingInfo(String testCaseName, String[] information)
+ throws Exception {
+ File outFile = new File(VIDEOEDITOR_OUTPUT);
+ Writer output = new BufferedWriter(new FileWriter(outFile, true));
+ output.write(testCaseName + "\n\t");
+ for (int i = 0; i < information.length; i++) {
+ output.write(information[i]);
+ }
+ output.write("\n\n");
+ output.close();
+ }
+
+ private final int NUM_OF_ITERATIONS=20;
+
+ private float calculateTimeTaken(long beginTime, int numIterations)
+ throws Exception {
+ final long duration2 = SystemClock.uptimeMillis();
+ final long durationToCreateMediaItem = (duration2 - beginTime);
+ final float timeTaken1 = (float)durationToCreateMediaItem *
+ 1.0f/(float)numIterations;
+ return (timeTaken1);
+ }
+
+ private void createVideoItems(MediaVideoItem[] mediaVideoItem,
+ String videoItemFileName, int renderingMode, int startTime, int endTime) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
+ videoItemFileName, renderingMode);
+ mediaVideoItem[i].setExtractBoundaries(startTime, endTime);
+ } catch (Exception e1) {
+ assertTrue(
+ "Can not create an object of Video Item with file name = "
+ + videoItemFileName + "------ID:m" + i + " Issue = "
+ + e1.toString(), false);
+ }
+ }
+ }
+
+ private void addVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mVideoEditor.addMediaItem(mediaVideoItem[i]);
+ } catch (Exception e1) {
+ assertTrue(
+ "Can not add an object of Video Item with ID:m" + i +
+ " Issue = " + e1.toString(), false);
+ }
+ }
+ }
+
+ private void removeVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mVideoEditor.removeMediaItem(mediaVideoItem[i].getId());
+ } catch (Exception e1) {
+ assertTrue(
+ "Can not Remove an object of Video Item with ID:m" + i +
+ " Issue = " + e1.toString(), false);
+ }
+ }
+ }
+
+ private void createImageItems(MediaImageItem[] mIi,
+ String imageItemFileName, int renderingMode, int duration) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mIi[i] = new MediaImageItem(mVideoEditor, "m" + i,
+ imageItemFileName, duration, renderingMode);
+ } catch (Exception e1) {
+ assertTrue( " Cannot create Image Item", false);
+ }
+ }
+ }
+
+ private void addImageItems(MediaImageItem[] mIi) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mVideoEditor.addMediaItem(mIi[i]);
+ } catch (Exception e1) {
+ assertTrue("Cannot add Image item", false);
+ }
+ }
+ }
+
+ private void removeImageItems(MediaImageItem[] mIi) throws Exception {
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ try {
+ mVideoEditor.removeMediaItem(mIi[i].getId());
+ } catch (Exception e1) {
+ assertTrue("Cannot remove image item", false);
+ }
+ }
+ }
+ /**
+ * To test the performance of adding and removing the video media item
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_001
+ @LargeTest
+ public void testPerformanceAddRemoveVideoItem() throws Exception {
+ final String videoItemFileName = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final int videoItemStartTime = 0;
+ final int videoItemEndTime = 5000;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[3];
+ final MediaVideoItem[] mediaVideoItem =
+ new MediaVideoItem[NUM_OF_ITERATIONS];
+ float timeTaken = 0.0f;
+ long startTime = 0;
+
+ /** Time Take for creation of Media Video Item */
+ startTime = SystemClock.uptimeMillis();
+ createVideoItems(mediaVideoItem, videoItemFileName, renderingMode,
+ videoItemStartTime, videoItemEndTime);
+
+ timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+ loggingInfo[0] = "Time taken to Create Media Video Item\t" +
+ timeTaken;
+
+ /** Time Take for Addition of Media Video Item */
+ startTime = SystemClock.uptimeMillis();
+ addVideoItems(mediaVideoItem);
+ timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+ loggingInfo[1] = "\n\tTime taken to Add Media Video Item\t"
+ + timeTaken;
+
+ /** Time Take for Removal of Media Video Item */
+ startTime = SystemClock.uptimeMillis();
+ removeVideoItems(mediaVideoItem);
+ timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+ loggingInfo[2] = "\n\tTime taken to remove Media Video Item\t"
+ + timeTaken;
+
+ writeTimingInfo("testPerformanceAddRemoveVideoItem (in mSec)", loggingInfo);
+ }
+
+ /**
+ * To test the performance of adding and removing the image media item
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_002
+ @LargeTest
+ public void testPerformanceAddRemoveImageItem() throws Exception {
+ final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+ final int imageItemDuration = 0;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[3];
+ final MediaImageItem[] mediaImageItem =
+ new MediaImageItem[NUM_OF_ITERATIONS];
+ float timeTaken = 0.0f;
+
+ long beginTime = SystemClock.uptimeMillis();
+ createImageItems(mediaImageItem, imageItemFileName, renderingMode,
+ imageItemDuration);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[0] = "Time taken to Create Media Image Item\t" +
+ timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ addImageItems(mediaImageItem);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[1] = "\n\tTime taken to add Media Image Item\t" +
+ timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ removeImageItems(mediaImageItem);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[2] = "\n\tTime taken to remove Media Image Item\t"
+ + timeTaken;
+
+ writeTimingInfo("testPerformanceAddRemoveImageItem (in mSec)",
+ loggingInfo);
+ }
+
+ /**
+ * To test the performance of adding and removing the transition
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_003
+ @LargeTest
+ public void testPerformanceAddRemoveTransition() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final int videoItemStartTime1 = 0;
+ final int videoItemEndTime1 = 20000;
+ final String videoItemFileName2 = INPUT_FILE_PATH
+ + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final int videoItemStartTime2 = 0;
+ final int videoItemEndTime2 = 20000;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int transitionDuration = 5000;
+ final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+ final String[] loggingInfo = new String[3];
+ float timeTaken = 0.0f;
+
+ final MediaVideoItem[] mediaVideoItem =
+ new MediaVideoItem[(NUM_OF_ITERATIONS *10) + 1];
+
+ for (int i = 0; i < (NUM_OF_ITERATIONS *10); i+=2) {
+ try {
+ mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
+ videoItemFileName1, renderingMode);
+ mediaVideoItem[i+1] = new MediaVideoItem(mVideoEditor,
+ "m" + (i+1), videoItemFileName2, renderingMode);
+ mediaVideoItem[i].setExtractBoundaries(videoItemStartTime1,
+ videoItemEndTime1);
+ mediaVideoItem[i+1].setExtractBoundaries(videoItemStartTime2,
+ videoItemEndTime2);
+ } catch (Exception e1) {
+ assertTrue("Can not create Video Object Item with file name = "
+ + e1.toString(), false);
+ }
+ mVideoEditor.addMediaItem(mediaVideoItem[i]);
+ mVideoEditor.addMediaItem(mediaVideoItem[i+1]);
+ }
+ mediaVideoItem[(NUM_OF_ITERATIONS *10)] = new MediaVideoItem(mVideoEditor,
+ "m" + (NUM_OF_ITERATIONS *10), videoItemFileName1, renderingMode);
+ mediaVideoItem[(NUM_OF_ITERATIONS *10)].setExtractBoundaries(
+ videoItemStartTime1, videoItemEndTime1);
+ mVideoEditor.addMediaItem(mediaVideoItem[(NUM_OF_ITERATIONS *10)]);
+ final TransitionCrossfade tranCrossfade[] =
+ new TransitionCrossfade[(NUM_OF_ITERATIONS *10)];
+
+ long beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+ tranCrossfade[i] = new TransitionCrossfade("transition" + i,
+ mediaVideoItem[i], mediaVideoItem[i+1], transitionDuration,
+ transitionBehavior);
+ }
+ timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+ loggingInfo[0] = "Time taken to Create CrossFade Transition\t" +
+ timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+ mVideoEditor.addTransition(tranCrossfade[i]);
+ }
+ timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+ loggingInfo[1] = "\n\tTime taken to add CrossFade Transition\t" +
+ timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+ assertEquals("Removing Transitions", tranCrossfade[i], mVideoEditor
+ .removeTransition(tranCrossfade[i].getId()));
+ }
+ timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+ loggingInfo[2] = "\n\tTime taken to remove CrossFade Transition\t" +
+ timeTaken;
+
+ writeTimingInfo("testPerformanceAddRemoveTransition (in mSec)", loggingInfo);
+ }
+
+ /**
+ * To test performance of Export
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_004
+ @LargeTest
+ public void testPerformanceExport() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int outHeight = MediaProperties.HEIGHT_480;
+ final int outBitrate = MediaProperties.BITRATE_256K;
+ final int outVcodec = MediaProperties.VCODEC_H264BP;
+ final String[] loggingInfo = new String[1];
+ final String outFilename = mVideoEditorHelper
+ .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_12Mbps_AACLC_44.1khz_64kbps_s_1_17.mp4";
+ final String imageItemFileName1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+ final String videoItemFileName2 = INPUT_FILE_PATH +
+ "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_32kbps_m_1_17.3gp";
+ final String imageItemFileName2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+ final String videoItemFileName3 = INPUT_FILE_PATH +
+ "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
+ final String overlayFile = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+ final String audioTrackFilename = INPUT_FILE_PATH +
+ "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+ final String maskFilename = INPUT_FILE_PATH +
+ "TransitionSpiral_QVGA.jpg";
+
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFileName1, renderingMode);
+ mediaItem1.setExtractBoundaries(0, 20000);
+ mVideoEditor.addMediaItem(mediaItem1);
+
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2", imageItemFileName1, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3", videoItemFileName2, renderingMode);
+ mediaItem3.setExtractBoundaries(0, 20000);
+ mVideoEditor.addMediaItem(mediaItem3);
+
+ final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+ "m4", imageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem4);
+
+ final MediaVideoItem mediaItem5 = new MediaVideoItem(mVideoEditor,
+ "m5", videoItemFileName3, renderingMode);
+ mediaItem5.setExtractBoundaries(0, 20000);
+ mVideoEditor.addMediaItem(mediaItem5);
+ /**
+ * 7.Add TransitionAlpha, Apply this Transition as Begin for Media Item 1
+ * with duration = 2 sec behavior = BEHAVIOR_LINEAR, mask file name =
+ * TransitionSpiral_QVGA.jpg , blending percent = 50%, invert = true;
+ * */
+ final TransitionAlpha transition1 =
+ mVideoEditorHelper.createTAlpha("transition1", null, mediaItem1,
+ 2000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, true);
+ mVideoEditor.addTransition(transition1);
+
+ /**
+ * 8.Add Transition Sliding between MediaItem 2 and 3 ,
+ * Sliding Direction = DIRECTION_RIGHT_OUT_LEFT_IN,
+ * behavior = BEHAVIOR_MIDDLE_FAST and duration = 4sec
+ * */
+ final TransitionSliding transition2And3 =
+ mVideoEditorHelper.createTSliding("transition2", mediaItem2,
+ mediaItem3, 4000, Transition.BEHAVIOR_MIDDLE_FAST,
+ TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+ mVideoEditor.addTransition(transition2And3);
+
+ /**
+ * 9.Add Transition Crossfade between Media Item 3 and 4,
+ * behavior = BEHAVIOR_MIDDLE_SLOW, duration = 3.5 sec
+ * */
+ final TransitionCrossfade transition3And4 =
+ mVideoEditorHelper.createTCrossFade("transition3", mediaItem3,
+ mediaItem4, 3500, Transition.BEHAVIOR_MIDDLE_SLOW);
+ mVideoEditor.addTransition(transition3And4);
+
+ /**
+ * 10.Add Transition Fadeblack between Media Item 4 and 5,
+ * behavior = BEHAVIOR_SPEED_DOWN, duration = 3.5 sec
+ * */
+ final TransitionFadeBlack transition4And5 =
+ mVideoEditorHelper.createTFadeBlack("transition4", mediaItem4,
+ mediaItem5, 3500, Transition.BEHAVIOR_SPEED_DOWN);
+ mVideoEditor.addTransition(transition4And5);
+
+ /**
+ * 11.Add Effect 1 type="TYPE_SEPIA" to the MediaItem 1,
+ * start time=1sec and duration =4secs
+ * */
+ final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
+ mediaItem1, "effect1", 1000, 4000, EffectColor.TYPE_SEPIA, 0);
+ mediaItem1.addEffect(effectColor1);
+
+ /**
+ * 12.Add Overlay 1 to the MediaItem 3: Frame Overlay with start time = 1 sec
+ * duration = 4 sec with item = IMG_640x480_Overlay1.png
+ * */
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(overlayFile, 640,
+ 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem3, "overlay",
+ mBitmap, 1000, 4000);
+ mediaItem3.addOverlay(overlayFrame);
+ /**
+ * 13.Add Effect 2 type="TYPE_NEGATIVE" to the MediaItem 2,
+ * start time=8sec and duration =2secs
+ * */
+ final EffectColor effectColor2 = mVideoEditorHelper.createEffectItem(
+ mediaItem2, "effect2", 8000, 2000, EffectColor.TYPE_NEGATIVE, 0);
+ mediaItem2.addEffect(effectColor2);
+ /**
+ * 14.Add Effect 3 type="TYPE_COLOR" to the MediaItem 3, color param = "PINK",
+ * start time=5 sec and duration =3secs
+ * */
+ final EffectColor effectColor3 = mVideoEditorHelper.createEffectItem(
+ mediaItem3, "effect3", 5000, 3000, EffectColor.TYPE_COLOR,
+ EffectColor.PINK);
+ mediaItem3.addEffect(effectColor3);
+ /**
+ * 15.Add Effect 4 type="TYPE_FIFTIES" to the MediaItem 4,
+ * start time=2 sec and duration =1secs
+ * */
+ final EffectColor effectColor4 = mVideoEditorHelper.createEffectItem(
+ mediaItem4, "effect4", 2000, 1000, EffectColor.TYPE_FIFTIES, 0);
+ mediaItem4.addEffect(effectColor4);
+ /**
+ * 16.Add KenBurnsEffect for MediaItem 4 with
+ * duration = 3 sec and startTime = 4 sec
+ * StartRect
+ * left = org_height/3 ; top = org_width/3
+ * bottom = org_width/2 ; right = org_height/2
+ * EndRect
+ * left = 0 ; top = 0
+ * bottom = org_height; right = org_width
+ * */
+
+ final Rect startRect = new Rect((mediaItem4.getHeight() / 3),
+ (mediaItem4.getWidth() / 3), (mediaItem4.getHeight() / 2),
+ (mediaItem4.getWidth() / 2));
+ final Rect endRect = new Rect(0, 0, mediaItem4.getWidth(),
+ mediaItem4.getHeight());
+ final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+ mediaItem4, "KBOnM2", startRect, endRect,4000 , 3000);
+ mediaItem4.addEffect(kbEffectOnMediaItem);
+
+ /** 17.Add Audio Track,Set extract boundaries o to 10 sec.
+ * */
+ final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+ mVideoEditor, "audioTrack", audioTrackFilename);
+ mVideoEditor.addAudioTrack(audioTrack);
+ /** 18.Enable Looping for Audio Track.
+ * */
+ audioTrack.enableLoop();
+ float timeTaken = 0.0f;
+ final long beginTime = SystemClock.uptimeMillis();
+ try {
+ mVideoEditor.export(outFilename, outHeight, outBitrate,
+ new ExportProgressListener() {
+ public void onProgress(VideoEditor ve,
+ String outFileName, int progress) {
+ }
+ });
+ } catch (Exception e) {
+ assertTrue("Error in Export" + e.toString(), false);
+ }
+ mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+
+ timeTaken = calculateTimeTaken(beginTime, 1);
+ loggingInfo[0] = "Time taken to do ONE export of storyboard duration\t"
+ + mVideoEditor.getDuration() + " is :\t" + timeTaken;
+
+ writeTimingInfo("testPerformanceExport (in mSec)", loggingInfo);
+ mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+ }
+
+
+ /**
+ * To test the performance of thumbnail extraction
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_005
+ @LargeTest
+ public void testPerformanceThumbnailVideoItem() throws Exception {
+ final String videoItemFileName = INPUT_FILE_PATH
+ + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final int videoItemStartTime = 0;
+ final int videoItemEndTime = 20000;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[1];
+
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFileName, renderingMode);
+ mediaVideoItem.setExtractBoundaries(videoItemStartTime,
+ videoItemEndTime);
+
+ float timeTaken = 0.0f;
+ long beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ mediaVideoItem.getThumbnail(mediaVideoItem.getWidth() / 2,
+ mediaVideoItem.getHeight() / 2, i);
+ }
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[0] = "Duration taken to get Video Thumbnails\t" +
+ timeTaken;
+
+ writeTimingInfo("testPerformanceThumbnailVideoItem (in mSec)", loggingInfo);
+ }
+
+ /**
+ * To test the performance of adding and removing the overlay to media item
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_006
+ @LargeTest
+ public void testPerformanceOverlayVideoItem() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final int videoItemStartTime1 = 0;
+ final int videoItemEndTime1 = 10000;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String overlayFilename = INPUT_FILE_PATH
+ + "IMG_640x480_Overlay1.png";
+ final int overlayStartTime = 1000;
+ final int overlayDuration = 5000;
+
+ final String[] loggingInfo = new String[2];
+ MediaVideoItem mediaVideoItem = null;
+
+ try {
+ mediaVideoItem = new MediaVideoItem(mVideoEditor, "m0",
+ videoItemFileName1, renderingMode);
+ mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
+ videoItemEndTime1);
+ } catch (Exception e1) {
+ assertTrue("Can not create Video Item with file name = "
+ + e1.toString(), false);
+ }
+ final OverlayFrame overlayFrame[] = new OverlayFrame[NUM_OF_ITERATIONS];
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(overlayFilename,
+ 640, 480);
+ float timeTaken = 0.0f;
+ long beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ overlayFrame[i] = new OverlayFrame(mediaVideoItem, "overlay" + i,
+ mBitmap, overlayStartTime, overlayDuration);
+ mediaVideoItem.addOverlay(overlayFrame[i]);
+ }
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[0] = "Time taken to add & create Overlay\t" + timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ assertEquals("Removing Overlays", overlayFrame[i],
+ mediaVideoItem.removeOverlay((overlayFrame[i].getId())));
+ }
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[1] = "\n\tTime taken to remove Overlay\t" +
+ timeTaken;
+
+ writeTimingInfo("testPerformanceOverlayVideoItem (in mSec)", loggingInfo);
+ }
+
+ /**
+ * To test the performance of get properties of a Video media item
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_007
+ @LargeTest
+ public void testPerformanceVideoItemProperties() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final int videoItemStartTime1 = 0;
+ final int videoItemEndTime1 = 10100;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+ final int fileType = MediaProperties.FILE_MP4;
+ final int videoCodecType = MediaProperties.VCODEC_H264BP;
+ final int duration = 77366;
+ final int videoBitrate = 3169971;
+ final int fps = 30;
+ final int videoProfile = MediaProperties.H264_PROFILE_0_LEVEL_1_3;
+ final int width = 1080;
+ final int height = MediaProperties.HEIGHT_720;
+ float timeTaken = 0.0f;
+ final String[] loggingInfo = new String[1];
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "m0", videoItemFileName1, renderingMode);
+ mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
+ videoItemEndTime1);
+ long beginTime = SystemClock.uptimeMillis();
+ for (int i = 0; i < (NUM_OF_ITERATIONS*10); i++) {
+ try {
+ assertEquals("Aspect Ratio Mismatch",
+ aspectRatio, mediaVideoItem.getAspectRatio());
+ assertEquals("File Type Mismatch",
+ fileType, mediaVideoItem.getFileType());
+ assertEquals("VideoCodec Mismatch",
+ videoCodecType, mediaVideoItem.getVideoType());
+ assertEquals("duration Mismatch",
+ duration, mediaVideoItem.getDuration());
+ assertEquals("Video Profile ",
+ videoProfile, mediaVideoItem.getVideoProfile());
+ assertEquals("Video height ",
+ height, mediaVideoItem.getHeight());
+ assertEquals("Video width ",
+ width, mediaVideoItem.getWidth());
+ } catch (Exception e1) {
+ assertTrue("Can not create Video Item with file name = "
+ + e1.toString(), false);
+ }
+ }
+ timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS*10));
+ loggingInfo[0] = "Time taken to get Media Properties\t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceVideoItemProperties:", loggingInfo);
+ }
+
+ /**
+ * To test the performance of generatePreview : with Transitions
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_008
+ @LargeTest
+ public void testPerformanceGeneratePreviewWithTransitions()
+ throws Exception {
+ final String videoItemFileName = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String imageItemFileName = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+ long averageTime = 0;
+ final String[] loggingInfo = new String[1];
+
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName, renderingMode);
+ mediaVideoItem.setExtractBoundaries(0, 10000);
+ mVideoEditor.addMediaItem(mediaVideoItem);
+
+ final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+ "mediaItem2", imageItemFileName, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaImageItem);
+
+ final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+ "transitionCrossFade", mediaVideoItem, mediaImageItem,
+ 5000, transitionBehavior);
+ mVideoEditor.addTransition(transitionCrossFade);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ final long duration2 = SystemClock.uptimeMillis();
+ mVideoEditor.removeTransition(transitionCrossFade.getId());
+ mVideoEditor.addTransition(transitionCrossFade);
+ averageTime += (duration2 - duration1);
+ }
+ final long durationToAddObjects = averageTime;
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] = "Time taken to Generate Preview with transition\t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceGeneratePreviewWithTransitions:",
+ loggingInfo);
+ }
+
+ /**
+ * To test the performance of generatePreview : with KenBurn
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_009
+ @LargeTest
+ public void testPerformanceWithKenBurn() throws Exception {
+ final String videoItemFileName = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String imageItemFileName = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ long averageTime = 0;
+ final String[] loggingInfo = new String[1];
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName, renderingMode);
+ mediaVideoItem.setExtractBoundaries(0, 10000);
+ mVideoEditor.addMediaItem(mediaVideoItem);
+
+ final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+ "mediaItem2", imageItemFileName, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaImageItem);
+
+ final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
+ (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
+ (mediaImageItem.getWidth() / 2));
+ final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
+ mediaImageItem.getHeight());
+ final EffectKenBurns kbEffectOnMediaItem =
+ new EffectKenBurns(mediaImageItem, "KBOnM2", startRect, endRect,
+ 500, 3000);
+ mediaImageItem.addEffect(kbEffectOnMediaItem);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ final long duration2 = SystemClock.uptimeMillis();
+ mediaImageItem.removeEffect(kbEffectOnMediaItem.getId());
+ mediaImageItem.addEffect(kbEffectOnMediaItem);
+ averageTime += duration2 - duration1;
+ }
+
+ final long durationToAddObjects = (averageTime);
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] = "Time taken to Generate KenBurn Effect \t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceWithKenBurn", loggingInfo);
+ }
+
+ /**
+ * To test the performance of generatePreview : with Transitions and
+ * Effect,Overlapping scenario
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_010
+ @LargeTest
+ public void testPerformanceEffectOverlappingTransition() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String videoItemFileName2 = INPUT_FILE_PATH
+ + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final int videoStartTime1 = 0;
+ final int videoEndTime1 = 10000;
+ final int videoStartTime2 = 0;
+ final int videoEndTime2 = 10000;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int transitionDuration = 5000;
+ final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+ final int effectItemStartTime = 5000;
+ final int effectItemDurationTime = 5000;
+ final int effectType = EffectColor.TYPE_COLOR;
+ final int effectColorType = EffectColor.GREEN;
+ long averageDuration = 0;
+
+ final String[] loggingInfo = new String[1];
+ final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName1, renderingMode);
+ mediaVideoItem1.setExtractBoundaries(videoStartTime1, videoEndTime1);
+ mVideoEditor.addMediaItem(mediaVideoItem1);
+
+ final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
+ "mediaItem2", videoItemFileName2, renderingMode);
+ mediaVideoItem2.setExtractBoundaries(videoStartTime2, videoEndTime2);
+ mVideoEditor.addMediaItem(mediaVideoItem2);
+
+ final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+ "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
+ transitionDuration, transitionBehavior);
+ mVideoEditor.addTransition(transitionCrossFade);
+
+ final EffectColor effectColor = new EffectColor(mediaVideoItem1,
+ "effect", effectItemStartTime, effectItemDurationTime, effectType,
+ effectColorType);
+ mediaVideoItem1.addEffect(effectColor);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ final long duration2 = SystemClock.uptimeMillis();
+ mVideoEditor.removeTransition(transitionCrossFade.getId());
+ mVideoEditor.addTransition(transitionCrossFade);
+ averageDuration += (duration2 - duration1);
+ }
+ SystemClock.uptimeMillis();
+ final long durationToAddObjects = (averageDuration);
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] =
+ "Time taken to testPerformanceEffectOverlappingTransition\t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceEffectOverlappingTransition:",
+ loggingInfo);
+ }
+
+ /**
+ * To test creation of story board with Transition and Two Effects, Effect
+ * overlapping transitions
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_011
+ @LargeTest
+ public void testPerformanceTransitionWithEffectOverlapping() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String videoItemFileName2 = INPUT_FILE_PATH
+ + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int transitionDuration = 5000;
+ final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+ final int effectItemStartTime1 = 5000;
+ final int effectItemDurationTime1 = 5000;
+ final int effectType1 = EffectColor.TYPE_COLOR;
+ final int effectColorType1 = EffectColor.GREEN;
+ final int effectItemStartTime2 = 5000;
+ final int effectItemDurationTime2 = 5000;
+ final int effectType2 = EffectColor.TYPE_COLOR;
+ final int effectColorType2 = EffectColor.GREEN;
+ int averageTime = 0;
+ final String[] loggingInfo = new String[1];
+
+ final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaVideoItem1);
+
+ final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
+ "mediaItem2", videoItemFileName2, renderingMode);
+ mVideoEditor.addMediaItem(mediaVideoItem2);
+
+ final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+ "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
+ transitionDuration, transitionBehavior);
+ mVideoEditor.addTransition(transitionCrossFade);
+
+ final EffectColor effectColor1 = new EffectColor(mediaVideoItem1,
+ "effect1", effectItemStartTime1, effectItemDurationTime1,
+ effectType1, effectColorType1);
+ mediaVideoItem1.addEffect(effectColor1);
+
+ final EffectColor effectColor2 = new EffectColor(mediaVideoItem2,
+ "effect2", effectItemStartTime2, effectItemDurationTime2,
+ effectType2, effectColorType2);
+ mediaVideoItem2.addEffect(effectColor2);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ final long duration2 = SystemClock.uptimeMillis();
+ mVideoEditor.removeTransition(transitionCrossFade.getId());
+ mVideoEditor.addTransition(transitionCrossFade);
+ averageTime += duration2 - duration1;
+ }
+ final long durationToAddObjects = (averageTime);
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] = "Time taken to TransitionWithEffectOverlapping\t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceTransitionWithEffectOverlapping",
+ loggingInfo);
+ }
+
+ /**
+ *To test ThumbnailList for H264
+ */
+ // TODO : TC_PRF_12
+ @LargeTest
+ public void testThumbnailH264NonIFrame() throws Exception {
+ final String videoItemFilename = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final int outWidth = 1080;
+ final int outHeight = 720;
+ final int atTime = 2400;
+ long durationToAddObjects = 0;
+ int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[1];
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFilename, renderingMode);
+ assertNotNull("MediaVideoItem", mediaVideoItem);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
+ final long duration2 = SystemClock.uptimeMillis();
+ durationToAddObjects += (duration2 - duration1);
+ }
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] = "Time taken for Thumbnail generation \t"
+ + timeTaken;
+ writeTimingInfo("testThumbnailH264NonIFrame", loggingInfo);
+ }
+
+ /**
+ *To test ThumbnailList for H264
+ */
+ // TODO : TC_PRF_13
+ @LargeTest
+ public void testThumbnailH264AnIFrame() throws Exception {
+ final String videoItemFilename = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final int outWidth = 1080;
+ final int outHeight = 720;
+ final int atTime = 3000;
+ int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[1];
+ long durationToAddObjects = 0;
+
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFilename, renderingMode);
+ assertNotNull("MediaVideoItem", mediaVideoItem);
+
+ for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+ final long duration1 = SystemClock.uptimeMillis();
+ mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
+ final long duration2 = SystemClock.uptimeMillis();
+ durationToAddObjects += (duration2 - duration1);
+ }
+ final float timeTaken = (float)durationToAddObjects *
+ 1.0f/(float)NUM_OF_ITERATIONS;
+ loggingInfo[0] = "Time taken Thumbnail generation \t"
+ + timeTaken;
+ writeTimingInfo("testThumbnailH264AnIFrame", loggingInfo);
+ }
+
+ /**
+ * To test the performance : With an audio track
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_014
+ @LargeTest
+ public void testPerformanceWithAudioTrack() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String audioFilename1 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+ final String audioFilename2 = INPUT_FILE_PATH +
+ "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int audioVolume = 50;
+ final String[] loggingInfo = new String[2];
+ float timeTaken = 0.0f;
+
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaVideoItem);
+
+ final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+ "Audio Track1", audioFilename1);
+ audioTrack1.disableDucking();
+ audioTrack1.setVolume(audioVolume);
+ mVideoEditor.addAudioTrack(audioTrack1);
+
+ long beginTime = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ timeTaken = calculateTimeTaken(beginTime, 1);
+ loggingInfo[0] = "Time taken for 1st Audio Track (AACLC)\t"
+ + timeTaken;
+
+ final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+ "Audio Track2", audioFilename2);
+ audioTrack2.enableLoop();
+
+ beginTime = SystemClock.uptimeMillis();
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ timeTaken = calculateTimeTaken(beginTime, 1);
+ loggingInfo[1] = "\n\tTime taken for 2nd Audio Track(AMRNB)\t"
+ + timeTaken;
+
+ writeTimingInfo("testPerformanceWithAudioTrack", loggingInfo);
+ }
+
+ /**
+ * To test the performance of adding and removing the
+ * image media item with 640 x 480
+ *
+ * @throws Exception
+ */
+ // TODO : remove PRF_015
+ @LargeTest
+ public void testPerformanceAddRemoveImageItem640x480() throws Exception {
+ final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+ final int imageItemDuration = 0;
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[3];
+
+ float timeTaken = 0.0f;
+
+ final MediaImageItem[] mediaImageItem =
+ new MediaImageItem[NUM_OF_ITERATIONS];
+ long beginTime = SystemClock.uptimeMillis();
+ createImageItems(mediaImageItem, imageItemFileName, renderingMode,
+ imageItemDuration);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[0] = "Time taken to Create Media Image Item (640x480)\t"
+ + timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ addImageItems(mediaImageItem);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[1] = "\n\tTime taken to add Media Image Item (640x480)\t"
+ + timeTaken;
+
+ beginTime = SystemClock.uptimeMillis();
+ removeImageItems(mediaImageItem);
+ timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+ loggingInfo[2] = "\n\tTime taken to remove Media Image Item (640x480)\t"
+ + timeTaken;
+ writeTimingInfo("testPerformanceAddRemoveImageItem640x480 (in mSec)", loggingInfo);
+ }
+
+
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java
new file mode 100755
index 0000000..0e70dd3
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java
@@ -0,0 +1,1317 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.mediaframeworktest.stress;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.Writer;
+import java.util.List;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.os.Environment;
+import android.os.SystemClock;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+import android.media.videoeditor.VideoEditorFactory;
+import android.media.videoeditor.ExtractAudioWaveformProgressListener;
+
+import android.os.Debug;
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+/**
+ * Junit / Instrumentation - performance measurement for media player and
+ * recorder
+ */
+public class VideoEditorStressTest
+ extends ActivityInstrumentationTestCase<MediaFrameworkTest> {
+
+ private final String TAG = "VideoEditorPerformance";
+
+ private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+ private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+ private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
+ "VideoEditorStressMemOutput.txt";
+
+ private long BeginJavaMemory;
+ private long AfterJavaMemory;
+
+ private long BeginNativeMemory;
+ private long AfterNativeMemory;
+
+ public VideoEditorStressTest() {
+ super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+ new File(VIDEOEDITOR_OUTPUT).delete();
+ }
+
+ private final String PROJECT_CLASS_NAME =
+ "android.media.videoeditor.VideoEditorImpl";
+ private VideoEditor mVideoEditor;
+ private VideoEditorHelper mVideoEditorHelper;
+
+ @Override
+ protected void setUp() throws Exception {
+ // setup for each test case.
+ super.setUp();
+ mVideoEditorHelper = new VideoEditorHelper();
+ // Create a random String which will be used as project path, where all
+ // project related files will be stored.
+ final String projectPath =
+ mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+ mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+ }
+
+ @Override
+ protected void tearDown() throws Exception {
+ mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+ // Clean the directory created as project path
+ mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+ System.gc();
+ super.tearDown();
+ }
+
+ private void writeTimingInfo(String[] information)
+ throws Exception {
+ File outFile = new File(VIDEOEDITOR_OUTPUT);
+ Writer output = new BufferedWriter(new FileWriter(outFile, true));
+ for (int i = 0; i < information.length; i++) {
+ output.write(information[i]);
+ }
+ output.close();
+ }
+
+ private void writeTestCaseHeader(String testCaseName)
+ throws Exception {
+ File outFile = new File(VIDEOEDITOR_OUTPUT);
+ Writer output = new BufferedWriter(new FileWriter(outFile, true));
+ output.write("\n\n" + testCaseName + "\n");
+ output.close();
+ }
+
+ private void getBeginMemory() throws Exception {
+ System.gc();
+ Thread.sleep(2500);
+ BeginNativeMemory = Debug.getNativeHeapAllocatedSize();
+ }
+ private void getAfterMemory_updateLog(String[] loggingInfo, boolean when,
+ int iteration)
+ throws Exception {
+ System.gc();
+ Thread.sleep(2500);
+ AfterNativeMemory = Debug.getNativeHeapAllocatedSize();
+ if(when == false){
+ loggingInfo[0] = "\n Before Remove: iteration No.= " + iteration +
+ "\t " + (AfterNativeMemory - BeginNativeMemory);
+ } else {
+ loggingInfo[0] = "\n After Remove: iteration No.= " + iteration +
+ "\t " + (AfterNativeMemory - BeginNativeMemory);
+ }
+ writeTimingInfo(loggingInfo);
+ }
+
+ /**
+ * To stress test MediaItem(Video Item) adding functionality
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_001
+ @LargeTest
+ public void testStressAddRemoveVideoItem() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_176x144_15fps_144kbps_AMRNB_8kHz_12.2kbps_m_1_17.3gp";
+ final String videoItemFileName2 = INPUT_FILE_PATH +
+ "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+ final String videoItemFileName3 = INPUT_FILE_PATH +
+ "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+ final String videoItemFileName4 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+ final String[] loggingInfo = new String[1];
+ writeTestCaseHeader("testStressAddRemoveVideoItem");
+ int i = 0;
+ getBeginMemory();
+
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1" + i, videoItemFileName1, renderingMode);
+ mediaItem1.setExtractBoundaries(0, 5000);
+ mVideoEditor.addMediaItem(mediaItem1);
+ }
+ if (i % 4 == 1) {
+ final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+ "m2" + i, videoItemFileName2, renderingMode);
+ mediaItem2.setExtractBoundaries(0, 10000);
+ mVideoEditor.addMediaItem(mediaItem2);
+ }
+ if (i % 4 == 2) {
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3" + i, videoItemFileName3, renderingMode);
+ mediaItem3.setExtractBoundaries(30000, 45000);
+ mVideoEditor.addMediaItem(mediaItem3);
+ }
+ if (i % 4 == 3) {
+ final MediaVideoItem mediaItem4 = new MediaVideoItem(mVideoEditor,
+ "m4" + i, videoItemFileName4, renderingMode);
+ mediaItem4.setExtractBoundaries(10000, 30000);
+ mVideoEditor.addMediaItem(mediaItem4);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ mVideoEditor.removeMediaItem("m1" + i);
+ }
+ if (i % 4 == 1) {
+ mVideoEditor.removeMediaItem("m2" + i);
+ }
+ if (i % 4 == 2) {
+ mVideoEditor.removeMediaItem("m3" + i);
+ }
+ if (i % 4 == 3) {
+ mVideoEditor.removeMediaItem("m4" + i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test MediaItem(Image Item) adding functionality
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_002
+ @LargeTest
+ public void testStressAddRemoveImageItem() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String ImageItemFileName1 = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_640x480.jpg";
+ final String ImageItemFileName3 = INPUT_FILE_PATH +
+ "IMG_320x240.jpg";
+ final String ImageItemFileName4 = INPUT_FILE_PATH +
+ "IMG_176x144.jpg";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ writeTestCaseHeader("testStressAddRemoveImageItem");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ final MediaImageItem mediaItem1 = new MediaImageItem(mVideoEditor,
+ "m1"+ i, ImageItemFileName1, 5000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ }
+ if (i % 4 == 1) {
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2"+ i, ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+ }
+ if (i % 4 == 2) {
+ final MediaImageItem mediaItem3 = new MediaImageItem(mVideoEditor,
+ "m3"+ i, ImageItemFileName3, 15000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem3);
+ }
+ if (i % 4 == 3) {
+ final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+ "m4"+ i, ImageItemFileName4, 20000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem4);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ mVideoEditor.removeMediaItem("m1"+i);
+ }
+ if (i % 4 == 1) {
+ mVideoEditor.removeMediaItem("m2"+i);
+ }
+ if (i % 4 == 2) {
+ mVideoEditor.removeMediaItem("m3"+i);
+ }
+ if (i % 4 == 3) {
+ mVideoEditor.removeMediaItem("m4"+i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test transition
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_003
+ @LargeTest
+ public void testStressAddRemoveTransition() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final String VideoItemFileName3 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final String maskFilename = INPUT_FILE_PATH +
+ "TransitionSpiral_QVGA.jpg";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ writeTestCaseHeader("testStressAddRemoveTransition");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1"+i, VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+ final TransitionCrossfade tranCrossfade =
+ new TransitionCrossfade("transCF" + i, null,
+ mediaItem1, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
+ mVideoEditor.addTransition(tranCrossfade);
+ }
+ if (i % 4 == 1) {
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1"+i, VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2" +i, ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+
+ final TransitionAlpha transitionAlpha =
+ mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem1,
+ mediaItem2, 5000, Transition.BEHAVIOR_SPEED_UP,
+ maskFilename, 10, false);
+ transitionAlpha.setDuration(4000);
+ mVideoEditor.addTransition(transitionAlpha);
+ }
+ if (i % 4 == 2) {
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2" + i, ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3" + i, VideoItemFileName3, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem3);
+
+ mediaItem3.setExtractBoundaries(0, 10000);
+ final TransitionAlpha transitionAlpha =
+ mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem2,
+ mediaItem3, 5000, Transition.BEHAVIOR_SPEED_UP,
+ maskFilename, 10, false);
+ transitionAlpha.setDuration(4000);
+ mVideoEditor.addTransition(transitionAlpha);
+
+ mediaItem3.setExtractBoundaries(0, 6000);
+
+ final TransitionSliding transition2And3 =
+ mVideoEditorHelper.createTSliding("transSlide" +i, mediaItem2,
+ mediaItem3, 3000, Transition.BEHAVIOR_MIDDLE_FAST,
+ TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
+ mVideoEditor.addTransition(transition2And3);
+ }
+ if (i % 4 == 3) {
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3" + i, VideoItemFileName3, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem3);
+ mediaItem3.setExtractBoundaries(0, 5000);
+
+ final TransitionFadeBlack transition3 =
+ mVideoEditorHelper.createTFadeBlack("transFB" +i, mediaItem3,
+ null, 2500, Transition.BEHAVIOR_SPEED_UP);
+ transition3.setDuration(500);
+ mVideoEditor.addTransition(transition3);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ mVideoEditor.removeTransition("transCF" + i);
+ mVideoEditor.removeMediaItem("m1" + i);
+ }
+ if (i % 4 == 1) {
+ mVideoEditor.removeTransition("transAlpha" + i);
+ mVideoEditor.removeMediaItem("m1" + i);
+ mVideoEditor.removeMediaItem("m2" + i);
+ }
+ if (i % 4 == 2) {
+ mVideoEditor.removeTransition("transSlide" +i);
+ mVideoEditor.removeMediaItem("m2" + i);
+ mVideoEditor.removeMediaItem("m3" + i);
+ }
+ if (i % 4 == 3) {
+ mVideoEditor.removeMediaItem("m3" + i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test overlay
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_004
+ @LargeTest
+ public void testStressAddRemoveOverlay() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_640x480.jpg";
+ final String OverlayFile3 = INPUT_FILE_PATH +
+ "IMG_640x480_Overlay1.png";
+ final String OverlayFile4 = INPUT_FILE_PATH +
+ "IMG_640x480_Overlay2.png";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2", ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+ writeTestCaseHeader("testStressAddRemoveOverlay");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 3 == 0) {
+ mediaItem1.setExtractBoundaries(0, 10000);
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(
+ OverlayFile3, 640, 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+ mBitmap, 1000, 5000);
+ mediaItem1.addOverlay(overlayFrame);
+ mediaItem1.removeOverlay("overlay"+i);
+ }
+ if (i % 3 == 1) {
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(
+ OverlayFile4, 640, 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem2, "overlay" + i,
+ mBitmap, 1000, 5000);
+ mediaItem2.addOverlay(overlayFrame);
+ mediaItem2.removeOverlay("overlay"+i);
+ }
+ if (i % 3 == 2) {
+ mediaItem1.setExtractBoundaries(0, 10000);
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(
+ OverlayFile4, 640, 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+ mBitmap, 0, mediaItem1.getDuration());
+ mediaItem1.addOverlay(overlayFrame);
+ mediaItem1.removeOverlay("overlay"+i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+
+ /**
+ * To stress test Effects
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_005
+ @LargeTest
+ public void testStressAddRemoveEffects() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final String[] loggingInfo = new String[1];
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2", ImageItemFileName2, 10000, renderingMode);
+ int i = 0;
+ mVideoEditor.addMediaItem(mediaItem2);
+ writeTestCaseHeader("testStressAddRemoveEffects");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 5 == 0) {
+ mediaItem1.setExtractBoundaries(10000, 30000);
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+ 10000, (mediaItem1.getTimelineDuration()-1000),
+ EffectColor.TYPE_COLOR, EffectColor.GREEN);
+ mediaItem1.addEffect(effectColor1);
+ }
+ if (i % 5 == 1) {
+ mediaItem2.setDuration(20000);
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
+ 0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
+ mediaItem2.addEffect(effectColor1);
+ }
+ if (i % 5 == 2) {
+ mediaItem1.setExtractBoundaries(10000, 30000);
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+ (mediaItem1.getTimelineDuration() - 4000), 4000,
+ EffectColor.TYPE_SEPIA, 0);
+ mediaItem1.addEffect(effectColor1);
+ }
+ if (i % 5 == 3) {
+ mediaItem2.setDuration(20000);
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
+ 10000, 4000, EffectColor.TYPE_NEGATIVE, 0);
+ mediaItem2.addEffect(effectColor1);
+ }
+ if (i % 5 == 4) {
+ mediaItem2.setDuration(20000);
+ final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
+ (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
+ (mediaItem2.getWidth() / 2));
+ final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
+ mediaItem2.getHeight());
+ final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+ mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
+ (mediaItem2.getDuration() - 500));
+ mediaItem2.addEffect(kbEffectOnMediaItem);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 5 == 0) {
+ mediaItem1.removeEffect("effect1"+i);
+ }
+ if (i % 5 == 1) {
+ mediaItem1.removeEffect("effect1"+i);
+ }
+ if (i % 5 == 2) {
+ mediaItem1.removeEffect("effect1"+i);
+ }
+ if (i % 5 == 3) {
+ mediaItem1.removeEffect("effect1"+i);
+ }
+ if (i % 5 == 4) {
+ mediaItem1.removeEffect("KBOnM2"+i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * This method will test thumbnail list extraction in a loop = 200 for Video
+ * Item
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_006
+ @LargeTest
+ public void testStressThumbnailVideoItem() throws Exception {
+ final String videoItemFileName = INPUT_FILE_PATH
+ + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFileName, renderingMode);
+ writeTestCaseHeader("testStressThumbnailVideoItem");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ final Bitmap[] thumbNails =
+ mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*3,
+ mediaVideoItem.getHeight()*2, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 1) {
+ final Bitmap[] thumbNails =
+ mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()/2,
+ mediaVideoItem.getHeight() * 3, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 2) {
+ final Bitmap[] thumbNails =
+ mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*2,
+ mediaVideoItem.getHeight() / 3, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 3) {
+ final Bitmap[] thumbNails =
+ mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth(),
+ mediaVideoItem.getHeight(), i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+
+ /**
+ * To stress test media properties
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_007
+ @LargeTest
+ public void testStressMediaProperties() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_640x480.jpg";
+ final String AudioItemFileName3 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ final int videoAspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+ final int videoFileType = MediaProperties.FILE_MP4;
+ final int videoCodecType = MediaProperties.VCODEC_H264BP;
+ final int videoDuration = 77366;
+ final int videoProfile = MediaProperties.H264_PROFILE_0_LEVEL_1_3;
+ final int videoHeight = MediaProperties.HEIGHT_720;
+ final int videoWidth = 1080;
+
+ final int imageAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+ final int imageFileType = MediaProperties.FILE_JPEG;
+ final int imageWidth = 640;
+ final int imageHeight = MediaProperties.HEIGHT_480;
+
+ final int audioDuration = 77554;
+ final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+ final int audioSamplingFrequency = 44100;
+ final int audioChannel = 2;
+ writeTestCaseHeader("testStressMediaProperties");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 3 == 0) {
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1" + i, VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 20000);
+ assertEquals("Aspect Ratio Mismatch",
+ videoAspectRatio, mediaItem1.getAspectRatio());
+ assertEquals("File Type Mismatch",
+ videoFileType, mediaItem1.getFileType());
+ assertEquals("VideoCodec Mismatch",
+ videoCodecType, mediaItem1.getVideoType());
+ assertEquals("duration Mismatch",
+ videoDuration, mediaItem1.getDuration());
+ assertEquals("Video Profile ",
+ videoProfile, mediaItem1.getVideoProfile());
+ assertEquals("Video height ",
+ videoHeight, mediaItem1.getHeight());
+ assertEquals("Video width ",
+ videoWidth, mediaItem1.getWidth());
+ mVideoEditor.removeMediaItem("m1" + i);
+ }
+ if (i % 3 == 1) {
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2" + i, ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+ assertEquals("Aspect Ratio Mismatch",
+ imageAspectRatio, mediaItem2.getAspectRatio());
+ assertEquals("File Type Mismatch",
+ imageFileType, mediaItem2.getFileType());
+ assertEquals("Image height",
+ imageHeight, mediaItem2.getHeight());
+ assertEquals("Image width",
+ imageWidth, mediaItem2.getWidth());
+ mVideoEditor.removeMediaItem("m2" + i);
+ }
+ if (i % 3 == 2) {
+ final AudioTrack mediaItem3 = new AudioTrack(mVideoEditor,
+ "m3" + i, AudioItemFileName3);
+ mVideoEditor.addAudioTrack(mediaItem3);
+ assertEquals("AudioType Mismatch", audioCodecType,
+ mediaItem3.getAudioType());
+ assertEquals("Audio Sampling", audioSamplingFrequency,
+ mediaItem3.getAudioSamplingFrequency());
+ assertEquals("Audio Channels",
+ audioChannel, mediaItem3.getAudioChannels());
+ assertEquals("duration Mismatch", audioDuration,
+ mediaItem3.getDuration());
+ mVideoEditor.removeAudioTrack("m3" + i);
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+
+ /**
+ * To stress test insert and move of mediaitems
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_008
+ @LargeTest
+ public void testStressInsertMovieItems() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String VideoItemFileName2 = INPUT_FILE_PATH +
+ "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+ final String VideoItemFileName3 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ writeTestCaseHeader("testStressInsertMoveItems");
+
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+
+ final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+ "m2", VideoItemFileName2, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+ mediaItem2.setExtractBoundaries(0, 15000);
+
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3" + i, VideoItemFileName3, renderingMode);
+ mediaItem3.setExtractBoundaries(0, 15000);
+ mVideoEditor.insertMediaItem(mediaItem3, "m1");
+ mVideoEditor.moveMediaItem("m2", "m3" + i);
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ mVideoEditor.removeMediaItem("m3" + i);
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ }
+ mVideoEditor.removeMediaItem("m2");
+ mVideoEditor.removeMediaItem("m1");
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test : load and save
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_009
+ @LargeTest
+ public void testStressLoadAndSave() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String VideoItemFileName2 = INPUT_FILE_PATH +
+ "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+ final String VideoItemFileName3 = INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+ final String ImageItemFileName4 = INPUT_FILE_PATH +
+ "IMG_640x480.jpg";
+ final String ImageItemFileName5 = INPUT_FILE_PATH +
+ "IMG_176x144.jpg";
+ final String OverlayFile6 = INPUT_FILE_PATH +
+ "IMG_640x480_Overlay1.png";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ final String[] projectPath = new String[10];
+ writeTestCaseHeader("testStressLoadAndSave");
+ getBeginMemory();
+ for( i=0; i < 10; i++){
+
+ projectPath[i] =
+ mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+ final VideoEditor mVideoEditor1 =
+ mVideoEditorHelper.createVideoEditor(projectPath[i]);
+
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor1,
+ "m1", VideoItemFileName1, renderingMode);
+ mVideoEditor1.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+
+ final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor1,
+ "m2", VideoItemFileName2, renderingMode);
+ mVideoEditor1.addMediaItem(mediaItem2);
+ mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
+ mediaItem2.getDuration()/2);
+
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor1,
+ "m3", VideoItemFileName3, renderingMode);
+ mVideoEditor1.addMediaItem(mediaItem3);
+ mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
+ mediaItem3.getDuration());
+
+ final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor1,
+ "m4", ImageItemFileName4, 5000, renderingMode);
+ mVideoEditor1.addMediaItem(mediaItem4);
+
+ final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor1,
+ "m5", ImageItemFileName5, 5000, renderingMode);
+ mVideoEditor1.addMediaItem(mediaItem5);
+
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem3, "effect1",
+ 10000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+ mediaItem3.addEffect(effectColor1);
+
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(OverlayFile6,
+ 640, 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem4, "overlay",
+ mBitmap, 4000, 1000);
+ mediaItem4.addOverlay(overlayFrame);
+
+ final TransitionCrossfade tranCrossfade =
+ new TransitionCrossfade("transCF", mediaItem1,
+ mediaItem2, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
+ mVideoEditor1.addTransition(tranCrossfade);
+
+ final EffectColor effectColor2 =
+ mVideoEditorHelper.createEffectItem(mediaItem4, "effect2", 0,
+ mediaItem4.getDuration(), EffectColor.TYPE_COLOR,
+ EffectColor.PINK);
+ mediaItem4.addEffect(effectColor2);
+
+ mVideoEditor1.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+
+ mVideoEditor1.save();
+ mVideoEditor1.release();
+
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for( i=0; i<10; i++){
+ final VideoEditor mVideoEditor1b =
+ VideoEditorFactory.load(projectPath[i], true);
+ List<MediaItem> mediaList = mVideoEditor1b.getAllMediaItems();
+ assertEquals("Media Item List Size", 5, mediaList.size());
+
+ mediaList.get(3).removeEffect("effect1");
+ mediaList.get(3).removeEffect("effect2");
+ mediaList.get(2).removeOverlay("overlay");
+ mVideoEditor1b.removeTransition("transCF");
+ mVideoEditor1b.removeMediaItem("m5");
+ mVideoEditor1b.removeMediaItem("m4");
+ mVideoEditor1b.removeMediaItem("m3");
+ mVideoEditor1b.removeMediaItem("m2");
+ mVideoEditor1b.removeMediaItem("m1");
+ mVideoEditor1b.release();
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test : Multiple Export
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_010
+ @LargeTest
+ public void testStressMultipleExport() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String VideoItemFileName2 = INPUT_FILE_PATH +
+ "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+ final String[] loggingInfo = new String[1];
+ final String outFilename = mVideoEditorHelper.createRandomFile(
+ mVideoEditor.getPath() + "/") + ".3gp";
+ int i = 0;
+ writeTestCaseHeader("testStressMultipleExport");
+ getBeginMemory();
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+
+ final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+ "m2", VideoItemFileName2, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+ mediaItem2.setExtractBoundaries(0, 15000);
+
+ for ( i = 0; i < 50; i++) {
+ if(i%4 ==0){
+ final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+ mVideoEditor.setAspectRatio(aspectRatio);
+ mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
+ MediaProperties.BITRATE_256K,MediaProperties.ACODEC_AAC_LC,
+ MediaProperties.VCODEC_H263,
+ new ExportProgressListener() {
+ public void onProgress(VideoEditor ve, String outFileName,
+ int progress) {
+ }
+ });
+ }
+ if(i%4 ==1){
+ final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
+ mVideoEditor.setAspectRatio(aspectRatio);
+ mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+ MediaProperties.BITRATE_384K,MediaProperties.ACODEC_AAC_LC,
+ MediaProperties.VCODEC_MPEG4,
+ new ExportProgressListener() {
+ public void onProgress(VideoEditor ve, String outFileName,
+ int progress) {
+ }
+ });
+ }
+ if(i%4 ==2){
+ final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
+ mVideoEditor.setAspectRatio(aspectRatio);
+ mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+ MediaProperties.BITRATE_512K,MediaProperties.ACODEC_AAC_LC,
+ MediaProperties.VCODEC_H264BP,
+ new ExportProgressListener() {
+ public void onProgress(VideoEditor ve, String outFileName,
+ int progress) {
+ }
+ });
+ }
+ if(i%4 ==3){
+ final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+ mVideoEditor.setAspectRatio(aspectRatio);
+ mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
+ MediaProperties.BITRATE_800K,MediaProperties.ACODEC_AAC_LC,
+ MediaProperties.VCODEC_H264BP,
+ new ExportProgressListener() {
+ public void onProgress(VideoEditor ve, String outFileName,
+ int progress) {
+ }
+ });
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ mVideoEditor.removeMediaItem("m2");
+ mVideoEditor.removeMediaItem("m1");
+
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To stress test Media Item,Overlays,Transitions and Ken Burn
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_011
+ @LargeTest
+ public void testStressOverlayTransKenBurn() throws Exception {
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String VideoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+ final String ImageItemFileName2 = INPUT_FILE_PATH +
+ "IMG_640x480.jpg";
+ final String OverlayFile3 = INPUT_FILE_PATH +
+ "IMG_640x480_Overlay1.png";
+ final String audioFilename4 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+ int i = 0;
+ final String[] loggingInfo = new String[1];
+ writeTestCaseHeader("testStressOverlayTransKenBurn");
+ getBeginMemory();
+ for ( i = 0; i < 10; i++) {
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1" + i, VideoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem1);
+ mediaItem1.setExtractBoundaries(0, 10000);
+
+ final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+ "m2" + i, ImageItemFileName2, 10000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem2);
+
+ final EffectColor effectColor1 =
+ mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+ (mediaItem1.getDuration() - 4000), 4000,
+ EffectColor.TYPE_SEPIA, 0);
+ mediaItem1.addEffect(effectColor1);
+
+ final TransitionCrossfade tranCrossfade =
+ new TransitionCrossfade("transCF" + i, mediaItem1,
+ mediaItem2, 4000, Transition.BEHAVIOR_MIDDLE_FAST);
+ mVideoEditor.addTransition(tranCrossfade);
+
+ final Bitmap mBitmap = mVideoEditorHelper.getBitmap(OverlayFile3,
+ 640, 480);
+ final OverlayFrame overlayFrame =
+ mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+ mBitmap, 1000, 5000);
+ mediaItem1.addOverlay(overlayFrame);
+
+ final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
+ (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
+ (mediaItem2.getWidth() / 2));
+ final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
+ mediaItem2.getHeight());
+
+ final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+ mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
+ (mediaItem2.getDuration()-500));
+ mediaItem2.addEffect(kbEffectOnMediaItem);
+
+ if(i == 5) {
+ final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+ "Audio Track1", audioFilename4);
+ mVideoEditor.addAudioTrack(audioTrack1);
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ for ( i = 0; i < 10; i++) {
+ MediaImageItem m2 = (MediaImageItem)mVideoEditor.getMediaItem("m2"+i);
+ MediaVideoItem m1 = (MediaVideoItem)mVideoEditor.getMediaItem("m1"+i);
+ m2.removeEffect("KBOnM2" + i);
+ m1.removeOverlay("overlay" + i);
+ mVideoEditor.removeTransition("transCF" + i);
+ m1.removeEffect("effect1" + i);
+ mVideoEditor.removeMediaItem("m2" + i);
+ mVideoEditor.removeMediaItem("m1" + i);
+ if(i == 5) {
+ mVideoEditor.removeAudioTrack("Audio Track1");
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To test the performance : With an audio track with Video
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_012
+ @LargeTest
+ public void testStressAudioTrackVideo() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+ final String audioFilename1 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+ final String audioFilename2 = INPUT_FILE_PATH +
+ "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int audioVolume = 50;
+ final String[] loggingInfo = new String[1];
+ int i = 1;
+ writeTestCaseHeader("testStressAudioTrackVideo");
+ getBeginMemory();
+ final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+ "mediaItem1", videoItemFileName1, renderingMode);
+ mVideoEditor.addMediaItem(mediaVideoItem);
+
+ final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+ "Audio Track1", audioFilename1);
+ audioTrack1.disableDucking();
+ audioTrack1.setVolume(audioVolume);
+ mVideoEditor.addAudioTrack(audioTrack1);
+
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+
+ mVideoEditor.removeAudioTrack("Audio Track1");
+
+ final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+ "Audio Track2", audioFilename2);
+ audioTrack2.enableLoop();
+
+ mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+ public void onProgress(Object item, int action, int progress) {
+ }
+ });
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ mVideoEditor.removeMediaItem("mediaItem1");
+
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To Test Stress : Story Board creation with out preview or export
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_013
+ @LargeTest
+ public void testStressStoryBoard() throws Exception {
+ final String videoItemFileName1 = INPUT_FILE_PATH +
+ "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
+ final String videoItemFileName2 = INPUT_FILE_PATH +
+ "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
+ final String videoItemFileName3= INPUT_FILE_PATH +
+ "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+ final String imageItemFileName4 = INPUT_FILE_PATH +
+ "IMG_1600x1200.jpg";
+ final String imageItemFileName5 = INPUT_FILE_PATH +
+ "IMG_176x144.jpg";
+ final String audioFilename6 = INPUT_FILE_PATH +
+ "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+ final String audioFilename7 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final int audioVolume = 50;
+ final String[] loggingInfo = new String[1];
+ int i = 1;
+
+ writeTestCaseHeader("testStressStoryBoard");
+ getBeginMemory();
+ final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+ "m1", videoItemFileName1, renderingMode);
+ mediaItem1.setExtractBoundaries(0, 10000);
+ mVideoEditor.addMediaItem(mediaItem1);
+
+ final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+ "m2", videoItemFileName2, renderingMode);
+ mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
+ mediaItem2.getDuration()/2);
+ mVideoEditor.addMediaItem(mediaItem2);
+
+ final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+ "m3", videoItemFileName3, renderingMode);
+ mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
+ mediaItem3.getDuration());
+ mVideoEditor.addMediaItem(mediaItem3);
+
+ final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+ "m4", imageItemFileName4, 5000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem4);
+
+ final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor,
+ "m5", imageItemFileName5, 5000, renderingMode);
+ mVideoEditor.addMediaItem(mediaItem5);
+
+ final TransitionCrossfade tranCrossfade =
+ new TransitionCrossfade("transCF", mediaItem2, mediaItem3, 2500,
+ Transition.BEHAVIOR_MIDDLE_FAST);
+ mVideoEditor.addTransition(tranCrossfade);
+
+ final TransitionCrossfade tranCrossfade1 =
+ new TransitionCrossfade("transCF1", mediaItem3, mediaItem4, 2500,
+ Transition.BEHAVIOR_MIDDLE_FAST);
+ mVideoEditor.addTransition(tranCrossfade1);
+
+ final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+ "Audio Track1", audioFilename6);
+ mVideoEditor.addAudioTrack(audioTrack1);
+
+ mVideoEditor.removeAudioTrack("Audio Track1");
+ final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+ "Audio Track2", audioFilename7);
+ mVideoEditor.addAudioTrack(audioTrack2);
+ audioTrack2.enableLoop();
+ getAfterMemory_updateLog(loggingInfo, false, i);
+
+ /** Remove items and check for memory leak if any */
+ getBeginMemory();
+ mVideoEditor.removeAudioTrack("Audio Track2");
+ mVideoEditor.removeTransition("transCF");
+ mVideoEditor.removeTransition("transCF1");
+ mVideoEditor.removeMediaItem("m5");
+ mVideoEditor.removeMediaItem("m4");
+ mVideoEditor.removeMediaItem("m3");
+ mVideoEditor.removeMediaItem("m2");
+ mVideoEditor.removeMediaItem("m1");
+
+ getAfterMemory_updateLog(loggingInfo, true, i);
+ }
+
+ /**
+ * To test the performance : With an audio track Only
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_014
+ @LargeTest
+ public void testStressAudioTrackOnly() throws Exception {
+
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String AudioItemFileName1 = INPUT_FILE_PATH +
+ "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ writeTestCaseHeader("testStressAudioTrackOnly");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ final AudioTrack mediaItem1 = new AudioTrack(mVideoEditor,
+ "m1" + i, AudioItemFileName1);
+ mVideoEditor.addAudioTrack(mediaItem1);
+ mediaItem1.enableLoop();
+ mVideoEditor.removeAudioTrack("m1" + i);
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+
+ /**
+ * This method will test thumbnail list extraction in a loop = 200 for Image
+ * Item
+ *
+ * @throws Exception
+ */
+ // TODO : remove TC_STR_016 -- New Test Case
+ @LargeTest
+ public void testStressThumbnailImageItem() throws Exception {
+ final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+ final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+ final String[] loggingInfo = new String[1];
+ int i = 0;
+ final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+ "m1", imageItemFileName, 5000, renderingMode);
+ writeTestCaseHeader("testStressThumbnailImageItem");
+ getBeginMemory();
+ for ( i = 0; i < 50; i++) {
+ if (i % 4 == 0) {
+ final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+ mediaImageItem.getWidth() / 2 ,
+ mediaImageItem.getHeight() / 2, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 1) {
+ final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+ mediaImageItem.getWidth() / 2,
+ mediaImageItem.getHeight() * 3, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 2) {
+ final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+ mediaImageItem.getWidth() * 2,
+ mediaImageItem.getHeight() / 3, i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 4 == 3) {
+ final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+ mediaImageItem.getWidth(),
+ mediaImageItem.getHeight(), i, 5000, 2);
+ // Recycle this Bitmap array
+ for (int i1 = 0; i1 < thumbNails.length; i1++) {
+ thumbNails[i1].recycle();
+ }
+ }
+ if (i % 10 == 0) {
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+ }
+ getAfterMemory_updateLog(loggingInfo, false, i);
+ }
+}
generated by cgit v1.1 at 2024-10-30 09:48:12 +0000