Android 利用MediaCodec 实现硬编码 h264

来源：互联网发布：阿里通网络客服电话编辑：程序博客网时间：2024/05/17 05:01

本篇文章记录一下，Android调用mediacodec编码camera回掉的YUV数据为h264的方法。

由于公司需要，软编码（X264）由于手机性能的瓶颈，已不能满足要求，所以决定使用硬编码。其实硬编码最早用过MediaRecord，但是不能直接得到h264数据，得先编成MP4，再从MP4里把H264的NALU取出来，感觉太绕了，所以当时抛弃了MediaRecord，选择了x264。不过看来，现在还得走上硬编码的路了 -- MediaCodec

这篇文章就用一个demo来说一下mediacodec的调用吧。

首先，要获取到CAMERA的回掉回来的YUV数据。

其次，将获得到的数据用MEDIACODEC编码为H264。

最后，将H264写入文件，程序结束后，可用VLC等支持播放H264的播放器查看效果。

先说下获取YUV数据吧，这个很简单了，直接上代码

[java] view plain copy

package com.example.mediacodecencode;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.graphics.ImageFormat;
import android.hardware.Camera;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.PreviewCallback;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
public class MainActivity extends Activity implements SurfaceHolder.Callback,PreviewCallback{
private SurfaceView surfaceview;
private SurfaceHolder surfaceHolder;
private Camera camera;
private Parameters parameters;
int width = 1280;
int height = 720;
int framerate = 30;
int biterate = 8500*1000;
private static int yuvqueuesize = 10;
public static ArrayBlockingQueue<byte[]> YUVQueue = new ArrayBlockingQueue<byte[]>(yuvqueuesize);
private AvcEncoder avcCodec;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
surfaceview = (SurfaceView)findViewById(R.id.surfaceview);
surfaceHolder = surfaceview.getHolder();
surfaceHolder.addCallback(this);
SupportAvcCodec();
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
camera = getBackCamera();
startcamera(camera);
avcCodec = new AvcEncoder(width,height,framerate,biterate);
avcCodec.StartEncoderThread();
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
if (null != camera) {
camera.setPreviewCallback(null);
camera.stopPreview();
camera.release();
camera = null;
avcCodec.StopThread();
}
}
@Override
public void onPreviewFrame(byte[] data, android.hardware.Camera camera) {
// TODO Auto-generated method stub
putYUVData(data,data.length);
}
public void putYUVData(byte[] buffer, int length) {
if (YUVQueue.size() >= 10) {
YUVQueue.poll();
}
YUVQueue.add(buffer);
}
@SuppressLint("NewApi")
private boolean SupportAvcCodec(){
if(Build.VERSION.SDK_INT>=18){
for(int j = MediaCodecList.getCodecCount() - 1; j >= 0; j--){
MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(j);
String[] types = codecInfo.getSupportedTypes();
for (int i = 0; i < types.length; i++) {
if (types[i].equalsIgnoreCase("video/avc")) {
return true;
}
}
}
}
return false;
}
private void startcamera(Camera mCamera){
if(mCamera != null){
try {
mCamera.setPreviewCallback(this);
mCamera.setDisplayOrientation(90);
if(parameters == null){
parameters = mCamera.getParameters();
}
parameters = mCamera.getParameters();
parameters.setPreviewFormat(ImageFormat.NV21);
parameters.setPreviewSize(width, height);
mCamera.setParameters(parameters);
mCamera.setPreviewDisplay(surfaceHolder);
mCamera.startPreview();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@TargetApi(9)
private Camera getBackCamera() {
Camera c = null;
try {
c = Camera.open(0); // attempt to get a Camera instance
} catch (Exception e) {
e.printStackTrace();
}
return c; // returns null if camera is unavailable
}
}

其实没啥说的，很简答的逻辑。不过上面代码有这么几点可以说一下：

1.camera start的时机最好放在surfaceCreated，销毁最好放在surfaceDestroyed；

2.camera parameters setPreviewFormat的时候在5.0一下系统使用NV21或YV12，因为基本所有的安卓手机都支持这两种预览格式；

3.最好在程序的开始，判断一下系统是否支持MediaCodec编码h264，具体逻辑可见上面的SupportAvcCodec方法。

4.上面的代码中，可以看出，我把YUV数据放到一个队列里面了，准备使用。

其次就是使用MediaCodec编码h264了，首先，初始化MediaCodec，方法如下：

[java] view plain copy
@SuppressLint("NewApi")  
    public AvcEncoder(int width, int height, int framerate, int bitrate) {   
          
        m_width  = width;  
        m_height = height;  
        m_framerate = framerate;  
      
        MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", width, height);  
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar);      
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, width*height*5);  
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 30);  
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);  
        try {  
            mediaCodec = MediaCodec.createEncoderByType("video/avc");  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        mediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);  
        mediaCodec.start();  
        createfile();  
    }  

