Merge "Benchmark: add asserts for common failures in sdk tests" (250a6b5f) · Commits · e / os / android_frameworks_av

media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/DecoderTest.java

+67 −88

Original line number	Diff line number	Diff line
		@@ -46,6 +46,7 @@ import java.util.Arrays;
		import java.util.Collection;

		import static org.junit.Assert.assertTrue;
		import static org.junit.Assert.assertEquals;

		@RunWith(Parameterized.class)
		public class DecoderTest {
		@@ -107,28 +108,23 @@ public class DecoderTest {
		@Test(timeout = PER_TEST_TIMEOUT_MS)
		public void testDecoder() throws IOException {
		File inputFile = new File(mInputFilePath + mInputFile);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
		inputFile.exists());
		FileInputStream fileInput = new FileInputStream(inputFile);
		FileDescriptor fileDescriptor = fileInput.getFD();
		Extractor extractor = new Extractor();
		int trackCount = extractor.setUpExtractor(fileDescriptor);
		assertTrue("Extraction failed. No tracks for file: " + mInputFile, (trackCount > 0));
		ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
		ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>();
		if (trackCount <= 0) {
		Log.e(TAG, "Extraction failed. No tracks for file: " + mInputFile);
		return;
		}
		for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
		extractor.selectExtractorTrack(currentTrack);
		MediaFormat format = extractor.getFormat(currentTrack);
		String mime = format.getString(MediaFormat.KEY_MIME);
		ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, false);
		if (mediaCodecs.size() <= 0) {
		Log.e(TAG,
		"No suitable codecs found for file: " + mInputFile
		+ " track : " + currentTrack + " mime: " + mime);
		continue;
		}
		assertTrue("No suitable codecs found for file: " + mInputFile + " track : " +
		currentTrack + " mime: " + mime, (mediaCodecs.size() > 0));

		// Get samples from extractor
		int sampleSize;
		do {
		@@ -141,9 +137,8 @@ public class DecoderTest {
		inputBuffer.add(dataBuffer);
		frameInfo.add(bufInfo);
		if (DEBUG) {
		Log.d(TAG,
		"Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = "
		+ bufInfo.presentationTimeUs + " size = " + bufInfo.size);
		Log.d(TAG, "Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = " +
		bufInfo.presentationTimeUs + " size = " + bufInfo.size);
		}
		} while (sampleSize > 0);
		for (String codecName : mediaCodecs) {
		@@ -154,32 +149,22 @@ public class DecoderTest {
		}
		File outFile = new File(mOutputFilePath + "decoder.out");
		if (outFile.exists()) {
		if (!outFile.delete()) {
		Log.e(TAG, " Unable to delete existing file" + outFile.toString());
		}
		assertTrue(" Unable to delete existing file" + outFile.toString(),
		outFile.delete());
		}
		if (outFile.createNewFile()) {
		assertTrue("Unable to create file: " + outFile.toString(),
		outFile.createNewFile());
		decodeOutputStream = new FileOutputStream(outFile);
		} else {
		Log.e(TAG, "Unable to create file: " + outFile.toString());
		}
		}
		Decoder decoder = new Decoder();
		decoder.setupDecoder(decodeOutputStream);
		int status =
		decoder.decode(inputBuffer, frameInfo, mAsyncMode, format, codecName);
		int status = decoder.decode(inputBuffer, frameInfo, mAsyncMode, format, codecName);
		decoder.deInitCodec();
		if (status == 0) {
		decoder.dumpStatistics(
		mInputFile + " " + codecName, extractor.getClipDuration());
		Log.i(TAG,
		"Decoding Successful for file: " + mInputFile
		+ " with codec: " + codecName);
		} else {
		Log.e(TAG,
		"Decoder returned error " + status + " for file: " + mInputFile
		+ " with codec: " + codecName);
		}
		assertEquals("Decoder returned error " + status + " for file: " + mInputFile +
		" with codec: " + codecName, 0, status);
		decoder.dumpStatistics(mInputFile + " " + codecName, extractor.getClipDuration());
		Log.i(TAG, "Decoding Successful for file: " + mInputFile + " with codec: " +
		codecName);
		decoder.resetDecoder();
		if (decodeOutputStream != null) {
		decodeOutputStream.close();
		@@ -191,11 +176,6 @@ public class DecoderTest {
		}
		extractor.deinitExtractor();
		fileInput.close();
		} else {
		Log.w(TAG,
		"Warning: Test Skipped. Cannot find " + mInputFile + " in directory "
		+ mInputFilePath);
		}
		}

		@Test
		@@ -203,7 +183,6 @@ public class DecoderTest {
		File inputFile = new File(mInputFilePath + mInputFile);
		assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
		inputFile.exists());
		int status = -1;
		FileInputStream fileInput = new FileInputStream(inputFile);
		FileDescriptor fileDescriptor = fileInput.getFD();
		Extractor extractor = new Extractor();
		@@ -217,10 +196,10 @@ public class DecoderTest {
		for (String codecName : mediaCodecs) {
		Log.i("Test: %s\n", mInputFile);
		Native nativeDecoder = new Native();
		status = nativeDecoder.Decode(mInputFilePath, mInputFile, codecName, mAsyncMode);
		assertTrue(
		codecName + " decoder returned error " + status + " for file:" + mInputFile,
		status == 0);
		int status =
		nativeDecoder.Decode(mInputFilePath, mInputFile, codecName, mAsyncMode);
		assertEquals("Decoder returned error " + status + " for file: " + mInputFile, 0,
		status);
		}
		}
		fileInput.close();

media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/EncoderTest.java

+137 −165

Original line number	Diff line number	Diff line
		@@ -45,6 +45,7 @@ import java.util.Arrays;
		import java.util.Collection;

		import static org.junit.Assert.assertTrue;
		import static org.junit.Assert.assertEquals;

		@RunWith(Parameterized.class)
		public class EncoderTest {
		@@ -99,15 +100,13 @@ public class EncoderTest {
		int sampleRate = 0;
		int numChannels = 0;
		File inputFile = new File(mInputFilePath + mInputFile);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
		inputFile.exists());
		FileInputStream fileInput = new FileInputStream(inputFile);
		FileDescriptor fileDescriptor = fileInput.getFD();
		Extractor extractor = new Extractor();
		int trackCount = extractor.setUpExtractor(fileDescriptor);
		if (trackCount <= 0) {
		Log.e(TAG, "Extraction failed. No tracks for file: " + mInputFile);
		return;
		}
		assertTrue("Extraction failed. No tracks for file: " + mInputFile, (trackCount > 0));
		ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
		ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>();
		for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
		@@ -135,12 +134,8 @@ public class EncoderTest {
		Decoder decoder = new Decoder();
		decoder.setupDecoder(decodeOutputStream);
		status = decoder.decode(inputBuffer, frameInfo, false, format, "");
		if (status == 0) {
		Log.i(TAG, "Decoding complete.");
		} else {
		Log.e(TAG, "Decode returned error. Encoding did not take place." + status);
		return;
		}
		assertEquals("Decoder returned error " + status + " for file: " + mInputFile, 0,
		status);
		decoder.deInitCodec();
		extractor.unselectExtractorTrack(currentTrack);
		inputBuffer.clear();
		@@ -150,11 +145,8 @@ public class EncoderTest {
		}
		String mime = format.getString(MediaFormat.KEY_MIME);
		ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, true);
		if (mediaCodecs.size() <= 0) {
		Log.e(TAG, "No suitable codecs found for file: " + mInputFile + " track : " +
		currentTrack + " mime: " + mime);
		return;
		}
		assertTrue("No suitable codecs found for file: " + mInputFile + " track : " +
		currentTrack + " mime: " + mime, (mediaCodecs.size() > 0));
		Boolean[] encodeMode = {true, false};
		/* Encoding the decoder's output */
		for (Boolean asyncMode : encodeMode) {
		@@ -163,21 +155,15 @@ public class EncoderTest {
		if (WRITE_OUTPUT) {
		File outEncodeFile = new File(mOutputFilePath + "encoder.out");
		if (outEncodeFile.exists()) {
		if (!outEncodeFile.delete()) {
		Log.e(TAG, "Unable to delete existing file" +
		decodedFile.toString());
		}
		assertTrue(" Unable to delete existing file" + outEncodeFile.toString(),
		outEncodeFile.delete());
		}
		if (outEncodeFile.createNewFile()) {
		assertTrue("Unable to create file to write encoder output: " +
		outEncodeFile.toString(), outEncodeFile.createNewFile());
		encodeOutputStream = new FileOutputStream(outEncodeFile);
		} else {
		Log.e(TAG, "Unable to create file to write encoder output: " +
		outEncodeFile.toString());
		}
		}
		File rawFile =
		new File(mContext.getFilesDir() + "/decoder_" + tid + ".out");
		if (rawFile.exists()) {
		File rawFile = new File(mContext.getFilesDir() + "/decoder_" + tid + ".out");
		assertTrue("Cannot open file to write decoded output", rawFile.exists());
		if (DEBUG) {
		Log.i(TAG, "Path of decoded input file: " + rawFile.toString());
		}
		@@ -193,8 +179,7 @@ public class EncoderTest {
		if (format.containsKey(MediaFormat.KEY_BIT_RATE)) {
		bitRate = format.getInteger(MediaFormat.KEY_BIT_RATE);
		} else if (bitRate <= 0) {
		if (mime.contains("video/3gpp") \|\|
		mime.contains("video/mp4v-es")) {
		if (mime.contains("video/3gpp") \|\| mime.contains("video/mp4v-es")) {
		bitRate = ENCODE_MIN_BIT_RATE;
		} else {
		bitRate = ENCODE_DEFAULT_BIT_RATE;
		@@ -223,50 +208,40 @@ public class EncoderTest {
		encodeFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
		encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, frameSize);
		} else {
		encodeFormat = MediaFormat
		.createAudioFormat(mime, sampleRate, numChannels);
		encodeFormat = MediaFormat.createAudioFormat(mime, sampleRate, numChannels);
		encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
		frameSize = 4096;
		}
		Encoder encoder = new Encoder();
		encoder.setupEncoder(encodeOutputStream, eleStream);
		status = encoder.encode(codecName, encodeFormat, mime, frameRate,
		sampleRate, frameSize, asyncMode);
		status = encoder.encode(codecName, encodeFormat, mime, frameRate, sampleRate,
		frameSize, asyncMode);
		encoder.deInitEncoder();
		if (status == 0) {
		encoder.dumpStatistics(mInputFile + "with " + codecName + " for " +
		"aSyncMode = " + asyncMode, extractor.getClipDuration());
		Log.i(TAG, "Encoding complete for file: " + mInputFile +
		" with codec: " + codecName + " for aSyncMode = " +
		asyncMode);
		} else {
		Log.e(TAG,
		codecName + " encoder returned error " + status + " for " +
		"file:" + " " + mInputFile);
		}
		assertEquals(
		codecName + " encoder returned error " + status + " for " + "file:" +
		" " + mInputFile, 0, status);
		encoder.dumpStatistics(
		mInputFile + "with " + codecName + " for " + "aSyncMode = " + asyncMode,
		extractor.getClipDuration());
		Log.i(TAG, "Encoding complete for file: " + mInputFile + " with codec: " +
		codecName + " for aSyncMode = " + asyncMode);
		encoder.resetEncoder();
		eleStream.close();
		if (encodeOutputStream != null) {
		encodeOutputStream.close();
		}
		}

		}
		}
		//Cleanup temporary input file
		if (decodedFile.exists()) {
		if (decodedFile.delete()) {
		assertTrue(" Unable to delete decoded file" + decodedFile.toString(),
		decodedFile.delete());
		Log.i(TAG, "Successfully deleted decoded file");
		} else {
		Log.e(TAG, "Unable to delete decoded file");
		}
		}
		}
		extractor.deinitExtractor();
		fileInput.close();
		} else {
		Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFile + " in directory " +
		mInputFilePath);
		}
		}

		@Test
		@@ -274,7 +249,6 @@ public class EncoderTest {
		File inputFile = new File(mInputFilePath + mInputFile);
		assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
		inputFile.exists());
		int status = -1;
		int tid = android.os.Process.myTid();
		final String mDecodedFile = mContext.getFilesDir() + "/decoder_" + tid + ".out";
		FileInputStream fileInput = new FileInputStream(inputFile);
		@@ -290,20 +264,18 @@ public class EncoderTest {
		// Encoding the decoder's output
		for (String codecName : mediaCodecs) {
		Native nativeEncoder = new Native();
		status = nativeEncoder.Encode(mInputFilePath, mInputFile, mDecodedFile, codecName);
		assertTrue(
		codecName + " encoder returned error " + status + " for file:" + mInputFile,
		status == 0);
		int status =
		nativeEncoder.Encode(mInputFilePath, mInputFile, mDecodedFile, codecName);
		assertEquals(
		codecName + " encoder returned error " + status + " for " + "file:" + " " +
		mInputFile, 0, status);
		}
		}
		File decodedFile = new File(mDecodedFile);
		// Cleanup temporary input file
		if (decodedFile.exists()) {
		if (decodedFile.delete()) {
		assertTrue("Unable to delete - " + mDecodedFile, decodedFile.delete());
		Log.i(TAG, "Successfully deleted - " + mDecodedFile);
		} else {
		Log.e(TAG, "Unable to delete - " + mDecodedFile);
		}
		}
		fileInput.close();
		}

