我正在尝试编写一个可以拍摄给定视频并将其分辨率更改为给定大小，比特率和音频采样率的Android应用。我正在使用API级别18中提供的内置MediaCodec和MediaMuxer类，我几乎都在关注BigFlake.com（http://bigflake.com/mediacodec/）的示例，但是我遇到了一些麻烦，让它全部顺利运行。
现在，当我尝试拨打IllegalStateException课程的dequeueInputBuffer时，我收到了MediaCodec。我知道这是一个很好的例外，但我希望有人可以看看下面的代码，让我知道我哪里出错了？
更新
结果显示dequeueInputBuffer来电是解决问题的问题。由于480 x 360不是16的倍数，dequeueInputBuffer扔了IllegalStateException。将目标分辨率更改为512 x 288可解决此问题。
现在，我遇到了queueInputBuffer方法调用的问题。这个电话给了我与之前相同的IllegalStateException，但现在出于不同的原因。
有趣的是我看过BigFlake.com上的示例，甚至重新实现了它，我仍然在这一行上得到了同样的例外。有没有人知道发生了什么？
顺便说一句，我删除了我的旧代码，并用最新版本更新了这篇文章。
谢谢！
package com.mikesappshop.videoconverter;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.media.MediaMuxer;
import android.util.Log;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Created by mneill on 11/3/15.
*/
public class VideoConverter {
// Interface
public interface CompletionHandler {
void videoEncodingDidComplete(Error error);
}
// Constants
private static final String TAG = "VideoConverter";
private static final boolean VERBOSE = true; // lots of logging
// parameters for the encoder
private static final String MIME_TYPE = "video/avc"; // H.264 Advanced Video Coding
private static final int FRAME_RATE = 15; // 15fps
private static final int CAPTURE_RATE = 15; // 15fps
private static final int IFRAME_INTERVAL = 10; // 10 seconds between I-frames
private static final int CHANNEL_COUNT = 1;
private static final int SAMPLE_RATE = 128000;
private static final int TIMEOUT_USEC = 10000;
// size of a frame, in pixels
private int mWidth = -1;
private int mHeight = -1;
// bit rate, in bits per second
private int mBitRate = -1;
// encoder / muxer state
private MediaCodec mDecoder;
private MediaCodec mEncoder;
private MediaMuxer mMuxer;
private int mTrackIndex;
private boolean mMuxerStarted;
/**
* Starts encoding process
*/
public void convertVideo(String mediaFilePath, String destinationFilePath, CompletionHandler handler) {
// TODO: Make configurable
// mWidth = 480;
// mHeight = 360;
mWidth = 512;
mHeight = 288;
mBitRate = 500000;
try {
if ((mWidth % 16) != 0 || (mHeight % 16) != 0) {
Log.e(TAG, "Width or Height not multiple of 16");
Error e = new Error("Width and height must be a multiple of 16");
handler.videoEncodingDidComplete(e);
return;
}
// prep the decoder and the encoder
prepareEncoderDecoder(destinationFilePath);
// load file
File file = new File(mediaFilePath);
byte[] fileData = readContentIntoByteArray(file);
// fill up the input buffer
fillInputBuffer(fileData);
// encode buffer
encode();
} catch (Exception ex) {
Log.e(TAG, ex.toString());
ex.printStackTrace();
} finally {
// release encoder and muxer
releaseEncoder();
}
}
/**
* Configures encoder and muxer state
*/
private void prepareEncoderDecoder(String outputPath) throws Exception {
// create decoder to read in the file data
mDecoder = MediaCodec.createDecoderByType(MIME_TYPE);
// create encoder to encode the file data into a new format
MediaCodecInfo info = selectCodec(MIME_TYPE);
int colorFormat = selectColorFormat(info, MIME_TYPE);
MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, mWidth, mHeight);
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);
mEncoder = MediaCodec.createByCodecName(info.getName());
mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
mEncoder.start();
// Create a MediaMuxer for saving the data
mMuxer = new MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
mTrackIndex = -1;
mMuxerStarted = false;
}
/**
* Releases encoder resources. May be called after partial / failed initialization.
*/
private void releaseEncoder() {
if (VERBOSE) Log.d(TAG, "releasing encoder objects");
if (mEncoder != null) {
mEncoder.stop();
mEncoder.release();
mEncoder = null;
}
if (mMuxer != null) {
mMuxer.stop();
mMuxer.release();
mMuxer = null;
}
}
private void fillInputBuffer(byte[] data) {
boolean inputDone = false;
int processedDataSize = 0;
int frameIndex = 0;
Log.d(TAG, "[fillInputBuffer] Buffer load start");
ByteBuffer[] inputBuffers = mEncoder.getInputBuffers();
while (!inputDone) {
int inputBufferIndex = mEncoder.dequeueInputBuffer(10000);
if (inputBufferIndex >= 0) {
if (processedDataSize >= data.length) {
mEncoder.queueInputBuffer(inputBufferIndex, 0, 0, computePresentationTime(frameIndex), MediaCodec.BUFFER_FLAG_END_OF_STREAM);
inputDone = true;
Log.d(TAG, "[fillInputBuffer] Buffer load complete");
} else {
ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
int limit = inputBuffer.capacity();
int pos = frameIndex * limit;
byte[] subData = new byte[limit];
System.arraycopy(data, pos, subData, 0, limit);
inputBuffer.clear();
inputBuffer.put(subData);
Log.d(TAG, "[encode] call queueInputBuffer");
mDecoder.queueInputBuffer(inputBufferIndex, 0, subData.length, computePresentationTime(frameIndex), MediaCodec.BUFFER_FLAG_CODEC_CONFIG);
Log.d(TAG, "[encode] did call queueInputBuffer");
Log.d(TAG, "[encode] Loaded frame " + frameIndex + " into buffer");
frameIndex++;
}
}
}
}
private void encode() throws Exception {
// get buffer info
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
// start encoding
ByteBuffer[] encoderOutputBuffers = mEncoder.getOutputBuffers();
while (true) {
int encoderStatus = mEncoder.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
// no output available yet
if (VERBOSE) Log.d(TAG, "no output available, spinning to await EOS");
break;
} else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
// not expected for an encoder
encoderOutputBuffers = mEncoder.getOutputBuffers();
} else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
// should happen before receiving buffers, and should only happen once
if (!mMuxerStarted) {
MediaFormat newFormat = mEncoder.getOutputFormat();
Log.d(TAG, "encoder output format changed: " + newFormat);
// now that we have the Magic Goodies, start the muxer
mTrackIndex = mMuxer.addTrack(newFormat);
mMuxer.start();
mMuxerStarted = true;
}
} else if (encoderStatus > 0) {
ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
if (encodedData == null) {
throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
}
if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
if (VERBOSE) Log.d(TAG, "ignoring BUFFER_FLAG_CODEC_CONFIG");
bufferInfo.size = 0;
}
if (bufferInfo.size != 0) {
if (!mMuxerStarted) {
throw new RuntimeException("muxer hasn't started");
}
// adjust the ByteBuffer values to match BufferInfo (not needed?)
encodedData.position(bufferInfo.offset);
encodedData.limit(bufferInfo.offset + bufferInfo.size);
mMuxer.writeSampleData(mTrackIndex, encodedData, bufferInfo);
if (VERBOSE) Log.d(TAG, "sent " + bufferInfo.size + " bytes to muxer");
}
mEncoder.releaseOutputBuffer(encoderStatus, false);
if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
if (VERBOSE) Log.d(TAG, "end of stream reached");
break; // out of while
}
}
}
}
private byte[] readContentIntoByteArray(File file) throws Exception
{
FileInputStream fileInputStream = null;
byte[] bFile = new byte[(int) file.length()];
//convert file into array of bytes
fileInputStream = new FileInputStream(file);
fileInputStream.read(bFile);
fileInputStream.close();
return bFile;
}
/**
* Returns the first codec capable of encoding the specified MIME type, or null if no
* match was found.
*/
private static MediaCodecInfo selectCodec(String mimeType) {
int numCodecs = MediaCodecList.getCodecCount();
for (int i = 0; i < numCodecs; i++) {
MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
if (!codecInfo.isEncoder()) {
continue;
}
String[] types = codecInfo.getSupportedTypes();
for (int j = 0; j < types.length; j++) {
if (types[j].equalsIgnoreCase(mimeType)) {
return codecInfo;
}
}
}
return null;
}
private static int selectColorFormat(MediaCodecInfo codecInfo, String mimeType) {
MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
for (int i = 0; i < capabilities.colorFormats.length; i++) {
int colorFormat = capabilities.colorFormats[i];
if (isRecognizedFormat(colorFormat)) {
return colorFormat;
}
}
return 0; // not reached
}
private static boolean isRecognizedFormat(int colorFormat) {
switch (colorFormat) {
// these are the formats we know how to handle for this test
case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
return true;
default:
return false;
}
}
/**
* Generates the presentation time for frame N, in microseconds.
*/
private static long computePresentationTime(int frameIndex) {
return 132 + frameIndex * 1000000 / FRAME_RATE;
}
}
答案 0 :(得分：2)
唯一让我跳出来的是你这样做：
MediaCodecInfo info = selectCodec(MIME_TYPE);
int colorFormat = selectColorFormat(info, MIME_TYPE);
然后这个：
mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
而不是：
mEncoder = MediaCodec.createByCodecName(info.getName());
（见this example）
我不知道为什么会导致失败，或者为什么在你去解码输入缓冲区之前不会出现失败。但是，如果您从编解码器中选择颜色格式，则应确保使用该编解码器。
其他说明：
mEncoder.configure()的异常，但不会停止执行。坚持throw new RuntimeException(ex)。encode()中的例外...为什么？删除try / catch以确保故障是显而易见的并停止编码过程。KEY_SAMPLE_RATE和KEY_CHANNEL_COUNT，这些用于音频。使用MediaCodec解码视频的视频转换最好通过Surface传递数据，但看起来您已经在文件中获得了YUV数据。希望您选择的YUV格式与编码器接受的格式相匹配。
答案 1 :(得分：0)
在函数 fillInputBuffer -> 的 else 部分中，为什么要在解码器缓冲区中排队。
Log.d(TAG, "[encode] call queueInputBuffer");
mDecoder.queueInputBuffer(inputBufferIndex, 0, subData.length, computePresentationTime(frameIndex), MediaCodec.BUFFER_FLAG_CODEC_CONFIG);
Log.d(TAG, "[encode] did call queueInputBuffer");
使用 mEncoder 代替 mDecoder 它会起作用