gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Benchmark: add asserts for common failures in sdk tests"

Browse Source
gugelfrei
Ray Essick 5 years ago committed by Gerrit Code Review
parent f87ae40621 2a4adb5407
commit 250a6b5f11
4 changed files with 281 additions and 361 deletions
Show Stats Download Patch File Download Diff File

155
media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/DecoderTest.java
Unescape View File

@ -46,6 +46,7 @@ import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class) @RunWith(Parameterized.class)
public class DecoderTest { public class DecoderTest {
@ -107,95 +108,74 @@ public class DecoderTest {
@Test(timeout = PER_TEST_TIMEOUT_MS) @Test(timeout = PER_TEST_TIMEOUT_MS)
public void testDecoder() throws IOException { public void testDecoder() throws IOException {
File inputFile = new File(mInputFilePath + mInputFile); File inputFile = new File(mInputFilePath + mInputFile);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
FileInputStream fileInput = new FileInputStream(inputFile); inputFile.exists());
FileDescriptor fileDescriptor = fileInput.getFD(); FileInputStream fileInput = new FileInputStream(inputFile);
Extractor extractor = new Extractor(); FileDescriptor fileDescriptor = fileInput.getFD();
int trackCount = extractor.setUpExtractor(fileDescriptor); Extractor extractor = new Extractor();
ArrayList<ByteBuffer> inputBuffer = new ArrayList<>(); int trackCount = extractor.setUpExtractor(fileDescriptor);
ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>(); assertTrue("Extraction failed. No tracks for file: " + mInputFile, (trackCount > 0));
if (trackCount <= 0) { ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
Log.e(TAG, "Extraction failed. No tracks for file: " + mInputFile); ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>();
return; for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
} extractor.selectExtractorTrack(currentTrack);
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) { MediaFormat format = extractor.getFormat(currentTrack);
extractor.selectExtractorTrack(currentTrack); String mime = format.getString(MediaFormat.KEY_MIME);
MediaFormat format = extractor.getFormat(currentTrack); ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, false);
String mime = format.getString(MediaFormat.KEY_MIME); assertTrue("No suitable codecs found for file: " + mInputFile + " track : " +
ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, false); currentTrack + " mime: " + mime, (mediaCodecs.size() > 0));
if (mediaCodecs.size() <= 0) {
Log.e(TAG, // Get samples from extractor
"No suitable codecs found for file: " + mInputFile int sampleSize;
+ " track : " + currentTrack + " mime: " + mime); do {
continue; sampleSize = extractor.getFrameSample();
MediaCodec.BufferInfo bufInfo = new MediaCodec.BufferInfo();
MediaCodec.BufferInfo info = extractor.getBufferInfo();
ByteBuffer dataBuffer = ByteBuffer.allocate(info.size);
dataBuffer.put(extractor.getFrameBuffer().array(), 0, info.size);
bufInfo.set(info.offset, info.size, info.presentationTimeUs, info.flags);
inputBuffer.add(dataBuffer);
frameInfo.add(bufInfo);
if (DEBUG) {
Log.d(TAG, "Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = " +
bufInfo.presentationTimeUs + " size = " + bufInfo.size);
} }
// Get samples from extractor } while (sampleSize > 0);
int sampleSize; for (String codecName : mediaCodecs) {
do { FileOutputStream decodeOutputStream = null;
sampleSize = extractor.getFrameSample(); if (WRITE_OUTPUT) {
MediaCodec.BufferInfo bufInfo = new MediaCodec.BufferInfo(); if (!Paths.get(mOutputFilePath).toFile().exists()) {
MediaCodec.BufferInfo info = extractor.getBufferInfo(); Files.createDirectories(Paths.get(mOutputFilePath));
ByteBuffer dataBuffer = ByteBuffer.allocate(info.size);
dataBuffer.put(extractor.getFrameBuffer().array(), 0, info.size);
bufInfo.set(info.offset, info.size, info.presentationTimeUs, info.flags);
inputBuffer.add(dataBuffer);
frameInfo.add(bufInfo);
if (DEBUG) {
Log.d(TAG,
"Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = "
+ bufInfo.presentationTimeUs + " size = " + bufInfo.size);
}
} while (sampleSize > 0);
for (String codecName : mediaCodecs) {
FileOutputStream decodeOutputStream = null;
if (WRITE_OUTPUT) {
if (!Paths.get(mOutputFilePath).toFile().exists()) {
Files.createDirectories(Paths.get(mOutputFilePath));
}
File outFile = new File(mOutputFilePath + "decoder.out");
if (outFile.exists()) {
if (!outFile.delete()) {
Log.e(TAG, " Unable to delete existing file" + outFile.toString());
}
}
if (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);
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);
} }
decoder.resetDecoder(); File outFile = new File(mOutputFilePath + "decoder.out");
if (decodeOutputStream != null) { if (outFile.exists()) {
decodeOutputStream.close(); assertTrue(" Unable to delete existing file" + outFile.toString(),
outFile.delete());
} }
assertTrue("Unable to create file: " + outFile.toString(),
outFile.createNewFile());
decodeOutputStream = new FileOutputStream(outFile);
}
Decoder decoder = new Decoder();
decoder.setupDecoder(decodeOutputStream);
int status = decoder.decode(inputBuffer, frameInfo, mAsyncMode, format, codecName);
decoder.deInitCodec();
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();
} }
extractor.unselectExtractorTrack(currentTrack);
inputBuffer.clear();
frameInfo.clear();
} }
extractor.deinitExtractor(); extractor.unselectExtractorTrack(currentTrack);
fileInput.close(); inputBuffer.clear();
} else { frameInfo.clear();
Log.w(TAG,
"Warning: Test Skipped. Cannot find " + mInputFile + " in directory "
+ mInputFilePath);
} }
extractor.deinitExtractor();
fileInput.close();
} }
@Test @Test
@ -203,7 +183,6 @@ public class DecoderTest {
File inputFile = new File(mInputFilePath + mInputFile); File inputFile = new File(mInputFilePath + mInputFile);
assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath, assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
inputFile.exists()); inputFile.exists());
int status = -1;
FileInputStream fileInput = new FileInputStream(inputFile); FileInputStream fileInput = new FileInputStream(inputFile);
FileDescriptor fileDescriptor = fileInput.getFD(); FileDescriptor fileDescriptor = fileInput.getFD();
Extractor extractor = new Extractor(); Extractor extractor = new Extractor();
@ -217,10 +196,10 @@ public class DecoderTest {
for (String codecName : mediaCodecs) { for (String codecName : mediaCodecs) {
Log.i("Test: %s\n", mInputFile); Log.i("Test: %s\n", mInputFile);
Native nativeDecoder = new Native(); Native nativeDecoder = new Native();
status = nativeDecoder.Decode(mInputFilePath, mInputFile, codecName, mAsyncMode); int status =
assertTrue( nativeDecoder.Decode(mInputFilePath, mInputFile, codecName, mAsyncMode);
codecName + " decoder returned error " + status + " for file:" + mInputFile, assertEquals("Decoder returned error " + status + " for file: " + mInputFile, 0,
status == 0); status);
} }
} }
fileInput.close(); fileInput.close();

