我正在尝试编写一个 Android 应用程序，它可以拍摄给定的视频并将其分辨率更改为给定的大小、比特率和音频采样率。我正在使用 API 级别 18 中提供的内置 MediaCodec 和 MediaMuxer 类，并且我非常关注来自 BigFlake.com (http://bigflake.com/mediacodec/) 的示例，但我在让它顺利运行时遇到了一些麻烦。
现在我在尝试调用 MediaCodec 类上的 dequeueInputBuffer 时遇到了一个 IllegalStateException。我知道这是一种包罗万象的异常，但我希望有人能看看我下面的代码并让我知道哪里出错了？
更新
事实证明，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;
}
}
最佳答案
唯一让我震惊的是你正在这样做:
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 格式。
关于Android更改视频文件的分辨率，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33524364/