testReleaseAfterFlush: extend to audio encoders
Also skip test on unsupported codecs.
Bug: 24345187
Change-Id: I0ecfadaf41f032709a93cf7844abf0eb7ca0eb28
diff --git a/tests/tests/media/src/android/media/cts/MediaCodecTest.java b/tests/tests/media/src/android/media/cts/MediaCodecTest.java
index bb05ea0..07c8bae 100644
--- a/tests/tests/media/src/android/media/cts/MediaCodecTest.java
+++ b/tests/tests/media/src/android/media/cts/MediaCodecTest.java
@@ -467,22 +467,32 @@
}
public void testReleaseAfterFlush() throws IOException, InterruptedException {
+ String mimes[] = new String[] { MIME_TYPE, MIME_TYPE_AUDIO};
+ for (String mime : mimes) {
+ if (!MediaUtils.checkEncoder(mime)) {
+ continue;
+ }
+ testReleaseAfterFlush(mime);
+ }
+ }
+
+ private void testReleaseAfterFlush(String mime) throws IOException, InterruptedException {
CountDownLatch buffersExhausted = null;
CountDownLatch codecFlushed = null;
AtomicInteger numBuffers = null;
// sync flush from same thread
- MediaCodec encoder = MediaCodec.createEncoderByType(MIME_TYPE);
- runReleaseAfterFlush(encoder, buffersExhausted, codecFlushed, numBuffers);
+ MediaCodec encoder = MediaCodec.createEncoderByType(mime);
+ runReleaseAfterFlush(mime, encoder, buffersExhausted, codecFlushed, numBuffers);
// sync flush from different thread
- encoder = MediaCodec.createEncoderByType(MIME_TYPE);
+ encoder = MediaCodec.createEncoderByType(mime);
buffersExhausted = new CountDownLatch(1);
codecFlushed = new CountDownLatch(1);
numBuffers = new AtomicInteger();
Thread flushThread = new FlushThread(encoder, buffersExhausted, codecFlushed);
flushThread.start();
- runReleaseAfterFlush(encoder, buffersExhausted, codecFlushed, numBuffers);
+ runReleaseAfterFlush(mime, encoder, buffersExhausted, codecFlushed, numBuffers);
flushThread.join();
// async
@@ -495,19 +505,19 @@
Handler handler = new Handler(callbackThread.getLooper());
// async flush from same thread
- encoder = MediaCodec.createEncoderByType(MIME_TYPE);
+ encoder = MediaCodec.createEncoderByType(mime);
buffersExhausted = null;
codecFlushed = null;
ReleaseAfterFlushCallback callback =
- new ReleaseAfterFlushCallback(encoder, buffersExhausted, codecFlushed, nBuffs);
+ new ReleaseAfterFlushCallback(mime, encoder, buffersExhausted, codecFlushed, nBuffs);
encoder.setCallback(callback, handler); // setCallback before configure, which is called in run
callback.run(); // drive input on main thread
// async flush from different thread
- encoder = MediaCodec.createEncoderByType(MIME_TYPE);
+ encoder = MediaCodec.createEncoderByType(mime);
buffersExhausted = new CountDownLatch(1);
codecFlushed = new CountDownLatch(1);
- callback = new ReleaseAfterFlushCallback(encoder, buffersExhausted, codecFlushed, nBuffs);
+ callback = new ReleaseAfterFlushCallback(mime, encoder, buffersExhausted, codecFlushed, nBuffs);
encoder.setCallback(callback, handler);
flushThread = new FlushThread(encoder, buffersExhausted, codecFlushed);
flushThread.start();
@@ -544,17 +554,21 @@
}
private static class ReleaseAfterFlushCallback extends MediaCodec.Callback implements Runnable {
+ final String mMime;
final MediaCodec mEncoder;
final CountDownLatch mBuffersExhausted, mCodecFlushed;
final int mNumBuffersBeforeFlush;
CountDownLatch mStopInput = new CountDownLatch(1);
+ List<Integer> mInputBufferIndices = new ArrayList<>();
List<Integer> mOutputBufferIndices = new ArrayList<>();
- ReleaseAfterFlushCallback(MediaCodec encoder,
+ ReleaseAfterFlushCallback(String mime,
+ MediaCodec encoder,
CountDownLatch buffersExhausted,
CountDownLatch codecFlushed,
int numBuffersBeforeFlush) {
+ mMime = mime;
mEncoder = encoder;
mBuffersExhausted = buffersExhausted;
mCodecFlushed = codecFlushed;
@@ -563,7 +577,10 @@
@Override
public void onInputBufferAvailable(MediaCodec codec, int index) {
- fail(codec + " onInputBufferAvailable " + index);
+ assertTrue("video onInputBufferAvailable " + index, mMime.startsWith("audio/"));
+ synchronized (mInputBufferIndices) {
+ mInputBufferIndices.add(index);
+ };
}
@Override
@@ -590,11 +607,20 @@
public void run() {
InputSurface inputSurface = null;
try {
- inputSurface = initCodecAndSurface(mEncoder);
+ inputSurface = initCodecAndSurface(mMime, mEncoder);
do {
- GLES20.glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
- GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
- inputSurface.swapBuffers();
+ int inputIndex = -1;
+ if (inputSurface == null) {
+ // asynchronous audio codec
+ synchronized (mInputBufferIndices) {
+ if (mInputBufferIndices.isEmpty()) {
+ continue;
+ } else {
+ inputIndex = mInputBufferIndices.remove(0);
+ }
+ }
+ }
+ feedEncoder(mEncoder, inputSurface, inputIndex);
} while (!mStopInput.await(TIMEOUT_USEC, TimeUnit.MICROSECONDS));
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
@@ -606,13 +632,14 @@
}
private static void runReleaseAfterFlush(
+ String mime,
MediaCodec encoder,
CountDownLatch buffersExhausted,
CountDownLatch codecFlushed,
AtomicInteger numBuffers) {
InputSurface inputSurface = null;
try {
- inputSurface = initCodecAndSurface(encoder);
+ inputSurface = initCodecAndSurface(mime, encoder);
List<Integer> outputBufferIndices = getOutputBufferIndices(encoder, inputSurface);
if (numBuffers != null) {
numBuffers.set(outputBufferIndices.size());
@@ -623,19 +650,29 @@
}
}
- private static InputSurface initCodecAndSurface(MediaCodec encoder) {
- InputSurface inputSurface;
- CodecInfo info = getAvcSupportedFormatInfo();
- MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, info.mMaxW, info.mMaxH);
- format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
- MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
- format.setInteger(MediaFormat.KEY_BIT_RATE, info.mBitRate);
- format.setInteger(MediaFormat.KEY_FRAME_RATE, info.mFps);
- format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);
- OutputSurface outputSurface = new OutputSurface(1, 1);
- encoder.configure(format, outputSurface.getSurface(), null, MediaCodec.CONFIGURE_FLAG_ENCODE);
- inputSurface = new InputSurface(encoder.createInputSurface());
- inputSurface.makeCurrent();
+ private static InputSurface initCodecAndSurface(String mime, MediaCodec encoder) {
+ MediaFormat format;
+ InputSurface inputSurface = null;
+ if (mime.startsWith("audio/")) {
+ format = MediaFormat.createAudioFormat(mime, AUDIO_SAMPLE_RATE, AUDIO_CHANNEL_COUNT);
+ format.setInteger(MediaFormat.KEY_AAC_PROFILE, AUDIO_AAC_PROFILE);
+ format.setInteger(MediaFormat.KEY_BIT_RATE, AUDIO_BIT_RATE);
+ encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+ } else if (MIME_TYPE.equals(mime)) {
+ CodecInfo info = getAvcSupportedFormatInfo();
+ format = MediaFormat.createVideoFormat(mime, info.mMaxW, info.mMaxH);
+ format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
+ MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
+ format.setInteger(MediaFormat.KEY_BIT_RATE, info.mBitRate);
+ format.setInteger(MediaFormat.KEY_FRAME_RATE, info.mFps);
+ format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);
+ OutputSurface outputSurface = new OutputSurface(1, 1);
+ encoder.configure(format, outputSurface.getSurface(), null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+ inputSurface = new InputSurface(encoder.createInputSurface());
+ inputSurface.makeCurrent();
+ } else {
+ throw new IllegalArgumentException("unsupported mime type: " + mime);
+ }
encoder.start();
return inputSurface;
}
@@ -657,9 +694,7 @@
List<Integer> indices = new ArrayList<>();
do {
feedMoreFrames = indices.isEmpty();
- GLES20.glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
- GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
- inputSurface.swapBuffers();
+ feedEncoder(encoder, inputSurface, -1);
// dequeue buffers until not available
int index = encoder.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
while (index >= 0) {
@@ -672,6 +707,31 @@
return indices;
}
+ /**
+ * @param encoder audio/video encoder
+ * @param inputSurface null for and only for audio encoders
+ * @param inputIndex only used for audio; if -1 the function would attempt to dequeue from encoder;
+ * do not use -1 for asynchronous encoders
+ */
+ private static void feedEncoder(MediaCodec encoder, InputSurface inputSurface, int inputIndex) {
+ if (inputSurface == null) {
+ // audio
+ while (inputIndex == -1) {
+ inputIndex = encoder.dequeueInputBuffer(TIMEOUT_USEC);
+ }
+ ByteBuffer inputBuffer = encoder.getInputBuffer(inputIndex);;
+ for (int i = 0; i < inputBuffer.capacity() / 2; i++) {
+ inputBuffer.putShort((short)i);
+ }
+ encoder.queueInputBuffer(inputIndex, 0, inputBuffer.limit(), 0, 0);
+ } else {
+ // video
+ GLES20.glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
+ GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
+ inputSurface.swapBuffers();
+ }
+ }
+
private static void releaseAfterFlush(
MediaCodec encoder,
List<Integer> outputBufferIndices,