302
media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/EncoderTest.java
Unescape View File

@ -45,6 +45,7 @@ import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class) @RunWith(Parameterized.class)
public class EncoderTest { public class EncoderTest {
@ -99,174 +100,148 @@ public class EncoderTest {
int sampleRate = 0; int sampleRate = 0;
int numChannels = 0; int numChannels = 0;
File inputFile = new File(mInputFilePath + mInputFile); File inputFile = new File(mInputFilePath + mInputFile);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
FileInputStream fileInput = new FileInputStream(inputFile); inputFile.exists());
FileDescriptor fileDescriptor = fileInput.getFD(); FileInputStream fileInput = new FileInputStream(inputFile);
Extractor extractor = new Extractor(); FileDescriptor fileDescriptor = fileInput.getFD();
int trackCount = extractor.setUpExtractor(fileDescriptor); Extractor extractor = new Extractor();
if (trackCount <= 0) { int trackCount = extractor.setUpExtractor(fileDescriptor);
Log.e(TAG, "Extraction failed. No tracks for file: " + mInputFile); assertTrue("Extraction failed. No tracks for file: " + mInputFile, (trackCount > 0));
return; ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>();
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
extractor.selectExtractorTrack(currentTrack);
MediaFormat format = extractor.getFormat(currentTrack);
// Get samples from extractor
int sampleSize;
do {
sampleSize = extractor.getFrameSample();
MediaCodec.BufferInfo bufInfo = new MediaCodec.BufferInfo();
MediaCodec.BufferInfo info = extractor.getBufferInfo();
ByteBuffer dataBuffer = ByteBuffer.allocate(info.size);
dataBuffer.put(extractor.getFrameBuffer().array(), 0, info.size);
bufInfo.set(info.offset, info.size, info.presentationTimeUs, info.flags);
inputBuffer.add(dataBuffer);
frameInfo.add(bufInfo);
if (DEBUG) {
Log.d(TAG, "Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = " +
bufInfo.presentationTimeUs + " size = " + bufInfo.size);
}
} while (sampleSize > 0);
int tid = android.os.Process.myTid();
File decodedFile = new File(mContext.getFilesDir() + "/decoder_" + tid + ".out");
FileOutputStream decodeOutputStream = new FileOutputStream(decodedFile);
Decoder decoder = new Decoder();
decoder.setupDecoder(decodeOutputStream);
status = decoder.decode(inputBuffer, frameInfo, false, format, "");
assertEquals("Decoder returned error " + status + " for file: " + mInputFile, 0,
status);
decoder.deInitCodec();
extractor.unselectExtractorTrack(currentTrack);
inputBuffer.clear();
frameInfo.clear();
if (decodeOutputStream != null) {
decodeOutputStream.close();
} }
ArrayList<ByteBuffer> inputBuffer = new ArrayList<>(); String mime = format.getString(MediaFormat.KEY_MIME);
ArrayList<MediaCodec.BufferInfo> frameInfo = new ArrayList<>(); ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, true);
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) { assertTrue("No suitable codecs found for file: " + mInputFile + " track : " +
extractor.selectExtractorTrack(currentTrack); currentTrack + " mime: " + mime, (mediaCodecs.size() > 0));
MediaFormat format = extractor.getFormat(currentTrack); Boolean[] encodeMode = {true, false};
// Get samples from extractor /* Encoding the decoder's output */
int sampleSize; for (Boolean asyncMode : encodeMode) {
do { for (String codecName : mediaCodecs) {
sampleSize = extractor.getFrameSample(); FileOutputStream encodeOutputStream = null;
MediaCodec.BufferInfo bufInfo = new MediaCodec.BufferInfo(); if (WRITE_OUTPUT) {
MediaCodec.BufferInfo info = extractor.getBufferInfo(); File outEncodeFile = new File(mOutputFilePath + "encoder.out");
ByteBuffer dataBuffer = ByteBuffer.allocate(info.size); if (outEncodeFile.exists()) {
dataBuffer.put(extractor.getFrameBuffer().array(), 0, info.size); assertTrue(" Unable to delete existing file" + outEncodeFile.toString(),
bufInfo.set(info.offset, info.size, info.presentationTimeUs, info.flags); outEncodeFile.delete());
inputBuffer.add(dataBuffer); }
frameInfo.add(bufInfo); assertTrue("Unable to create file to write encoder output: " +
outEncodeFile.toString(), outEncodeFile.createNewFile());
encodeOutputStream = new FileOutputStream(outEncodeFile);
}
File rawFile = new File(mContext.getFilesDir() + "/decoder_" + tid + ".out");
assertTrue("Cannot open file to write decoded output", rawFile.exists());
if (DEBUG) { if (DEBUG) {
Log.d(TAG, "Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = " + Log.i(TAG, "Path of decoded input file: " + rawFile.toString());
bufInfo.presentationTimeUs + " size = " + bufInfo.size);
} }
} while (sampleSize > 0); FileInputStream eleStream = new FileInputStream(rawFile);
int tid = android.os.Process.myTid(); if (mime.startsWith("video/")) {
File decodedFile = new File(mContext.getFilesDir() + "/decoder_" + tid + ".out"); width = format.getInteger(MediaFormat.KEY_WIDTH);
FileOutputStream decodeOutputStream = new FileOutputStream(decodedFile); height = format.getInteger(MediaFormat.KEY_HEIGHT);
Decoder decoder = new Decoder(); if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
decoder.setupDecoder(decodeOutputStream); frameRate = format.getInteger(MediaFormat.KEY_FRAME_RATE);
status = decoder.decode(inputBuffer, frameInfo, false, format, ""); } else if (frameRate <= 0) {
if (status == 0) { frameRate = ENCODE_DEFAULT_FRAME_RATE;
Log.i(TAG, "Decoding complete.");
} else {
Log.e(TAG, "Decode returned error. Encoding did not take place." + status);
return;
}
decoder.deInitCodec();
extractor.unselectExtractorTrack(currentTrack);
inputBuffer.clear();
frameInfo.clear();
if (decodeOutputStream != null) {
decodeOutputStream.close();
}
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;
}
Boolean[] encodeMode = {true, false};
/* Encoding the decoder's output */
for (Boolean asyncMode : encodeMode) {
for (String codecName : mediaCodecs) {
FileOutputStream encodeOutputStream = null;
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());
}
}
if (outEncodeFile.createNewFile()) {
encodeOutputStream = new FileOutputStream(outEncodeFile);
} else {
Log.e(TAG, "Unable to create file to write encoder output: " +
outEncodeFile.toString());
}
} }
File rawFile = if (format.containsKey(MediaFormat.KEY_BIT_RATE)) {
new File(mContext.getFilesDir() + "/decoder_" + tid + ".out"); bitRate = format.getInteger(MediaFormat.KEY_BIT_RATE);
if (rawFile.exists()) { } else if (bitRate <= 0) {
if (DEBUG) { if (mime.contains("video/3gpp") || mime.contains("video/mp4v-es")) {
Log.i(TAG, "Path of decoded input file: " + rawFile.toString()); bitRate = ENCODE_MIN_BIT_RATE;
}
FileInputStream eleStream = new FileInputStream(rawFile);
if (mime.startsWith("video/")) {
width = format.getInteger(MediaFormat.KEY_WIDTH);
height = format.getInteger(MediaFormat.KEY_HEIGHT);
if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
frameRate = format.getInteger(MediaFormat.KEY_FRAME_RATE);
} else if (frameRate <= 0) {
frameRate = ENCODE_DEFAULT_FRAME_RATE;
}
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")) {
bitRate = ENCODE_MIN_BIT_RATE;
} else {
bitRate = ENCODE_DEFAULT_BIT_RATE;
}
}
if (format.containsKey(MediaFormat.KEY_PROFILE)) {
profile = format.getInteger(MediaFormat.KEY_PROFILE);
}
if (format.containsKey(MediaFormat.KEY_PROFILE)) {
level = format.getInteger(MediaFormat.KEY_LEVEL);
}
} else {
sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE);
numChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
bitRate = sampleRate * numChannels * 16;
}
/*Setup Encode Format*/
MediaFormat encodeFormat;
if (mime.startsWith("video/")) {
frameSize = width * height * 3 / 2;
encodeFormat = MediaFormat.createVideoFormat(mime, width, height);
encodeFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
encodeFormat.setInteger(MediaFormat.KEY_PROFILE, profile);
encodeFormat.setInteger(MediaFormat.KEY_LEVEL, level);
encodeFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, frameSize);
} else { } else {
encodeFormat = MediaFormat bitRate = ENCODE_DEFAULT_BIT_RATE;
.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);
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);
}
encoder.resetEncoder();
eleStream.close();
if (encodeOutputStream != null) {
encodeOutputStream.close();
} }
} }
if (format.containsKey(MediaFormat.KEY_PROFILE)) {
profile = format.getInteger(MediaFormat.KEY_PROFILE);
}
if (format.containsKey(MediaFormat.KEY_PROFILE)) {
level = format.getInteger(MediaFormat.KEY_LEVEL);
}
} else {
sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE);
numChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT);
bitRate = sampleRate * numChannels * 16;
} }
} /*Setup Encode Format*/
//Cleanup temporary input file MediaFormat encodeFormat;
if (decodedFile.exists()) { if (mime.startsWith("video/")) {
if (decodedFile.delete()) { frameSize = width * height * 3 / 2;
Log.i(TAG, "Successfully deleted decoded file"); encodeFormat = MediaFormat.createVideoFormat(mime, width, height);
encodeFormat.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
encodeFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
encodeFormat.setInteger(MediaFormat.KEY_PROFILE, profile);
encodeFormat.setInteger(MediaFormat.KEY_LEVEL, level);
encodeFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
encodeFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, frameSize);
} else { } else {
Log.e(TAG, "Unable to delete decoded file"); 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);
encoder.deInitEncoder();
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();
} }
} }
} }
extractor.deinitExtractor(); //Cleanup temporary input file
fileInput.close(); if (decodedFile.exists()) {
} else { assertTrue(" Unable to delete decoded file" + decodedFile.toString(),
Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFile + " in directory " + decodedFile.delete());
mInputFilePath); Log.i(TAG, "Successfully deleted decoded file");
}
} }
extractor.deinitExtractor();
fileInput.close();
} }
@Test @Test
@ -274,7 +249,6 @@ public class EncoderTest {
File inputFile = new File(mInputFilePath + mInputFile); File inputFile = new File(mInputFilePath + mInputFile);
assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath, assertTrue("Cannot find " + mInputFile + " in directory " + mInputFilePath,
inputFile.exists()); inputFile.exists());
int status = -1;
int tid = android.os.Process.myTid(); int tid = android.os.Process.myTid();
final String mDecodedFile = mContext.getFilesDir() + "/decoder_" + tid + ".out"; final String mDecodedFile = mContext.getFilesDir() + "/decoder_" + tid + ".out";
FileInputStream fileInput = new FileInputStream(inputFile); FileInputStream fileInput = new FileInputStream(inputFile);
@ -290,20 +264,18 @@ public class EncoderTest {
// Encoding the decoder's output // Encoding the decoder's output
for (String codecName : mediaCodecs) { for (String codecName : mediaCodecs) {
Native nativeEncoder = new Native(); Native nativeEncoder = new Native();
status = nativeEncoder.Encode(mInputFilePath, mInputFile, mDecodedFile, codecName); int status =
assertTrue( nativeEncoder.Encode(mInputFilePath, mInputFile, mDecodedFile, codecName);
codecName + " encoder returned error " + status + " for file:" + mInputFile, assertEquals(
status == 0); codecName + " encoder returned error " + status + " for " + "file:" + " " +
mInputFile, 0, status);
} }
} }
File decodedFile = new File(mDecodedFile); File decodedFile = new File(mDecodedFile);
// Cleanup temporary input file // Cleanup temporary input file
if (decodedFile.exists()) { if (decodedFile.exists()) {
if (decodedFile.delete()) { assertTrue("Unable to delete - " + mDecodedFile, decodedFile.delete());
Log.i(TAG, "Successfully deleted - " + mDecodedFile); Log.i(TAG, "Successfully deleted - " + mDecodedFile);
} else {
Log.e(TAG, "Unable to delete - " + mDecodedFile);
}
} }
fileInput.close(); fileInput.close();
} }

