Merge "Video Editor CTS Test Code: annotation suppress" (4c030b56) · Commits · e / os / android_frameworks_base

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkTestRunner.java

+6 −1

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2008 The Android Open Source Project
		* 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.
		@@ -32,6 +32,9 @@ import com.android.mediaframeworktest.functional.MediaEqualizerTest;
		import com.android.mediaframeworktest.functional.MediaPresetReverbTest;
		import com.android.mediaframeworktest.functional.MediaVirtualizerTest;
		import com.android.mediaframeworktest.functional.MediaVisualizerTest;
		/import for VideoEditor Test cases/
		import com.android.mediaframeworktest.functional.VideoEditorAPITest;

		import junit.framework.TestSuite;

		import android.test.InstrumentationTestRunner;
		@@ -69,6 +72,8 @@ public class MediaFrameworkTestRunner extends InstrumentationTestRunner {
		suite.addTestSuite(MediaPresetReverbTest.class);
		suite.addTestSuite(MediaVirtualizerTest.class);
		suite.addTestSuite(MediaVisualizerTest.class);
		/Test for Video Editor/
		suite.addTestSuite(VideoEditorAPITest.class);
		return suite;
		}

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/VideoEditorHelper.java

0 → 100644

+479 −0

Original line number	Diff line number	Diff line
		/*
		* 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;

		import java.io.File;
		import java.io.FileInputStream;
		import java.io.IOException;
		import java.text.SimpleDateFormat;
		import java.util.Date;
		import java.util.Random;

		import junit.framework.Assert;
		import android.graphics.Bitmap;
		import android.graphics.BitmapFactory;
		import android.media.videoeditor.AudioTrack;
		import android.media.videoeditor.EffectColor;
		import android.media.videoeditor.MediaImageItem;
		import android.media.videoeditor.MediaItem;
		import android.media.videoeditor.MediaVideoItem;
		import android.media.videoeditor.OverlayFrame;
		import android.media.videoeditor.TransitionAlpha;
		import android.media.videoeditor.TransitionCrossfade;
		import android.media.videoeditor.TransitionFadeBlack;
		import android.media.videoeditor.TransitionSliding;
		import android.media.videoeditor.VideoEditor;
		import android.media.videoeditor.VideoEditorFactory;
		import android.util.Log;
		import android.os.Environment;

		/**
		* This class has the names of the all the activity name and variables in the
		* instrumentation test.
		*/
		public class VideoEditorHelper extends Assert {

		private final String TAG = "VideoEditorMediaNames";

		public VideoEditorHelper() {

		}

		public static final String PROJECT_LOCATION_COMMON =
		Environment.getExternalStorageDirectory().toString() + "/";

		public static final String INPUT_FILE_PATH_COMMON = PROJECT_LOCATION_COMMON +
		"media_api/videoeditor/";

		// -----------------------------------------------------------------
		// HELPER METHODS
		// -----------------------------------------------------------------

		/**
		* This method creates an object of VideoEditor
		*
		* @param projectPath the directory where all files related to project will
		* be stored
		* @param className The class which implements the VideoEditor Class
		* @return the object of VideoEditor
		*/
		public VideoEditor createVideoEditor(String projectPath) {
		VideoEditor mVideoEditor = null;
		try {
		mVideoEditor = VideoEditorFactory.create(projectPath);
		assertNotNull("VideoEditor", mVideoEditor);
		} catch (Exception e) {
		fail("Unable to create Video Editor");
		}
		return mVideoEditor;
		}

		/**
		*This method deletes the VideoEditor object created using
		* createVideoEditor method
		*
		* @param videoEditor the VideoEditor object which needs to be cleaned up
		*/
		public void destroyVideoEditor(VideoEditor videoEditor) {
		// Release VideoEditor
		if (videoEditor != null) {
		try {
		videoEditor.release();
		} catch (Exception e) {
		fail("Unable to destory Video Editor");
		}
		}
		}

		/**
		*This Method checks the Range in "RangePercent" (say 10)
		*
		* @param int Expected data
		* @param actual data
		* @return boolean flag which confirms the range matching
		*/
		public boolean checkRange(long expected, long actual, long rangePercent) {
		long range = 0;
		range = (100 * actual) / expected;

		Log.i("checkRange", "Range = " + range);
		if ((range > (100 - rangePercent)) && (range < (100 + rangePercent))) {
		return true;
		} else {
		return false;
		}
		}

		/**
		*This Method Creates a Bitmap with the given input file
		*
		* @param file the Input whose Bitmap has top be extracted
		* @return an Object of EffectColor
		*/
		public Bitmap getBitmap(String file, int width, int height) throws IOException {
		assertNotNull("Bitmap File is Null", file);
		FileInputStream inputStream = null;
		Bitmap overlayBmp = null;
		if (!new File(file).exists())
		throw new IOException("File not Found " + file);
		try {
		final BitmapFactory.Options dbo = new BitmapFactory.Options();
		dbo.inJustDecodeBounds = true;
		dbo.outWidth = width;
		dbo.outHeight = height;
		File flPtr = new File(file);
		inputStream = new FileInputStream(flPtr);
		final Bitmap srcBitmap = BitmapFactory.decodeStream(inputStream);
		overlayBmp = Bitmap.createBitmap(srcBitmap);
		assertNotNull("Bitmap 1", srcBitmap);
		assertNotNull("Bitmap 2", overlayBmp);
		inputStream.close();
		} catch (IOException e) {
		e.printStackTrace();
		}
		return overlayBmp;
		}

		/**
		*This Method Create a Media Video Item with the specified params
		*
		* @return an Object of MediaVideoItem
		*/
		public MediaVideoItem createMediaItem(VideoEditor videoEditor,
		String MediaId, String filename, int renderingMode) {
		MediaVideoItem mvi = null;
		try {
		mvi = new MediaVideoItem(videoEditor, MediaId, filename,
		renderingMode);
		assertNotNull("Can not create an object of MediaVideoItem", mvi);
		} catch (IllegalArgumentException e) {
		throw new IllegalArgumentException
		("Can not create an object of Media Video Item with file name = "
		+ filename + " Issue = " + e.toString());
		} catch (IOException e) {
		assertTrue
		("Can not create an object of Media Video Item with file name = "
		+ filename + " Issue = " + e.toString(), false);
		}
		return mvi;
		}

		/**
		*This Method Create a Media Image Item with the specified params
		*
		* @return an Object of MediaImageItem
		*/
		public MediaImageItem createMediaItem(VideoEditor videoEditor,
		String MediaId, String filename, long duration, int renderingMode) {
		MediaImageItem mii = null;
		try {
		mii = new MediaImageItem(videoEditor, MediaId, filename, duration,
		renderingMode);
		assertNotNull("Can not create an object of MediaImageItem", mii);

		} catch (IllegalArgumentException e) {
		assertTrue("Can not create an object of Media Image with file name = "
		+ filename + " Issue = " + e.toString(), false);
		} catch (IOException e) {
		assertTrue("Can not create an object of Media Image with file name = "
		+ filename + " Issue = " + e.toString(), false);
		}
		return mii;
		}

		/**
		*This Method Create a Effect with the specified params
		*
		* @return an Object of EffectColor
		*/
		public EffectColor createEffectItem(MediaItem mediaItem, String effectId,
		long startTime, long duration, int effectType, int colorType) {
		EffectColor effectonMVI = null;
		effectonMVI = new EffectColor(mediaItem, effectId, startTime,
		duration, effectType, colorType);
		return effectonMVI;
		}

		/**
		*This Method creates object of Type Transition Cross fade
		*
		* @return TransitionCrossfade object
		*/
		public TransitionCrossfade createTCrossFade(String transitionId,
		MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
		int behavior) {
		Log.i("TransitionCrossfade Details === ", "Transid ID = " + transitionId +
		" Duration= " + durationMs + " Behaviour " + behavior);

		TransitionCrossfade transitionCF = null;
		transitionCF = new TransitionCrossfade(transitionId, afterMediaItem,
		beforeMediaItem, durationMs, behavior);
		return transitionCF;
		}

		/**
		*This Method creates object of Type TransitionFadeBlack
		*
		* @return TransitionFadeBlack object
		*/
		public TransitionFadeBlack createTFadeBlack(String transitionId,
		MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
		int behavior) {
		TransitionFadeBlack transitionFB = null;

		transitionFB = new TransitionFadeBlack(transitionId, afterMediaItem,
		beforeMediaItem, durationMs, behavior);
		return transitionFB;
		}

		/**
		*This Method creates object of Type TransitionSliding
		*
		* @return TransitionSliding object
		*/
		public TransitionSliding createTSliding(String transitionId,
		MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
		int behavior, int direction) {
		TransitionSliding transSlide = null;
		transSlide = new TransitionSliding(transitionId, afterMediaItem,
		beforeMediaItem, durationMs, behavior, direction);
		return transSlide;
		}

		/**
		*This Method creates object of Type TranistionAlpha
		*
		* @return TranistionAlpha object
		*/

		public TransitionAlpha createTAlpha(String transitionId,
		MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
		int behavior, String maskFilename, int blendingPercent, boolean invert) {
		TransitionAlpha transA = null;
		transA = new TransitionAlpha(transitionId, afterMediaItem,
		beforeMediaItem, durationMs, behavior, maskFilename,
		blendingPercent, invert);
		return transA;
		}

		/**
		*This Method creates object of Type OverlayFrame
		*
		* @return OverlayFrame object
		*/

		public OverlayFrame createOverlay(MediaItem mediaItem, String overlayId,
		Bitmap bitmap, long startTimeMs, long durationMs) {
		OverlayFrame overLayFrame = null;
		overLayFrame = new OverlayFrame(mediaItem, overlayId, bitmap,
		startTimeMs, durationMs);
		return overLayFrame;
		}

		/**
		*This Method creates object of Type AudioTrack
		*
		* @return OverlayFrame object
		*/
		public AudioTrack createAudio(VideoEditor videoEditor, String audioTrackId,
		String filename) {
		AudioTrack audio = null;
		try {
		audio = new AudioTrack(videoEditor, audioTrackId, filename);
		assertNotNull("Cant not create an object of an AudioTrack " +
		audioTrackId, audio);
		} catch (IllegalArgumentException e) {
		assertTrue("Can not create object of an AudioTrack " +
		audioTrackId + " Issue = " + e.toString(), false);
		} catch (IOException e) {
		assertTrue("Can not create object of an AudioTrack " +
		audioTrackId + " Issue = " + e.toString(), false);
		}
		return audio;
		}

		/**
		*This Method validates the Exported Movie,as per the specified params
		* during Export
		*/

		public void validateExport(VideoEditor videoEditor, String fileName,
		int export_height, int startTime, long endTime, int vCodec, int aCodec) {
		File tempFile = new File(fileName);
		assertEquals("Exported FileName", tempFile.exists(), true);
		final MediaVideoItem mvi = createMediaItem(videoEditor, "m1", fileName,
		MediaItem.RENDERING_MODE_BLACK_BORDER);

		Log.i(TAG, "VideoCodec for file = " + fileName +
		"\tExpected Video Codec = " + vCodec + "\tActual Video Codec = " +
		mvi.getVideoType());
		assertEquals("Export: Video Codec Mismatch for file = " + fileName +
		"\t<expected> " + vCodec + "\t<actual> " + mvi.getVideoType(),
		vCodec, mvi.getVideoType());

		Log.i(TAG, "Height for file = " + fileName + "\tExpected Height = " +
		export_height + "\tActual VideoHeight = " + mvi.getHeight());
		assertEquals("Export height Mismatch for file " + fileName +
		"\t<expected> " + export_height + "\t<actual> " + mvi.getHeight(),
		export_height, mvi.getHeight());
		if (startTime == 0) {
		if (endTime != 0) {
		Log.i(TAG, "TimeLine Expected = " + (startTime + endTime) +
		"\t VideoTime= " + mvi.getTimelineDuration());
		assertTrue("Timeline Duration Mismatch for file " + fileName +
		"<expected> " + (startTime + endTime) + "\t<actual> " +
		mvi.getTimelineDuration(), checkRange((startTime +
		endTime), mvi.getTimelineDuration(), 10));
		}
		} else {
		Log.i(TAG, "TimeLine Expected = " + (endTime - startTime) +
		"\t VideoTime= " + mvi.getTimelineDuration());
		assertTrue("Timeline Duration Mismatch for file " + fileName +
		"<expected> " + (endTime - startTime) + "\t<actual> " +
		mvi.getTimelineDuration(), checkRange((endTime -
		startTime), (int)mvi.getTimelineDuration(), 10));
		}
		}

		/**
		* @param videoEditor
		* @param fileName
		* @param export_bitrate
		* @param export_height
		* @param startTime
		* @param endTime
		* @param vCodec
		* @param aCodec
		*/
		public void validateExport(VideoEditor videoEditor, String fileName,
		int export_height, int startTime, int endTime, int vCodec, int aCodec) {
		File tempFile = new File(fileName);
		assertEquals("Exported FileName", tempFile.exists(), true);
		final MediaVideoItem mvi = createMediaItem(videoEditor, "m1", fileName,
		MediaItem.RENDERING_MODE_BLACK_BORDER);
		Log.i(TAG, "VideoCodec for file = " + fileName +
		"\tExpected Video Codec = " + vCodec + "\tActual Video Codec = " +
		mvi.getVideoType());
		assertEquals("Export: Video Codec Mismatch for file = " + fileName +
		"\t<expected> " + vCodec + "\t<actual> " + mvi.getVideoType(),
		vCodec, mvi.getVideoType());

		Log.i(TAG, "AudioCodec for file = " + fileName +
		"\tExpected Audio Codec = " + aCodec + "\tActual Audio Codec = " +
		mvi.getAudioType());
		assertEquals("Export: Audio Codec Mismatch for file = " + fileName +
		"\t<expected> " + aCodec + "\t<actual> " + mvi.getAudioType(),
		aCodec, mvi.getAudioType());

		Log.i(TAG, "Height for file = " + fileName + "\tExpected Height = " +
		export_height + "\tActual VideoHeight = " + mvi.getHeight());
		assertEquals("Export: height Mismatch for file " + fileName +
		"\t<expected> " + export_height + "\t<actual> " + mvi.getHeight(),
		export_height, mvi.getHeight());
		if (startTime == 0) {
		if (endTime != 0) {
		Log.i(TAG, "TimeLine Expected = " + (startTime + endTime) +
		"\t VideoTime= " + mvi.getTimelineDuration());
		assertTrue("Export :Timeline Duration Mismatch for file " +
		fileName + "<expected> " + (startTime + endTime) +
		"\t<actual> " + mvi.getTimelineDuration(),
		checkRange((startTime + endTime), mvi.getTimelineDuration(), 10));
		}
		} else {
		Log.i(TAG, "TimeLine Expected = " + (endTime-startTime) +
		"\t VideoTime= " + mvi.getTimelineDuration());
		assertTrue("Timeline Duration Mismatch for file " + fileName +
		"<expected> " + (endTime - startTime) + "\t<actual> " +
		mvi.getTimelineDuration(), checkRange((endTime -
		startTime), mvi.getTimelineDuration(), 10));
		}
		}

		/**
		* Check file and deletes it.
		*
		* @param filename
		*/
		public void checkDeleteExistingFile(String filename) {
		Log.i(TAG, ">>>>>>>>>>>>>>>>>>checkDeleteExistingFile = " + filename);
		if (filename != null) {
		File temp = new File(filename);
		if (temp != null && temp.exists()) {
		temp.delete();
		}
		}
		}

		/**
		* This method creates a Directory and filename
		*
		* @param location This is path where the file is to be created
		* "/sdcard/Output/"
		* @return Path in form of /sdcard/Output/200910100000
		*/
		public String createRandomFile(String location) {
		Random randomGenerator = new Random();
		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmssS");
		Date date = new Date();
		final String filePath = location + dateFormat.format(date) +
		randomGenerator.nextInt(10);
		Log.i(TAG, ">>>>>>>>>>>>>>>>createRandomFile Location= " + location +
		"\t FilePath = " + filePath);
		return filePath;
		}

		/**
		* This method recursively deletes all the file and directory
		*
		* @param directory where the files are located Example = "/sdcard/Input"
		* @return boolean True if deletion is successful else False
		*/
		public boolean deleteProject(File directory) {
		Log.i(TAG, ">>>>>>>>>>>>>>>>>>>>>>>>deleteProject directory= " +
		directory.toString());
		if (directory.isDirectory()) {
		String[] filesInDirecory = directory.list();
		for (int i = 0; i < filesInDirecory.length; i++) {
		boolean success = deleteProject(new File(directory,
		filesInDirecory[i]));
		if (!success) {
		return false;
		}
		}
		}
		return directory.delete();
		}

		/**
		* This method compares the array of Integer from 0 - 100
		*
		* @param data set of integer values received as progress
		* @return true if sucess else false
		*/
		public boolean checkProgressCBValues(int[] data) {
		boolean retFlag = false;
		for (int i = 0; i < 100; i++) {
		if (data[i] == 100) {
		retFlag = true;
		break;
		} else {
		retFlag = false;
		}
		}
		return retFlag;
		}
		}

media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorAPITest.java

0 → 100644

+2803 −0

File added.

Preview size limit exceeded, changes collapsed.