EncoderDecoderTestForMJPEG.java

/**
 * This was written as if it were a CTS test, but is not part of CTS. It should be straightforward
 * to adapt the code to other environments.
 *
 * It's enable YUVY422 pic buffer to JPEG using MediaCodec
 *
 * Author: Alan Wang
 * Date : 2015-07-10
 */

package android.media.cts;

import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.media.MediaFormat;
import android.os.Environment;
import android.test.AndroidTestCase;
import android.util.Log;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

/**
 *
 *
 */
public class EncoderDecoderTestForMJPEG extends AndroidTestCase {
 private static final String LOG_TAG = "EncoderDecoderTestForMJPEG";

 // Where to find the input
 // And Where to store the output
 private static final String INPUT_FILE_NAME_BASE =
 Environment.getExternalStorageDirectory() + "/video.YUY2";
 private static final String OUTPUT_FILE_NAME_BASE =
 Environment.getExternalStorageDirectory() + "/video.jpeg";

 // Parameters for encoder
 private static final String MIME_TYPE = "video/mjpeg";

 private static final int TIME_OUT = 10000; //usec

 private static final int FRAME_RATE = 15; // 15fps, not really needed
 private static final int NUM_FRAMES = 10; // Num of frame to input for decode/encode
 private static final int IFRAME_INTERVAL = 10; // 10 secs between I-frames, not really needed


 private int mWidth = -1;
 private int mHeight = -1;
 private int mBitRate = -1;

 // Allocate one BufferInfo
 private MediaCodec.BufferInfo mBufferInfo;

 /**
 * Test Encoding of MJPEG from Buffer
 *
 */
 public void testEncodeVideoFromBufToBuf1080p() throws Exception {
 Log.i(LOG_TAG, "Encode Video from Buffer To Buffer 1080p");
 setParameters(1920, 1080, 6000000);
 encodeVideoFromBuffer();
 }

 public void testEncodeVideoFromBufToBuf768p() throws Exception {
 Log.i(LOG_TAG, "Encode Video from Buffer To Buffer 768p");
 setParameters(1024, 768, 6000000);
 encodeVideoFromBuffer();
 }

 public void testEncodeVideoFromBufToBuf720p() throws Exception {
 Log.i(LOG_TAG, "Encode Video from Buffer To Buffer 720p");
 setParameters(1280, 720, 6000000);
 encodeVideoFromBuffer();
 }

 public void testEncodeVideoFromBufToBufD1() throws Exception {
 Log.i(LOG_TAG, "Encode Video from Buffer To Buffer D1");
 setParameters(720, 480, 6000000);
 encodeVideoFromBuffer();
 }

 public void testEncodeVideoFromBufToBuf384p() throws Exception {
 Log.i(LOG_TAG, "Encode Video from Buffer To Buffer Cross");
 setParameters(512, 384, 6000000);
 encodeVideoFromBuffer();
 }

 /**
 * Test Decoding of MJPEG from Buffer
 *
 */
 public void testDecodeVideoFromBufToBuf1080p() throws Exception {
 Log.i(LOG_TAG, "Decode Video from Buffer to Buffer 1080p");
 setParameters(1920, 1080, 6000000);
 decodeVideoFromBuffer();
 }

 public void testDecodeVideoFromBufToBuf720p() throws Exception {
 Log.i(LOG_TAG, "Decode Video from Buffer to Buffer 720p");
 setParameters(1280, 720, 6000000);
 decodeVideoFromBuffer();
 }

 public void testDecodeVideoFromBufToBuf768p() throws Exception {
 Log.i(LOG_TAG, "Decode Video from Buffer to Buffer 768p");
 setParameters(1024, 768, 6000000);
 decodeVideoFromBuffer();
 }

 public void testDecodeVideoFromBufToBufD1() throws Exception {
 Log.i(LOG_TAG, "Decode Video from Buffer to Buffer D1");
 setParameters(720, 480, 6000000);
 decodeVideoFromBuffer();
 }