53
media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/ExtractorTest.java
Unescape View File

@ -36,9 +36,8 @@ import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import java.util.Collection; import java.util.Collection;
import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.Assert.assertTrue;
import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
@RunWith(Parameterized.class) @RunWith(Parameterized.class)
public class ExtractorTest { public class ExtractorTest {
@ -74,41 +73,31 @@ public class ExtractorTest {
@Test @Test
public void sampleExtractTest() throws IOException { public void sampleExtractTest() throws IOException {
int status = -1;
File inputFile = new File(mInputFilePath + mInputFileName); File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
FileInputStream fileInput = new FileInputStream(inputFile); inputFile.exists());
FileDescriptor fileDescriptor = fileInput.getFD(); FileInputStream fileInput = new FileInputStream(inputFile);
Extractor extractor = new Extractor(); FileDescriptor fileDescriptor = fileInput.getFD();
extractor.setUpExtractor(fileDescriptor); Extractor extractor = new Extractor();
status = extractor.extractSample(mTrackId); extractor.setUpExtractor(fileDescriptor);
extractor.deinitExtractor(); int status = extractor.extractSample(mTrackId);
extractor.dumpStatistics(mInputFileName); assertEquals("Extraction failed for " + mInputFileName, 0, status);
fileInput.close(); Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
} else { extractor.deinitExtractor();
Log.e(TAG, "Cannot find " + mInputFileName + " in directory " + mInputFilePath); extractor.dumpStatistics(mInputFileName);
} fileInput.close();
assertThat(status, is(equalTo(0)));
} }
@Test @Test
public void sampleExtractNativeTest() throws IOException { public void sampleExtractNativeTest() throws IOException {
Native nativeExtractor = new Native(); Native nativeExtractor = new Native();
int status = -1;
File inputFile = new File(mInputFilePath + mInputFileName); File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
FileInputStream fileInput = new FileInputStream(inputFile); inputFile.exists());
status = nativeExtractor.Extract(mInputFilePath, mInputFileName); FileInputStream fileInput = new FileInputStream(inputFile);
fileInput.close(); int status = nativeExtractor.Extract(mInputFilePath, mInputFileName);
if (status != 0) { fileInput.close();
Log.e(TAG, "Extraction for " + mInputFileName + " failed."); assertEquals("Extraction failed for " + mInputFileName, 0, status);
} else { Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
}
} else {
Log.e(TAG, "Cannot find " + inputFile + " in directory " +
mInputFilePath);
}
assertThat(status, is(equalTo(0)));
} }
} }