需要注意的一点是，对于比特率，其实完全可以这样处理，N*width*height，N可设置为1 2 3或者1 3 5等，来区分低/中/高的码率。

另外，我选择了YUV420SP作为编码的目标颜色空间，其实YUV420SP就是NV12，咱们CAMERA设置的是NV21，所以需要转一下。转换方法如下：

[java] view plain copy
private void NV21ToNV12(byte[] nv21,byte[] nv12,int width,int height){  
        if(nv21 == null || nv12 == null)return;  
        int framesize = width*height;  
        int i = 0,j = 0;  
        System.arraycopy(nv21, 0, nv12, 0, framesize);  
        for(i = 0; i < framesize; i++){  
            nv12[i] = nv21[i];  
        }  
        for (j = 0; j < framesize/2; j+=2)  
        {  
          nv12[framesize + j-1] = nv21[j+framesize];  
        }  
        for (j = 0; j < framesize/2; j+=2)  
        {  
          nv12[framesize + j] = nv21[j+framesize-1];  
        }  
    }  

下面，就是编码的函数了，我这里把编码放在一个线程里，去轮训YUV队列，如有有数据就编码，具体如下：

[java] view plain copy

public void StartEncoderThread(){
Thread EncoderThread = new Thread(new Runnable() {
@SuppressLint("NewApi")
@Override
public void run() {
isRuning = true;
byte[] input = null;
long pts = 0;
long generateIndex = 0;
while (isRuning) {
if (MainActivity.YUVQueue.size() >0){
input = MainActivity.YUVQueue.poll();
byte[] yuv420sp = new byte[m_width*m_height*3/2];
NV21ToNV12(input,yuv420sp,m_width,m_height);
input = yuv420sp;
}
if (input != null) {
try {
long startMs = System.currentTimeMillis();
ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();
ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();
int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);
if (inputBufferIndex >= 0) {
pts = computePresentationTime(generateIndex);
ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
inputBuffer.clear();
inputBuffer.put(input);
mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, pts, 0);
generateIndex += 1;
}
MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
while (outputBufferIndex >= 0) {
//Log.i("AvcEncoder", "Get H264 Buffer Success! flag = "+bufferInfo.flags+",pts = "+bufferInfo.presentationTimeUs+"");
ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
byte[] outData = new byte[bufferInfo.size];
outputBuffer.get(outData);
if(bufferInfo.flags == 2){
configbyte = new byte[bufferInfo.size];
configbyte = outData;
}else if(bufferInfo.flags == 1){
byte[] keyframe = new byte[bufferInfo.size + configbyte.length];
System.arraycopy(configbyte, 0, keyframe, 0, configbyte.length);
System.arraycopy(outData, 0, keyframe, configbyte.length, outData.length);
outputStream.write(keyframe, 0, keyframe.length);
}else{
outputStream.write(outData, 0, outData.length);
}
mediaCodec.releaseOutputBuffer(outputBufferIndex, false);
outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
}
} catch (Throwable t) {
t.printStackTrace();
}
} else {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
});
EncoderThread.start();
}

需要注意的有两点，其实也是两个坑：

坑1：mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, pts, 0); 第四个参数，是否需要传入？我觉得必须得传，因为不传的话，你就会发现mediaCodec.dequeueOutputBuffer变了第一个I帧之后，一直返回-1。

坑2：关于mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC)的超时时间是否要传，穿多少？我觉得不能传-1（不能丢帧，一直等），传-1会卡住，要么编码非常卡，传多少合适呢，传11000吧，下过不错。

下面贴一下计算PTS的方法：

[java] view plain copy

/**
* Generates the presentation time for frame N, in microseconds.
*/
private long computePresentationTime(long frameIndex) {
return 132 + frameIndex * 1000000 / m_framerate;
}

这样，大概就说完了，其实也很简单，不过，就是编码的时候一些参数的设置非常重要，例如一款硬件比较差的设备，那么帧率就得设置的低一些，码率也一样。

如果发现编码出来之后，播放很卡，那么请降低帧率，降低码率。

在github上面穿了例子，地址如下：

https://github.com/sszhangpengfei/MediaCodecEncodeH264

相关demo下载：
硬编码：https://github.com/kidloserme/MediaCodecDemo
硬编码、解码：https://github.com/VladimirLichonos/MediaCodec

0 0