Android 利用MediaCodec 实现硬编码 h264

本篇文章记录一下,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
  1. package com.example.mediacodecencode;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import java.util.ArrayList;  
  6. import java.util.concurrent.ArrayBlockingQueue;  
  7. import android.annotation.SuppressLint;  
  8. import android.annotation.TargetApi;  
  9. import android.app.Activity;  
  10. import android.graphics.ImageFormat;  
  11. import android.hardware.Camera;  
  12. import android.hardware.Camera.Parameters;  
  13. import android.hardware.Camera.PreviewCallback;  
  14. import android.media.MediaCodecInfo;  
  15. import android.media.MediaCodecList;  
  16. import android.os.Build;  
  17. import android.os.Bundle;  
  18. import android.util.Log;  
  19. import android.view.SurfaceHolder;  
  20. import android.view.SurfaceView;  
  21.   
  22. public class MainActivity extends Activity  implements SurfaceHolder.Callback,PreviewCallback{  
  23.   
  24.     private SurfaceView surfaceview;  
  25.       
  26.     private SurfaceHolder surfaceHolder;  
  27.       
  28.     private Camera camera;  
  29.       
  30.     private Parameters parameters;  
  31.       
  32.     int width = 1280;  
  33.       
  34.     int height = 720;  
  35.       
  36.     int framerate = 30;  
  37.       
  38.     int biterate = 8500*1000;  
  39.       
  40.     private static int yuvqueuesize = 10;  
  41.       
  42.     public static ArrayBlockingQueue<byte[]> YUVQueue = new ArrayBlockingQueue<byte[]>(yuvqueuesize);   
  43.       
  44.     private AvcEncoder avcCodec;  
  45.       
  46.       
  47.     @Override  
  48.     protected void onCreate(Bundle savedInstanceState) {  
  49.         super.onCreate(savedInstanceState);  
  50.         setContentView(R.layout.activity_main);  
  51.         surfaceview = (SurfaceView)findViewById(R.id.surfaceview);  
  52.         surfaceHolder = surfaceview.getHolder();  
  53.         surfaceHolder.addCallback(this);  
  54.         SupportAvcCodec();  
  55.     }  
  56.       
  57.   
  58.     @Override  
  59.     public void surfaceCreated(SurfaceHolder holder) {  
  60.         camera = getBackCamera();  
  61.         startcamera(camera);  
  62.         avcCodec = new AvcEncoder(width,height,framerate,biterate);  
  63.         avcCodec.StartEncoderThread();  
  64.           
  65.     }  
  66.   
  67.     @Override  
  68.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {  
  69.   
  70.     }  
  71.   
  72.     @Override  
  73.     public void surfaceDestroyed(SurfaceHolder holder) {  
  74.         if (null != camera) {  
  75.             camera.setPreviewCallback(null);  
  76.             camera.stopPreview();  
  77.             camera.release();  
  78.             camera = null;  
  79.             avcCodec.StopThread();  
  80.         }  
  81.     }  
  82.   
  83.   
  84.     @Override  
  85.     public void onPreviewFrame(byte[] data, android.hardware.Camera camera) {  
  86.         // TODO Auto-generated method stub  
  87.         putYUVData(data,data.length);  
  88.     }  
  89.       
  90.     public void putYUVData(byte[] buffer, int length) {  
  91.         if (YUVQueue.size() >= 10) {  
  92.             YUVQueue.poll();  
  93.         }  
  94.         YUVQueue.add(buffer);  
  95.     }  
  96.       
  97.     @SuppressLint("NewApi")  
  98.     private boolean SupportAvcCodec(){  
  99.         if(Build.VERSION.SDK_INT>=18){  
  100.             for(int j = MediaCodecList.getCodecCount() - 1; j >= 0; j--){  
  101.                 MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(j);  
  102.       
  103.                 String[] types = codecInfo.getSupportedTypes();  
  104.                 for (int i = 0; i < types.length; i++) {  
  105.                     if (types[i].equalsIgnoreCase("video/avc")) {  
  106.                         return true;  
  107.                     }  
  108.                 }  
  109.             }  
  110.         }  
  111.         return false;  
  112.     }  
  113.       
  114.   
  115.     private void startcamera(Camera mCamera){  
  116.         if(mCamera != null){  
  117.             try {  
  118.                 mCamera.setPreviewCallback(this);  
  119.                 mCamera.setDisplayOrientation(90);  
  120.                 if(parameters == null){  
  121.                     parameters = mCamera.getParameters();  
  122.                 }  
  123.                 parameters = mCamera.getParameters();  
  124.                 parameters.setPreviewFormat(ImageFormat.NV21);  
  125.                 parameters.setPreviewSize(width, height);  
  126.                 mCamera.setParameters(parameters);  
  127.                 mCamera.setPreviewDisplay(surfaceHolder);  
  128.                 mCamera.startPreview();  
  129.   
  130.             } catch (IOException e) {  
  131.                 e.printStackTrace();  
  132.             }  
  133.         }  
  134.     }  
  135.   
  136.     @TargetApi(9)  
  137.     private Camera getBackCamera() {  
  138.         Camera c = null;  
  139.         try {  
  140.             c = Camera.open(0); // attempt to get a Camera instance  
  141.         } catch (Exception e) {  
  142.             e.printStackTrace();  
  143.         }  
  144.         return c; // returns null if camera is unavailable  
  145.     }  
  146.   
  147.   
  148. }  
   其实没啥说的,很简答的逻辑。不过上面代码有这么几点可以说一下:

   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
  1. @SuppressLint("NewApi")  
  2.     public AvcEncoder(int width, int height, int framerate, int bitrate) {   
  3.           
  4.         m_width  = width;  
  5.         m_height = height;  
  6.         m_framerate = framerate;  
  7.       
  8.         MediaFormat mediaFormat = MediaFormat.createVideoFormat("video/avc", width, height);  
  9.         mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar);      
  10.         mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, width*height*5);  
  11.         mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 30);  
  12.         mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);  
  13.         try {  
  14.             mediaCodec = MediaCodec.createEncoderByType("video/avc");  
  15.         } catch (IOException e) {  
  16.             // TODO Auto-generated catch block  
  17.             e.printStackTrace();  
  18.         }  
  19.         mediaCodec.configure(mediaFormat, nullnull, MediaCodec.CONFIGURE_FLAG_ENCODE);  
  20.         mediaCodec.start();  
  21.         createfile();  
  22.     }  

  需要注意的一点是,对于比特率,其实完全可以这样处理,N*width*height,N可设置为1 2 3或者1 3 5等,来区分低/中/高的码率。
  另外,我选择了YUV420SP作为编码的目标颜色空间,其实YUV420SP就是NV12,咱们CAMERA设置的是NV21,所以需要转一下。转换方法如下:
[java] view plain copy
  1. private void NV21ToNV12(byte[] nv21,byte[] nv12,int width,int height){  
  2.         if(nv21 == null || nv12 == null)return;  
  3.         int framesize = width*height;  
  4.         int i = 0,j = 0;  
  5.         System.arraycopy(nv21, 0, nv12, 0, framesize);  
  6.         for(i = 0; i < framesize; i++){  
  7.             nv12[i] = nv21[i];  
  8.         }  
  9.         for (j = 0; j < framesize/2; j+=2)  
  10.         {  
  11.           nv12[framesize + j-1] = nv21[j+framesize];  
  12.         }  
  13.         for (j = 0; j < framesize/2; j+=2)  
  14.         {  
  15.           nv12[framesize + j] = nv21[j+framesize-1];  
  16.         }  
  17.     }  

下面,就是编码的函数了,我这里把编码放在一个线程里,去轮训YUV队列,如有有数据就编码,具体如下:
[java] view plain copy
  1. public void StartEncoderThread(){  
  2.     Thread EncoderThread = new Thread(new Runnable() {  
  3.   
  4.         @SuppressLint("NewApi")  
  5.         @Override  
  6.         public void run() {  
  7.             isRuning = true;  
  8.             byte[] input = null;  
  9.             long pts =  0;  
  10.             long generateIndex = 0;  
  11.   
  12.             while (isRuning) {  
  13.                 if (MainActivity.YUVQueue.size() >0){  
  14.                     input = MainActivity.YUVQueue.poll();  
  15.                     byte[] yuv420sp = new byte[m_width*m_height*3/2];  
  16.                     NV21ToNV12(input,yuv420sp,m_width,m_height);  
  17.                     input = yuv420sp;  
  18.                 }  
  19.                 if (input != null) {  
  20.                     try {  
  21.                         long startMs = System.currentTimeMillis();  
  22.                         ByteBuffer[] inputBuffers = mediaCodec.getInputBuffers();  
  23.                         ByteBuffer[] outputBuffers = mediaCodec.getOutputBuffers();  
  24.                         int inputBufferIndex = mediaCodec.dequeueInputBuffer(-1);  
  25.                         if (inputBufferIndex >= 0) {  
  26.                             pts = computePresentationTime(generateIndex);  
  27.                             ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];  
  28.                             inputBuffer.clear();  
  29.                             inputBuffer.put(input);  
  30.                         mediaCodec.queueInputBuffer(inputBufferIndex, 0, input.length, pts, 0);  
  31.                             generateIndex += 1;  
  32.                         }  
  33.                           
  34.                 MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();  
  35.                 int outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);  
  36.                    while (outputBufferIndex >= 0) {  
  37.             //Log.i("AvcEncoder", "Get H264 Buffer Success! flag = "+bufferInfo.flags+",pts = "+bufferInfo.presentationTimeUs+"");  
  38.                             ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];  
  39.                             byte[] outData = new byte[bufferInfo.size];  
  40.                             outputBuffer.get(outData);  
  41.                             if(bufferInfo.flags == 2){  
  42.                                 configbyte = new byte[bufferInfo.size];  
  43.                                 configbyte = outData;  
  44.                             }else if(bufferInfo.flags == 1){  
  45.                 byte[] keyframe = new byte[bufferInfo.size + configbyte.length];  
  46.                     System.arraycopy(configbyte, 0, keyframe, 0, configbyte.length);  
  47.                     System.arraycopy(outData, 0, keyframe, configbyte.length, outData.length);  
  48.                                   
  49.                                 outputStream.write(keyframe, 0, keyframe.length);  
  50.                             }else{  
  51.                                 outputStream.write(outData, 0, outData.length);  
  52.                             }  
  53.   
  54.                             mediaCodec.releaseOutputBuffer(outputBufferIndex, false);  
  55.                             outputBufferIndex = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);  
  56.                         }  
  57.   
  58.                     } catch (Throwable t) {  
  59.                         t.printStackTrace();  
  60.                     }  
  61.                 } else {  
  62.                     try {  
  63.                         Thread.sleep(500);  
  64.                     } catch (InterruptedException e) {  
  65.                         e.printStackTrace();  
  66.                     }  
  67.                 }  
  68.             }  
  69.         }  
  70.     });  
  71.     EncoderThread.start();  
  72.       
  73. }  
需要注意的有两点,其实也是两个坑:

坑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
  1. /** 
  2.   * Generates the presentation time for frame N, in microseconds. 
  3.   */  
  4.  private long computePresentationTime(long frameIndex) {  
  5.      return 132 + frameIndex * 1000000 / m_framerate;  
  6.  }  

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

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

在github上面穿了例子,地址如下:
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页