132
media/tests/benchmark/MediaBenchmarkTest/src/androidTest/java/com/android/media/benchmark/tests/MuxerTest.java
Unescape View File

@ -43,9 +43,9 @@ import java.util.Collection;
import java.util.Hashtable; import java.util.Hashtable;
import java.util.Map; import java.util.Map;
import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.Assert.assertTrue;
import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertNotEquals;
@RunWith(Parameterized.class) @RunWith(Parameterized.class)
public class MuxerTest { public class MuxerTest {
@ -96,89 +96,69 @@ public class MuxerTest {
@Test @Test
public void sampleMuxerTest() throws IOException { public void sampleMuxerTest() throws IOException {
int status = -1;
File inputFile = new File(mInputFilePath + mInputFileName); File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
FileInputStream fileInput = new FileInputStream(inputFile); inputFile.exists());
FileDescriptor fileDescriptor = fileInput.getFD(); FileInputStream fileInput = new FileInputStream(inputFile);
ArrayList<ByteBuffer> inputBuffer = new ArrayList<>(); FileDescriptor fileDescriptor = fileInput.getFD();
ArrayList<MediaCodec.BufferInfo> inputBufferInfo = new ArrayList<>(); ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
Extractor extractor = new Extractor(); ArrayList<MediaCodec.BufferInfo> inputBufferInfo = new ArrayList<>();
int trackCount = extractor.setUpExtractor(fileDescriptor); Extractor extractor = new Extractor();
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) { int trackCount = extractor.setUpExtractor(fileDescriptor);
extractor.selectExtractorTrack(currentTrack); for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
while (true) { extractor.selectExtractorTrack(currentTrack);
int sampleSize = extractor.getFrameSample(); while (true) {
MediaCodec.BufferInfo bufferInfo = extractor.getBufferInfo(); int sampleSize = extractor.getFrameSample();
MediaCodec.BufferInfo tempBufferInfo = new MediaCodec.BufferInfo(); MediaCodec.BufferInfo bufferInfo = extractor.getBufferInfo();
tempBufferInfo MediaCodec.BufferInfo tempBufferInfo = new MediaCodec.BufferInfo();
.set(bufferInfo.offset, bufferInfo.size, bufferInfo.presentationTimeUs, tempBufferInfo
bufferInfo.flags); .set(bufferInfo.offset, bufferInfo.size, bufferInfo.presentationTimeUs,
inputBufferInfo.add(tempBufferInfo); bufferInfo.flags);
ByteBuffer tempSampleBuffer = ByteBuffer.allocate(tempBufferInfo.size); inputBufferInfo.add(tempBufferInfo);
tempSampleBuffer.put(extractor.getFrameBuffer().array(), 0, bufferInfo.size); ByteBuffer tempSampleBuffer = ByteBuffer.allocate(tempBufferInfo.size);
inputBuffer.add(tempSampleBuffer); tempSampleBuffer.put(extractor.getFrameBuffer().array(), 0, bufferInfo.size);
if (sampleSize < 0) { inputBuffer.add(tempSampleBuffer);
break; if (sampleSize < 0) {
} break;
}
MediaFormat format = extractor.getFormat(currentTrack);
int outputFormat = mMapFormat.getOrDefault(mFormat, -1);
if (outputFormat != -1) {
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);
}
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(); MediaFormat format = extractor.getFormat(currentTrack);
fileInput.close(); int outputFormat = mMapFormat.getOrDefault(mFormat, -1);
} else { assertNotEquals("Test failed for " + mInputFileName + ". Returned invalid " +
Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFileName + " in directory " + "output format for given " + mFormat + " format.", -1, outputFormat);
mInputFilePath); Muxer muxer = new Muxer();
int trackIndex = muxer.setUpMuxer(mContext, outputFormat, format);
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();
} }
assertThat(status, is(equalTo(0))); extractor.deinitExtractor();
fileInput.close();
} }
@Test @Test
public void sampleMuxerNativeTest() { public void sampleMuxerNativeTest() {
int status = -1;
Native nativeMuxer = new Native(); Native nativeMuxer = new Native();
File inputFile = new File(mInputFilePath + mInputFileName); File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) { assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
int tid = android.os.Process.myTid(); inputFile.exists());
String mMuxOutputFile = (mContext.getFilesDir() + "/mux_" + tid + ".out"); int tid = android.os.Process.myTid();
status = nativeMuxer.Mux(mInputFilePath, mInputFileName, mMuxOutputFile, String mMuxOutputFile = (mContext.getFilesDir() + "/mux_" + tid + ".out");
mFormat); int status = nativeMuxer.Mux(mInputFilePath, mInputFileName, mMuxOutputFile, mFormat);
if (status != 0) { assertEquals("Cannot perform write operation for " + mInputFileName, 0, status);
Log.e(TAG, "Mux for " + mInputFileName + " failed."); Log.i(TAG, "Muxed " + mInputFileName + " successfully.");
} else { File muxedFile = new File(mMuxOutputFile);
Log.i(TAG, "Muxed " + mInputFileName + " successfully."); // Cleanup temporary output file
} if (muxedFile.exists()) {
File muxedFile = new File(mMuxOutputFile); assertTrue("Unable to delete" + mMuxOutputFile + " file.",
// Cleanup temporary output file muxedFile.delete());
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);
} }
assertThat(status, is(equalTo(0)));
} }
} }

Write Preview
Loading…
Cancel
Save