media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/ExtractorTest.java

+21 −32

Original line number	Diff line number	Diff line
		@@ -36,9 +36,8 @@ import java.io.IOException;
		import java.util.Arrays;
		import java.util.Collection;

		import static org.hamcrest.CoreMatchers.equalTo;
		import static org.hamcrest.CoreMatchers.is;
		import static org.junit.Assert.assertThat;
		import static org.junit.Assert.assertTrue;
		import static org.junit.Assert.assertEquals;

		@RunWith(Parameterized.class)
		public class ExtractorTest {
		@@ -74,41 +73,31 @@ public class ExtractorTest {

		@Test
		public void sampleExtractTest() throws IOException {
		int status = -1;
		File inputFile = new File(mInputFilePath + mInputFileName);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
		inputFile.exists());
		FileInputStream fileInput = new FileInputStream(inputFile);
		FileDescriptor fileDescriptor = fileInput.getFD();
		Extractor extractor = new Extractor();
		extractor.setUpExtractor(fileDescriptor);
		status = extractor.extractSample(mTrackId);
		int status = extractor.extractSample(mTrackId);
		assertEquals("Extraction failed for " + mInputFileName, 0, status);
		Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
		extractor.deinitExtractor();
		extractor.dumpStatistics(mInputFileName);
		fileInput.close();
		} else {
		Log.e(TAG, "Cannot find " + mInputFileName + " in directory " + mInputFilePath);
		}
		assertThat(status, is(equalTo(0)));
		}

		@Test
		public void sampleExtractNativeTest() throws IOException {
		Native nativeExtractor = new Native();
		int status = -1;
		File inputFile = new File(mInputFilePath + mInputFileName);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
		inputFile.exists());
		FileInputStream fileInput = new FileInputStream(inputFile);
		status = nativeExtractor.Extract(mInputFilePath, mInputFileName);
		int status = nativeExtractor.Extract(mInputFilePath, mInputFileName);
		fileInput.close();
		if (status != 0) {
		Log.e(TAG, "Extraction for " + mInputFileName + " failed.");
		} else {
		assertEquals("Extraction failed for " + mInputFileName, 0, status);
		Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
		}
		} else {
		Log.e(TAG, "Cannot find " + inputFile + " in directory " +
		mInputFilePath);
		}
		assertThat(status, is(equalTo(0)));
		}
		}