 public void testDecodeVideoFromBufToBuf384p() throws Exception {
 Log.i(LOG_TAG, "Decode Video from Buffer to Buffer 768p");
 setParameters(512, 384, 6000000);
 decodeVideoFromBuffer();
 }
 /**
 * Sets the desired frame size and bit rate.
 */
 private void setParameters(int width, int height, int bitRate) {
 if ((width % 16) != 0 || (height % 16) != 0) {
 Log.w(LOG_TAG, "WARNING: width or height not multiple of 16");
 }
 mWidth = width;
 mHeight = height;
 mBitRate = bitRate;
 }

 private void encodeVideoFromBuffer() throws Exception {
 MediaCodec encoder = null;

 try {
 MediaCodecInfo codecInfo = selectCodec(MIME_TYPE, true);
 if (codecInfo == null) {
 Log.e(LOG_TAG, "Unable to find an appropriate codec for " + MIME_TYPE);
 return;
 }

 Log.i(LOG_TAG, "Found codec: " + codecInfo.getName());

 // JPEG encoder only support this colorFormat as Input
 // COLOR_FormatCbYCrY a.k.a Organized as 16bit UYVY
 int colorFormat = MediaCodecInfo.CodecCapabilities.COLOR_FormatCbYCrY;

 MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);

 // Set some properties. Failing to specify some of these can cause the MediaCodec
 // configure() call to throw an unhelpful exception.
 format.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
 format.setInteger(MediaFormat.KEY_BIT_RATE, mBitRate);
 format.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
 format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);
 Log.i(LOG_TAG, "format: " + format);

 // Create a MediaCodec for the desired codec, then configure it as an encoder with
 // our desired properties.
 encoder = MediaCodec.createByCodecName(codecInfo.getName());
 Log.i(LOG_TAG, "created Codec " + codecInfo.getName());
 encoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
 encoder.start();

