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 
am: 250a6b5f11

Change-Id: I11480ee98c12637f2d04f19552b02368ed6a7964
gugelfrei
Ray Essick 5 years ago committed by android-build-merger
parent c34dc6e2cd 250a6b5f11
commit 0706451134
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 static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class DecoderTest {
@ -107,95 +108,74 @@ public class DecoderTest {
@Test(timeout = PER_TEST_TIMEOUT_MS)
public void testDecoder() throws IOException {
File inputFile = new File(mInputFilePath + mInputFile);
if (inputFile.exists()) {
FileInputStream fileInput = new FileInputStream(inputFile);
FileDescriptor fileDescriptor = fileInput.getFD();
Extractor extractor = new Extractor();
int trackCount = extractor.setUpExtractor(fileDescriptor);
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("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<>();
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);
assertTrue("No suitable codecs found for file: " + mInputFile + " track : " +
currentTrack + " mime: " + mime, (mediaCodecs.size() > 0));
// 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);
}
// 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);
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);
} while (sampleSize > 0);
for (String codecName : mediaCodecs) {
FileOutputStream decodeOutputStream = null;
if (WRITE_OUTPUT) {
if (!Paths.get(mOutputFilePath).toFile().exists()) {
Files.createDirectories(Paths.get(mOutputFilePath));
}
decoder.resetDecoder();
if (decodeOutputStream != null) {
decodeOutputStream.close();
File outFile = new File(mOutputFilePath + "decoder.out");
if (outFile.exists()) {
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();
fileInput.close();
} else {
Log.w(TAG,
"Warning: Test Skipped. Cannot find " + mInputFile + " in directory "
+ mInputFilePath);
extractor.unselectExtractorTrack(currentTrack);
inputBuffer.clear();
frameInfo.clear();
}
extractor.deinitExtractor();
fileInput.close();
}
@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();

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 static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class EncoderTest {
@ -99,174 +100,148 @@ public class EncoderTest {
int sampleRate = 0;
int numChannels = 0;
File inputFile = new File(mInputFilePath + mInputFile);
if (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("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<>();
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<>();
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);
String mime = format.getString(MediaFormat.KEY_MIME);
ArrayList<String> mediaCodecs = CodecUtils.selectCodecs(mime, true);
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) {
for (String codecName : mediaCodecs) {
FileOutputStream encodeOutputStream = null;
if (WRITE_OUTPUT) {
File outEncodeFile = new File(mOutputFilePath + "encoder.out");
if (outEncodeFile.exists()) {
assertTrue(" Unable to delete existing file" + outEncodeFile.toString(),
outEncodeFile.delete());
}
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) {
Log.d(TAG, "Extracted bufInfo: flag = " + bufInfo.flags + " timestamp = " +
bufInfo.presentationTimeUs + " size = " + bufInfo.size);
Log.i(TAG, "Path of decoded input file: " + rawFile.toString());
}
} 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, "");
if (status == 0) {
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());
}
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;
}
File rawFile =
new File(mContext.getFilesDir() + "/decoder_" + tid + ".out");
if (rawFile.exists()) {
if (DEBUG) {
Log.i(TAG, "Path of decoded input file: " + rawFile.toString());
}
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);
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 {
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();
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();
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;
}
}
//Cleanup temporary input file
if (decodedFile.exists()) {
if (decodedFile.delete()) {
Log.i(TAG, "Successfully deleted decoded file");
/*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 {
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();
fileInput.close();
} else {
Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFile + " in directory " +
mInputFilePath);
//Cleanup temporary input file
if (decodedFile.exists()) {
assertTrue(" Unable to delete decoded file" + decodedFile.toString(),
decodedFile.delete());
Log.i(TAG, "Successfully deleted decoded file");
}
}
extractor.deinitExtractor();
fileInput.close();
}
@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()) {
Log.i(TAG, "Successfully deleted - " + mDecodedFile);
} else {
Log.e(TAG, "Unable to delete - " + mDecodedFile);
}
assertTrue("Unable to delete - " + mDecodedFile, decodedFile.delete());
Log.i(TAG, "Successfully deleted - " + mDecodedFile);
}
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.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()) {
FileInputStream fileInput = new FileInputStream(inputFile);
FileDescriptor fileDescriptor = fileInput.getFD();
Extractor extractor = new Extractor();
extractor.setUpExtractor(fileDescriptor);
status = extractor.extractSample(mTrackId);
extractor.deinitExtractor();
extractor.dumpStatistics(mInputFileName);
fileInput.close();
} else {
Log.e(TAG, "Cannot find " + mInputFileName + " in directory " + mInputFilePath);
}
assertThat(status, is(equalTo(0)));
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);
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();
}
@Test
public void sampleExtractNativeTest() throws IOException {
Native nativeExtractor = new Native();
int status = -1;
File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) {
FileInputStream fileInput = new FileInputStream(inputFile);
status = nativeExtractor.Extract(mInputFilePath, mInputFileName);
fileInput.close();
if (status != 0) {
Log.e(TAG, "Extraction for " + mInputFileName + " failed.");
} else {
Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
}
} else {
Log.e(TAG, "Cannot find " + inputFile + " in directory " +
mInputFilePath);
}
assertThat(status, is(equalTo(0)));
assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
inputFile.exists());
FileInputStream fileInput = new FileInputStream(inputFile);
int status = nativeExtractor.Extract(mInputFilePath, mInputFileName);
fileInput.close();
assertEquals("Extraction failed for " + mInputFileName, 0, status);
Log.i(TAG, "Extracted " + mInputFileName + " successfully.");
}
}

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.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,89 +96,69 @@ public class MuxerTest {
@Test
public void sampleMuxerTest() throws IOException {
int status = -1;
File inputFile = new File(mInputFilePath + mInputFileName);
if (inputFile.exists()) {
FileInputStream fileInput = new FileInputStream(inputFile);
FileDescriptor fileDescriptor = fileInput.getFD();
ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
ArrayList<MediaCodec.BufferInfo> inputBufferInfo = new ArrayList<>();
Extractor extractor = new Extractor();
int trackCount = extractor.setUpExtractor(fileDescriptor);
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
extractor.selectExtractorTrack(currentTrack);
while (true) {
int sampleSize = extractor.getFrameSample();
MediaCodec.BufferInfo bufferInfo = extractor.getBufferInfo();
MediaCodec.BufferInfo tempBufferInfo = new MediaCodec.BufferInfo();
tempBufferInfo
.set(bufferInfo.offset, bufferInfo.size, bufferInfo.presentationTimeUs,
bufferInfo.flags);
inputBufferInfo.add(tempBufferInfo);
ByteBuffer tempSampleBuffer = ByteBuffer.allocate(tempBufferInfo.size);
tempSampleBuffer.put(extractor.getFrameBuffer().array(), 0, bufferInfo.size);
inputBuffer.add(tempSampleBuffer);
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.");
assertTrue("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
inputFile.exists());
FileInputStream fileInput = new FileInputStream(inputFile);
FileDescriptor fileDescriptor = fileInput.getFD();
ArrayList<ByteBuffer> inputBuffer = new ArrayList<>();
ArrayList<MediaCodec.BufferInfo> inputBufferInfo = new ArrayList<>();
Extractor extractor = new Extractor();
int trackCount = extractor.setUpExtractor(fileDescriptor);
for (int currentTrack = 0; currentTrack < trackCount; currentTrack++) {
extractor.selectExtractorTrack(currentTrack);
while (true) {
int sampleSize = extractor.getFrameSample();
MediaCodec.BufferInfo bufferInfo = extractor.getBufferInfo();
MediaCodec.BufferInfo tempBufferInfo = new MediaCodec.BufferInfo();
tempBufferInfo
.set(bufferInfo.offset, bufferInfo.size, bufferInfo.presentationTimeUs,
bufferInfo.flags);
inputBufferInfo.add(tempBufferInfo);
ByteBuffer tempSampleBuffer = ByteBuffer.allocate(tempBufferInfo.size);
tempSampleBuffer.put(extractor.getFrameBuffer().array(), 0, bufferInfo.size);
inputBuffer.add(tempSampleBuffer);
if (sampleSize < 0) {
break;
}
}
extractor.deinitExtractor();
fileInput.close();
} else {
Log.w(TAG, "Warning: Test Skipped. Cannot find " + mInputFileName + " in directory " +
mInputFilePath);
MediaFormat format = extractor.getFormat(currentTrack);
int outputFormat = mMapFormat.getOrDefault(mFormat, -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);
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
public void sampleMuxerNativeTest() {
int status = -1;
Native nativeMuxer = new Native();
File inputFile = new File(mInputFilePath + mInputFileName);
if (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 {
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("Cannot find " + mInputFileName + " in directory " + mInputFilePath,
inputFile.exists());
int tid = android.os.Process.myTid();
String mMuxOutputFile = (mContext.getFilesDir() + "/mux_" + tid + ".out");
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()) {
assertTrue("Unable to delete" + mMuxOutputFile + " file.",
muxedFile.delete());
}
assertThat(status, is(equalTo(0)));
}
}

Write Preview
Loading…
Cancel
Save