media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/MuxerTest.java

+56 −76

Original line number	Diff line number	Diff line
		@@ -43,9 +43,9 @@ import java.util.Collection;
		import java.util.Hashtable;
		import java.util.Map;

		import static org.hamcrest.CoreMatchers.equalTo;
		import static org.hamcrest.CoreMatchers.is;
		import static org.junit.Assert.assertThat;
		import static org.junit.Assert.assertTrue;
		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertNotEquals;

		@RunWith(Parameterized.class)
		public class MuxerTest {
		@@ -96,9 +96,9 @@ public class MuxerTest {

		@Test
		public void sampleMuxerTest() throws IOException {
		int status = -1;
		File inputFile = new File(mInputFilePath + mInputFileName);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
		inputFile.exists());
		FileInputStream fileInput = new FileInputStream(inputFile);
		FileDescriptor fileDescriptor = fileInput.getFD();
		ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
		@@ -124,61 +124,41 @@ public class MuxerTest {
		}
		MediaFormat format = extractor.getFormat(currentTrack);
		int outputFormat = mMapFormat.getOrDefault(mFormat, -1);
		if (outputFormat != -1) {
		assertNotEquals("Test failed for " + mInputFileName + ". Returned invalid " +
		"output format for given " + mFormat + " format.", -1, outputFormat);
		Muxer muxer = new Muxer();
		int trackIndex = muxer.setUpMuxer(mContext, outputFormat, format);
		status = muxer.mux(trackIndex, inputBuffer, inputBufferInfo);
		if (status != 0) {
		Log.e(TAG, "Cannot perform write operation for " + mInputFileName);
		}
		int status = muxer.mux(trackIndex, inputBuffer, inputBufferInfo);
		assertEquals("Cannot perform write operation for " + mInputFileName, 0, status);
		Log.i(TAG, "Muxed " + mInputFileName + " successfully.");
		muxer.deInitMuxer();
		muxer.dumpStatistics(mInputFileName, extractor.getClipDuration());
		muxer.resetMuxer();
		extractor.unselectExtractorTrack(currentTrack);
		inputBufferInfo.clear();
		inputBuffer.clear();
		} else {
		Log.e(TAG, "Test failed for " + mInputFileName + ". Returned invalid " +
		"output format for given " + mFormat + " format.");
		}

		}
		extractor.deinitExtractor();
		fileInput.close();
		} else {
		Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFileName + " in directory " +
		mInputFilePath);
		}
		assertThat(status, is(equalTo(0)));
		}

		@Test
		public void sampleMuxerNativeTest() {
		int status = -1;
		Native nativeMuxer = new Native();
		File inputFile = new File(mInputFilePath + mInputFileName);
		if (inputFile.exists()) {
		assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
		inputFile.exists());
		int tid = android.os.Process.myTid();
		String mMuxOutputFile = (mContext.getFilesDir() + "/mux_" + tid + ".out");
		status = nativeMuxer.Mux(mInputFilePath, mInputFileName, mMuxOutputFile,
		mFormat);
		if (status != 0) {
		Log.e(TAG, "Mux for " + mInputFileName + " failed.");
		} else {
		int status = nativeMuxer.Mux(mInputFilePath, mInputFileName, mMuxOutputFile, mFormat);
		assertEquals("Cannot perform write operation for " + mInputFileName, 0, status);
		Log.i(TAG, "Muxed " + mInputFileName + " successfully.");
		}
		File muxedFile = new File(mMuxOutputFile);
		// Cleanup temporary output file
		if (muxedFile.exists()) {
		if (muxedFile.delete()) {
		Log.i(TAG, "Successfully deleted" + mMuxOutputFile + " file.");
		} else {
		Log.e(TAG, "Unable to delete" + mMuxOutputFile + " file.");
		}
		}
		} else {
		Log.e(TAG, "Cannot find " + inputFile + " in directory " +
		mInputFilePath);
		assertTrue("Unable to delete" + mMuxOutputFile + " file.",
		muxedFile.delete());
		}
		assertThat(status, is(equalTo(0)));
		}
		}