 doEncodeVideoFromBuffer(encoder, colorFormat);

 } finally {

 Log.i(LOG_TAG, "releasing encoder");
 if (encoder != null) {
 encoder.stop();
 encoder.release();
 }

 }

 }

 private void decodeVideoFromBuffer() throws Exception {
 MediaCodec decoder = null;

 try {
 MediaCodecInfo codecInfo = selectCodec(MIME_TYPE, false);
 if (codecInfo == null) {
 Log.e(LOG_TAG, "Unable to find an appropriate codec for " + MIME_TYPE);
 return;
 }

 Log.i(LOG_TAG, "Found codec: " + codecInfo.getName());

 // JPEG decoder only support this colorFormat as Output
 // COLOR_FormatCbYCrY a.k.a Organized as 16bit UYVY
 int colorFormat = MediaCodecInfo.CodecCapabilities.COLOR_FormatCbYCrY;

 MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);

 // Create a MediaCodec for the desired codec, then configure it as an encoder with
 // our desired properties.
 decoder = MediaCodec.createByCodecName(codecInfo.getName());
 Log.i(LOG_TAG, "created Codec " + codecInfo.getName());
 decoder.configure(format, null, null, 0);
 decoder.start();

 doDecodeVideoFromBuffer(decoder, colorFormat);

 } finally {

 Log.i(LOG_TAG, "releasing decoder");
 if (decoder != null) {
 decoder.stop();
 decoder.release();
 }

 }

 }

 /**
 * Returns the first codec capable of encoding the specified MIME_TYPE
 */
 private static MediaCodecInfo selectCodec(String mimeType, boolean needEncoder) {
 int numCodec = MediaCodecList.getCodecCount();
 Log.i(LOG_TAG, "We got " + numCodec + " Codecs");

 for (int i = 0; i < numCodec; i++) {
 MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);

 if (!codecInfo.isEncoder() && needEncoder) {
 continue;
 }

 String[] type = codecInfo.getSupportedTypes();
 for (int j = 0; j < type.length; j++) {
 Log.i(LOG_TAG, "We got type " + type[j]);
 if (type[j].equalsIgnoreCase(mimeType)) {
 return codecInfo;
 }
 }

 }

 return null;
 }

 /**
 * Do the actual work for encoding frames from buffers of byte[].
 * @param encoder
 * @param encoderColorFormat
 */
 private void doEncodeVideoFromBuffer(MediaCodec encoder, int encoderColorFormat) throws IOException {
 Log.i(LOG_TAG, "In doEncodeVideoFromBuffer...");

 int generateIndex = 0;
 int outPutIndex = 0;

 ByteBuffer[] encoderInputBuffers = encoder.getInputBuffers();
 ByteBuffer[] encoderOutputBuffers = encoder.getOutputBuffers();

 MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();

 // The size of a frame of video data, in the format we handle, is mWidth*mHeight*2
 byte[] frameData = new byte[mWidth * mHeight * 2];

 // Encoded outputStream
 FileOutputStream outputStream = null;

 boolean inputDone = false;
 boolean encodeDone = false;
 boolean outputDone = false;

 while (!outputDone) {
 Log.i(LOG_TAG, "Looping... ");

 // If we're not done submitting frames, generate a new one and submit it. By
 // doing this on every loop we're working to ensure that the encoder always has
 // work to do.
 //
 // We don't really want a timeout here, but sometimes there's a delay opening
 // the encoder device, so a short timeout can keep us from spinning hard.
 if (!inputDone) {
 int inputBufIndex = encoder.dequeueInputBuffer(TIME_OUT);
 Log.d(LOG_TAG, "inputBufIndex = " + inputBufIndex);

 if (inputBufIndex >= 0) {
 long ptsUsec = computePTS(generateIndex);
 // Store input data into frameData
 generateFrame(generateIndex, encoderColorFormat, frameData, true, true);

 ByteBuffer inputBuf = encoderInputBuffers[inputBufIndex];
 // Buf capacity check
 Log.i(LOG_TAG, "inputBuf.capacity() = " + inputBuf.capacity()
 + "frameData.length = " + frameData.length);
 assertTrue(inputBuf.capacity() >= frameData.length);
 inputBuf.clear();
 inputBuf.put(frameData);

 encoder.queueInputBuffer(inputBufIndex, 0, frameData.length, ptsUsec, 0);
 Log.i(LOG_TAG, "Buffer " + inputBufIndex + " submitted to encode");
 generateIndex++;
 } else {
 Log.w(LOG_TAG, "Input buffer not available");
 }

 if (generateIndex >= NUM_FRAMES) {
 Log.d(LOG_TAG, "generateIndex = " + generateIndex + " Queuing EOS in InputBuffer");
 //encoder.queueInputBuffer(inputBufIndex, 0, 0, 0,
 // MediaCodec.BUFFER_FLAG_END_OF_STREAM);
 inputDone = true;
 }
 }

 // Check for output from the encoder. If there's no output yet, we either need to
 // provide more input, or we need to wait for the encoder to work its magic. We
 // can't actually tell which is the case, so if we can't get an output buffer right
 // away we loop around and see if it wants more input.
 //
 // Once we get EOS from the encoder, we don't need to do this anymore.
 if (!encodeDone) {
 Log.d(LOG_TAG, "dequeuing Output buffers...");
 int encoderStatus = encoder.dequeueOutputBuffer(info, TIME_OUT);
 if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
 Log.i(LOG_TAG, "No output from encoder available, try again later.");
 } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
 Log.i(LOG_TAG, "INFO_OUTPUT_BUFFERS_CHANGED... NOT EXPECTED for and encoder");
 } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
 Log.i(LOG_TAG, "INFO_OUTPUT_FORMAT_CHANGED... NOT EXPECTED for and encoder");
 } else if (encoderStatus < 0) {
 Log.e(LOG_TAG, "Unexpected result!!!");
 fail("encoder in wrong Status");
 } else { // it's the index of an output buffer that has been successfully decoded

 Log.i(LOG_TAG, "Encode success, encoderStatus = " + encoderStatus);
 outputStream = new FileOutputStream(OUTPUT_FILE_NAME_BASE + "_" + outPutIndex);
 ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
 if (encodedData == null) {
 fail("encoderOuputBuffer " + encoderStatus + " was null");
 }

 encodedData.position(info.offset);
 encodedData.limit(info.offset + info.size);

 if (outputStream != null) {
 byte[] data = new byte[info.size];
 encodedData.get(data); //Store input buffer into data
 encodedData.position(info.offset);

 Log.i(LOG_TAG, "outputStream writing data!");
 outputStream.write(data);
 outPutIndex++;
 }

 encoder.releaseOutputBuffer(encoderStatus, false);

 //FIXME: Check info.flags is not working ???
 if (outPutIndex >= NUM_FRAMES) {
 outputDone = true;
 encodeDone = true;
 }

 }
 }
 }
 }

 /**
 * Do the actual work for decoding frames from buffers of byte[].
 * @param decoder
 * @param decoderColorFormat
 *
 */
 private void doDecodeVideoFromBuffer(MediaCodec decoder, int decoderColorFormat)
 throws IOException {
 Log.i(LOG_TAG, "In doDecodeVideoFromBuffer ...");

 // As for decoder, the input file is video.jpeg the output file is video.YUY2
 // which is oppsite with encoder
 String INPUT = OUTPUT_FILE_NAME_BASE;
 String OUTPUT = INPUT_FILE_NAME_BASE;

 int generateIndex = 0;
 int outPutIndex = 0;

 //File input = new File(INPUT + "_" + generateIndex);
 File input = null;
 byte[] frameData = null;

 ByteBuffer[] decoderInputBuffers = decoder.getInputBuffers();

 MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();

 // Decoded outputStream
 FileOutputStream outputStream = null;

 boolean inputDone = false;
 boolean decodeDone = false;
 boolean outputDone = false;

 while (!outputDone) {
 Log.i(LOG_TAG, "Loopping...");

 // If we're not done submitting frames, generate a new one and submit it. By
 // doing this on every loop we're working to ensure that the encoder always has
 // work to do.
 //
 // We don't really want a timeout here, but sometimes there's a delay opening
 // the encoder device, so a short timeout can keep us from spinning hard.
 if (!inputDone) {
 int inputBufIndex = decoder.dequeueInputBuffer(TIME_OUT);
 Log.i(LOG_TAG, "inputBufIndex = " + inputBufIndex);

 if (inputBufIndex >= 0) {
 long ptsUsec = computePTS(generateIndex);

 input = new File(INPUT + "_" + generateIndex);
 frameData = new byte[(int)input.length()];
 // Store input data into frameData
 generateFrame(generateIndex, decoderColorFormat, frameData, true, false);

 ByteBuffer inputBuf = decoderInputBuffers[inputBufIndex];
 // Buf capacity check
 Log.i(LOG_TAG, "inputBuf.capacity() = " + inputBuf.capacity()
 + "frameData.length = " + frameData.length);
 assertTrue(inputBuf.capacity() >= frameData.length);
 inputBuf.clear();
 inputBuf.put(frameData);

 decoder.queueInputBuffer(inputBufIndex, 0, frameData.length, ptsUsec, 0);
 Log.i(LOG_TAG, "Buffer " + inputBufIndex + " of len = " + frameData.length + " submitted to decode");
 generateIndex++;

 } else {
 Log.w(LOG_TAG, "Input buffer not available");
 }

 if(generateIndex >= NUM_FRAMES) {
 // We have enough frames, so send an empty one with EOS flag
 Log.d(LOG_TAG, "generateIndex = " + generateIndex + "Queuing EOS in InputBuffer");
 //decoder.queueInputBuffer(inputBufIndex, 0, 0, 0,
 // MediaCodec.BUFFER_FLAG_END_OF_STREAM);
 inputDone = true;
 }
 }

 // Check for output from the decoder. We want to do this on every loop to avoid
 // the possibility of stalling the pipeline. We use a short timeout to avoid
 // burning CPU if the decoder is hard at work but the next frame isn't quite ready.
 //
 // If we're decoding to a Surface, we'll get notified here as usual but the
 // ByteBuffer references will be null. The data is sent to Surface instead.
 if (!decodeDone) {
 Log.d(LOG_TAG, "dequeuing Output buffers...");
 int decoderStatus = decoder.dequeueOutputBuffer(info, TIME_OUT);
 if (decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
 Log.i(LOG_TAG, "No output from decoder available, try again later.");
 } else if (decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
 Log.i(LOG_TAG, "INFO_OUTPUT_BUFFERS_CHANGED... NOT EXPECTED for and decoder");
 } else if (decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
 Log.i(LOG_TAG, "INFO_OUTPUT_FORMAT_CHANGED... NOT EXPECTED for and decoder");
 } else if (decoderStatus < 0) {
 Log.e(LOG_TAG, "Unexpected result!!!");
 fail("decoder in wrong Status");
 } else { // it's the index of an output buffer that has been successfully decoded
 Log.i(LOG_TAG, "Decode success, decoderStatus = " + decoderStatus + " info.size = " + info.size);

 ByteBuffer[] decoderOutputBuffers = decoder.getOutputBuffers();
 ByteBuffer decodedData = decoderOutputBuffers[decoderStatus];

 if (decodedData == null) {
 fail("decoderOuputBuffer " + decoderStatus + " was null");
 }

 outputStream = new FileOutputStream(OUTPUT + "_" + outPutIndex);

 decodedData.position(info.offset);
 decodedData.limit(info.offset + info.size);

 if (outputStream != null) {
 byte[] data = new byte[info.size];
 decodedData.get(data); //Store input buffer into data
 decodedData.position(info.offset);

 if (info.size > 0) {
 Log.i(LOG_TAG, "outputStream writing data! size = " + info.size);
 outputStream.write(data);
 }
 outPutIndex++;
 }

 if (outPutIndex >= NUM_FRAMES) {
 outputDone = true;
 decodeDone = true;
 }

 decoder.releaseOutputBuffer(decoderStatus, false);

 }
 }
 }

 }

 private long computePTS(int generateIndex) {
 return 132 + generateIndex * 1000000 / FRAME_RATE;
 }

 /**
 *
 * @param frameIndex
 * @param colorFormat
 * @param frameData
 * @param readFromDisk true: the data is read file the yuv file
 * [WIP]false: the data is generated like:
 *
 * Generates data for frame N into the supplied buffer. We have an 8-frame animation
 * sequence that wraps around. It looks like this:
 * <pre>
 * 0 1 2 3
 * 7 6 5 4
 * </pre>
 * We draw one of the eight rectangles and leave the rest set to the zero-fill color.
 */
 private void generateFrame(int frameIndex, int colorFormat,
 byte[] frameData, boolean readFromDisk,
 boolean encoder) {

 if (frameIndex >= NUM_FRAMES) {
 fail("frameIndex is overflow...");
 }

 FileInputStream fileInputStream = null;
 File file = null;

 // If it's decoder the OUTPUT_FILE name is as INPUT
 if (encoder) {
 file = new File(INPUT_FILE_NAME_BASE + "_" + frameIndex);
 } else {
 file = new File(OUTPUT_FILE_NAME_BASE + "_" + frameIndex);
 }

 Log.i(LOG_TAG, "file.length = " + file.length());


 if (readFromDisk) {

 try {
 //convert file into array of bytes
 fileInputStream = new FileInputStream(file);
 fileInputStream.read(frameData);
 fileInputStream.close();

 } catch (Exception e) {
 e.printStackTrace();
 }

 } else {
 //WIP: Read from surface
 Log.w(LOG_TAG, "Not implement so far...");
 }


 }


}