Android硬編解碼介面MediaCodec使用完全解析（一）
阿新 • • 發佈：2019-01-22
由於4月初要離職了，在找新工作，發現很多企業的招聘資訊都有“附上自己的技術部落格可以加分”類似的說明，正好最後的這段時間會比較閒，所以打算整理一下以前記錄的一些筆記發上來，也算是回顧一下。由於這些筆記或多或少的參考了其他資料，所以本人不擁有其版權，可以隨便轉載，能註明出處最好，不註明也無所謂。順便求個Android開發的職位，座標深圳，郵箱[email protected]。
0、本文概述
MediaCodec是anroid api 16以後開發的硬編解碼介面，英文文件參照這個連結，中文翻譯可以參考這個連結。本文主要記錄的是如何使用MediaCodec對視訊進行編解碼，最後會以例項的方式展示如何將Camera預覽資料編碼成H264，再把編碼後的h264解碼並且顯示在SurfaceView中。本例不涉及音訊的編解碼。
1、MediaCodec編碼視訊
使用MediaCodec實現視訊編碼的步驟如下：
1.初始化MediaCodec，方法有兩種，分別是通過名稱和型別來建立，對應的方法為：
MediaCodec createByCodecName (String name);
MediaCodec createDecoderByType (String type);具體可用的name和type參考文件即可。這裡我們通過後者來初始化一個視訊編碼器。
mMC = MediaCodec.createDecoderByType(MIME_TYPE);2.配置MediaCodec，這一步需要配置的是MediaFormat，這個類包含了位元率、幀率、關鍵幀間隔時間等，其中位元率如果太低就會造成類似馬賽克的現象。
mMF = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
mMF.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
mMF.setInteger(MediaFormat.KEY_FRAME_RATE, framerate);
if (mPrimeColorFormat != 0){
mMF.setInteger(MediaFormat.KEY_COLOR_FORMAT, mPrimeColorFormat);
}
mMF.setInteger(MediaFormat.KEY 其中mPrimeColorFormat為本機支援的顏色空間。一般是yuv420p或者yuv420sp，Camera預覽格式一般是yv12或者NV21，所以在編碼之前需要進行格式轉換，例項可參照文末程式碼。程式碼是最好的老師嘛。
3.開啟編碼器，獲取輸入輸出緩衝區
mMC.start();
mInputBuffers = mMC.getInputBuffers();
mOutputBuffers = mMC.getOutputBuffers();4.輸入資料，過程可以分為以下幾個小步：
1）獲取可使用緩衝區位置得到索引
int inputbufferindex = mMC.dequeueInputBuffer(BUFFER_TIMEOUT);如果存在可用的緩衝區，此方法會返回其位置索引，否則返回-1，引數為超時時間，單位是毫秒，如果此引數是0，則立即返回，如果引數小於0，則無限等待直到有可使用的緩衝區，如果引數大於0，則等待時間為傳入的毫秒值。
2）傳入原始資料
ByteBuffer inputBuffer = mInputBuffers[inputbufferindex];
inputBuffer.clear();//清除原來的內容以接收新的內容
inputBuffer.put(bytes, 0, len);//len是傳進來的有效資料長度
mMC.queueInputBuffer(inputbufferindex, 0, len, timestamp, 0);此緩衝區一旦使用，只有在dequeueInputBuffer返回其索引位置才代表它可以再次使用。
5.獲取其輸出資料，獲取輸入原始資料和獲取輸出資料最好是非同步進行，因為輸入一幀資料不代表編碼器馬上就會輸出對應的編碼資料，可能輸入好幾幀才會輸出一幀。獲取輸出資料的步驟與輸入資料的步驟相似：
1）獲取可用的輸出緩衝區
int outputbufferindex = mMC.dequeueOutputBuffer(mBI, BUFFER_TIMEOUT);其中引數一是一個BufferInfo型別的例項，引數二為超時時間，負數代表無限等待（可見，不要在主執行緒進行操作）。
2）獲取輸出資料
mOutputBuffers[outputbufferindex].get(bytes, 0, mBI.size);3）釋放緩衝區
mMC.releaseOutputBuffer(outputbufferindex, false);2、MediaCodec解碼視訊
解碼視訊的步驟跟編碼的類似，配置不一樣：
1.例項化解碼器
mMC = MediaCodec.createDecoderByType(MIME_TYPE);2.配置解碼器，此處需要配置用於顯示影象的Surface、MediaFormat包含視訊的pps和sps（包含在編碼出來的第一幀資料）
int[] width = new int[1];
int[] height = new int[1];
AvcUtils.parseSPS(sps, width, height);//從sps中解析出視訊寬高
mMF = MediaFormat.createVideoFormat(MIME_TYPE, width[0], height[0]);
mMF.setByteBuffer("csd-0", ByteBuffer.wrap(sps));
mMF.setByteBuffer("csd-1", ByteBuffer.wrap(pps));
mMF.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, width[0] * height[0]);
mMC.configure(mMF, surface, null, 0);3.開啟編碼器並獲取輸入輸出緩衝區
mMC.start();
mInputBuffers = mMC.getInputBuffers();
mOutputBuffers = mMC.getOutputBuffers();4.輸入資料
1）獲取可用的輸入緩衝區
int inputbufferindex = mMC.dequeueInputBuffer(BUFFER_TIMEOUT);返回值為可用緩衝區的索引
ByteBuffer inputBuffer = mInputBuffers[inputbufferindex];
inputBuffer.clear();2）然後輸入資料
inputBuffer.put(bytes, 0, len);
mMC.queueInputBuffer(inputbufferindex, 0, len, timestamp, 0);5.獲取輸出資料，這一步與4同樣應該非同步進行，其具體步驟與上面解碼的基本相同，在釋放緩衝區的時候需要注意第二個引數設定為true，表示解碼顯示在Surface上
mMC.releaseOutputBuffer(outputbufferindex, true);3、編解碼例項
下面是一個MediaCodec編解碼例項，此例子Camera預覽資料（yv12）編碼成H264，再把編碼後的h264解碼並且顯示在SurfaceView中。
3.1佈局檔案
佈局檔案非常簡單，兩個SurfaceView分別用於顯示編解碼的影象，兩個按鈕控制開始和停止，一個TextView用於顯示捕捉幀率。佈局檔案程式碼就不展示了，介面如下
3.2編碼器類Encoder
package com.example.mediacodecpro;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaFormat;
import android.util.Log;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Created by chuibai on 2017/3/10.<br />
*/
public class Encoder {
public static final int TRY_AGAIN_LATER = -1;
public static final int BUFFER_OK = 0;
public static final int BUFFER_TOO_SMALL = 1;
public static final int OUTPUT_UPDATE = 2;
private int format = 0;
private final String MIME_TYPE = "video/avc";
private MediaCodec mMC = null;
private MediaFormat mMF;
private ByteBuffer[] inputBuffers;
private ByteBuffer[] outputBuffers;
private long BUFFER_TIMEOUT = 0;
private MediaCodec.BufferInfo mBI;
/**
* 初始化編碼器
* @throws IOException 建立編碼器失敗會丟擲異常
*/
public void init() throws IOException {
mMC = MediaCodec.createEncoderByType(MIME_TYPE);
format = MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar;
mBI = new MediaCodec.BufferInfo();
}
/**
* 配置編碼器，需要配置顏色、幀率、位元率以及視訊寬高
* @param width 視訊的寬
* @param height 視訊的高
* @param bitrate 視訊位元率
* @param framerate 視訊幀率
*/
public void configure(int width,int height,int bitrate,int framerate){
if(mMF == null){
mMF = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
mMF.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
mMF.setInteger(MediaFormat.KEY_FRAME_RATE, framerate);
if (format != 0){
mMF.setInteger(MediaFormat.KEY_COLOR_FORMAT, format);
}
mMF.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, -1); //關鍵幀間隔時間 單位s
}
mMC.configure(mMF,null,null,MediaCodec.CONFIGURE_FLAG_ENCODE);
}
/**
* 開啟編碼器，獲取輸入輸出緩衝區
*/
public void start(){
mMC.start();
inputBuffers = mMC.getInputBuffers();
outputBuffers = mMC.getOutputBuffers();
}
/**
* 向編碼器輸入資料，此處要求輸入YUV420P的資料
* @param data YUV資料
* @param len 資料長度
* @param timestamp 時間戳
* @return
*/
public int input(byte[] data,int len,long timestamp){
int index = mMC.dequeueInputBuffer(BUFFER_TIMEOUT);
Log.e("...","" + index);
if(index >= 0){
ByteBuffer inputBuffer = inputBuffers[index];
inputBuffer.clear();
if(inputBuffer.capacity() < len){
mMC.queueInputBuffer(index, 0, 0, timestamp, 0);
return BUFFER_TOO_SMALL;
}
inputBuffer.put(data,0,len);
mMC.queueInputBuffer(index,0,len,timestamp,0);
}else{
return index;
}
return BUFFER_OK;
}
/**
* 輸出編碼後的資料
* @param data 資料
* @param len 有效資料長度
* @param ts 時間戳
* @return
*/
public int output(/*out*/byte[] data,/* out */int[] len,/* out */long[] ts){
int i = mMC.dequeueOutputBuffer(mBI, BUFFER_TIMEOUT);
if(i >= 0){
if(mBI.size > data.length) return BUFFER_TOO_SMALL;
outputBuffers[i].position(mBI.offset);
outputBuffers[i].limit(mBI.offset + mBI.size);
outputBuffers[i].get(data, 0, mBI.size);
len[0] = mBI.size ;
ts[0] = mBI.presentationTimeUs;
mMC.releaseOutputBuffer(i, false);
} else if (i == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
outputBuffers = mMC.getOutputBuffers();
return OUTPUT_UPDATE;
} else if (i == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
mMF = mMC.getOutputFormat();
return OUTPUT_UPDATE;
} else if (i == MediaCodec.INFO_TRY_AGAIN_LATER) {
return TRY_AGAIN_LATER;
}
return BUFFER_OK;
}
public void release(){
mMC.stop();
mMC.release();
mMC = null;
outputBuffers = null;
inputBuffers = null;
}
public void flush() {
mMC.flush();
}
}3.3解碼器類Decoder
package com.example.mediacodecpro;
import android.media.MediaCodec;
import android.media.MediaFormat;
import android.view.Surface;
import java.io.IOException;
import java.nio.ByteBuffer;
/**
* Created by chuibai on 2017/3/10.<br />
*/
public class Decoder {
public static final int TRY_AGAIN_LATER = -1;
public static final int BUFFER_OK = 0;
public static final int BUFFER_TOO_SMALL = 1;
public static final int OUTPUT_UPDATE = 2;
private final String MIME_TYPE = "video/avc";
private MediaCodec mMC = null;
private MediaFormat mMF;
private long BUFFER_TIMEOUT = 0;
private MediaCodec.BufferInfo mBI;
private ByteBuffer[] mInputBuffers;
private ByteBuffer[] mOutputBuffers;
/**
* 初始化編碼器
* @throws IOException 建立編碼器失敗會丟擲異常
*/
public void init() throws IOException {
mMC = MediaCodec.createDecoderByType(MIME_TYPE);
mBI = new MediaCodec.BufferInfo();
}
/**
* 配置解碼器
* @param sps 用於配置的sps引數
* @param pps 用於配置的pps引數
* @param surface 用於解碼顯示的Surface
*/
public void configure(byte[] sps, byte[] pps, Surface surface){
int[] width = new int[1];
int[] height = new int[1];
AvcUtils.parseSPS(sps, width, height);//從sps中解析出視訊寬高
mMF = MediaFormat.createVideoFormat(MIME_TYPE, width[0], height[0]);
mMF.setByteBuffer("csd-0", ByteBuffer.wrap(sps));
mMF.setByteBuffer("csd-1", ByteBuffer.wrap(pps));
mMF.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, width[0] * height[0]);
mMC.configure(mMF, surface, null, 0);
}
/**
* 開啟解碼器，獲取輸入輸出緩衝區
*/
public void start(){
mMC.start();
mInputBuffers = mMC.getInputBuffers();
mOutputBuffers = mMC.getOutputBuffers();
}
/**
* 輸入資料
* @param data 輸入的資料
* @param len 資料有效長度
* @param timestamp 時間戳
* @return 成功則返回{@link #BUFFER_OK} 否則返回{@link #TRY_AGAIN_LATER}
*/
public int input(byte[] data,int len,long timestamp){
int i = mMC.dequeueInputBuffer(BUFFER_TIMEOUT);
if(i >= 0){
ByteBuffer inputBuffer = mInputBuffers[i];
inputBuffer.clear();
inputBuffer.put(data, 0, len);
mMC.queueInputBuffer(i, 0, len, timestamp, 0);
}else {
return TRY_AGAIN_LATER;
}
return BUFFER_OK;
}
public int output(byte[] data,int[] len,long[] ts){
int i = mMC.dequeueOutputBuffer(mBI, BUFFER_TIMEOUT);
if(i >= 0){
if (mOutputBuffers[i] != null)
{
mOutputBuffers[i].position(mBI.offset);
mOutputBuffers[i].limit(mBI.offset + mBI.size);
if (data != null)
mOutputBuffers[i].get(data, 0, mBI.size);
len[0] = mBI.size;
ts[0] = mBI.presentationTimeUs;
}
mMC.releaseOutputBuffer(i, true);
}else{
return TRY_AGAIN_LATER;
}
return BUFFER_OK;
}
public void flush(){
mMC.flush();
}
public void release() {
flush();
mMC.stop();
mMC.release();
mMC = null;
mInputBuffers = null;
mOutputBuffers = null;
}
}3.4MainAcitivity
package com.example.mediacodecpro;
import android.content.pm.ActivityInfo;
import android.graphics.ImageFormat;
import android.hardware.Camera;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.SurfaceView;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import java.io.IOException;
import java.io.OutputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import butterknife.BindView;
import butterknife.ButterKnife;
public class MainActivity extends AppCompatActivity implements View.OnClickListener, Camera.PreviewCallback {
@BindView(R.id.surfaceView_encode)
SurfaceView surfaceViewEncode;
@BindView(R.id.surfaceView_decode)
SurfaceView surfaceViewDecode;
@BindView(R.id.btnStart)
Button btnStart;
@BindView(R.id.btnStop)
Button btnStop;
@BindView(R.id.capture)
TextView capture;
private int width;
private int height;
private int bitrate;
private int framerate;
private int captureFrame;
private Camera mCamera;
private Queue<PreviewBufferInfo> mPreviewBuffers_clean;
private Queue<PreviewBufferInfo> mPreviewBuffers_dirty;
private Queue<PreviewBufferInfo> mDecodeBuffers_clean;
private Queue<PreviewBufferInfo> mDecodeBuffers_dirty;
private int PREVIEW_POOL_CAPACITY = 5;
private int format;
private int DECODE_UNI_SIZE = 1024 * 1024;
private byte[] mAvcBuf = new byte[1024 * 1024];
private final int MSG_ENCODE = 0;
private final int MSG_DECODE = 1;
private String TAG = "MainActivity";
private long mLastTestTick = 0;
private Object mAvcEncLock;
private Object mDecEncLock;
private Decoder mDecoder;
private Handler codecHandler;
private byte[] mRawData;
private Encoder mEncoder;
private CodecThread codecThread;
private DatagramSocket socket;
private DatagramPacket packet;
private byte[] sps_pps;
private byte[] mPacketBuf = new byte[1024 * 1024];
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ButterKnife.bind(this);
//初始化引數
initParams();
//設定監聽事件
btnStart.setOnClickListener(this);
btnStop.setOnClickListener(this);
}
/**
* 初始化引數，包括幀率、顏色、位元率，視訊寬高等
*/
private void initParams() {
width = 352;
height = 288;
bitrate = 1500000;
framerate = 30;
captureFrame = 0;
format = ImageFormat.YV12;
mAvcEncLock = new Object();
mDecEncLock = new Object();
}
@Override
protected void onResume() {
if (getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) {
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
}
super.onResume();
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btnStart:
mCamera = Camera.open(0);
initQueues();
initEncoder();
initCodecThread();
startPreview();
break;
case R.id.btnStop:
releaseCodecThread();
releseEncoderAndDecoder();
releaseCamera();
releaseQueue();
break;
}
}
/**
* 釋放佇列資源
*/
private void releaseQueue() {
if (mPreviewBuffers_clean != null){
mPreviewBuffers_clean.clear();
mPreviewBuffers_clean = null;
}
if (mPreviewBuffers_dirty != null){
mPreviewBuffers_dirty.clear();
mPreviewBuffers_dirty = null;
}
if (mDecodeBuffers_clean != null){
mDecodeBuffers_clean.clear();
mDecodeBuffers_clean = null;
}
if (mDecodeBuffers_dirty != null){
mDecodeBuffers_dirty.clear();
mDecodeBuffers_dirty = null;
}
}
/**
* 釋放攝像頭資源
*/
private void releaseCamera() {
if(mCamera != null){
mCamera.setPreviewCallbackWithBuffer(null);
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
}
private void releseEncoderAndDecoder() {
if(mEncoder != null){
mEncoder.flush();
mEncoder.release();
mEncoder = null;
}
if(mDecoder != null){
mDecoder.release();
mDecoder = null;
}
}
private void releaseCodecThread() {
codecHandler.getLooper().quit();
codecHandler = null;
codecThread = null;
}
private void initCodecThread() {
codecThread = new CodecThread();
codecThread.start();
}
/**
* 開啟預覽
*/
private void startPreview() {
Camera.Parameters parameters = mCamera.getParameters();
parameters.setPreviewFormat(format);
parameters.setPreviewFrameRate(framerate);
parameters.setPreviewSize(width,height);
mCamera.setParameters(parameters);
try {
mCamera.setPreviewDisplay(surfaceViewEncode.getHolder());
} catch (IOException e) {
e.printStackTrace();
}
mCamera.setPreviewCallbackWithBuffer(this);
mCamera.startPreview();
}
@Override
public void onPreviewFrame(byte[] data, Camera camera) {
/** 預覽的data為null */
if(data == null) {
Log.e(TAG,"預覽的data為null");
return;
}
long curTick = System.currentTimeMillis();
if (mLastTestTick == 0) {
mLastTestTick = curTick;
}
if (curTick > mLastTestTick + 1000) {
setCaptureFPSTextView(captureFrame);
captureFrame = 0;
mLastTestTick = curTick;
} else
captureFrame++;
synchronized(mAvcEncLock) {
PreviewBufferInfo info = mPreviewBuffers_clean.poll(); //remove the head of queue
info.buffer = data;
info.size = getPreviewBufferSize(width, height, format);
info.timestamp = System.currentTimeMillis();
mPreviewBuffers_dirty.add(info);
if(mDecoder == null){
codecHandler.sendEmptyMessage(MSG_ENCODE);
}
}
}
private void setCaptureFPSTextView(int captureFrame) {
capture.setText("當前幀率：" + captureFrame);
}
private void initEncoder() {
mEncoder = new Encoder();
try {
mEncoder.init();
mEncoder.configure(width,height,bitrate,framerate);
mEncoder.start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 初始化各種佇列
*/
private void initQueues() {
if (mPreviewBuffers_clean == null)
mPreviewBuffers_clean = new LinkedList<>();
if (mPreviewBuffers_dirty == null)
mPreviewBuffers_dirty = new LinkedList<>();
int size = getPreviewBufferSize(width, height, format);
for (int i = 0; i < PREVIEW_POOL_CAPACITY; i++) {
byte[] mem = new byte[size];
mCamera.addCallbackBuffer(mem); //ByteBuffer.array is a reference, not a copy
PreviewBufferInfo info = new PreviewBufferInfo();
info.buffer = null;
info.size = 0;
info.timestamp = 0;
mPreviewBuffers_clean.add(info);
}
if (mDecodeBuffers_clean == null)
mDecodeBuffers_clean = new LinkedList<>();
if (mDecodeBuffers_dirty == null)
mDecodeBuffers_dirty = new LinkedList<>();
for (int i = 0; i < PREVIEW_POOL_CAPACITY; i++) {
PreviewBufferInfo info = new PreviewBufferInfo();
info.buffer = new byte[DECODE_UNI_SIZE];
info.size = 0;
info.timestamp = 0;
mDecodeBuffers_clean.add(info);
}
}
/**
* 獲取預覽buffer的大小
* @param width 預覽寬
* @param height 預覽高
* @param format 預覽顏色格式
* @return 預覽buffer的大小
*/
private int getPreviewBufferSize(int width, int height, int format) {
int size = 0;
switch (format) {
case ImageFormat.YV12: {
int yStride = (int) Math.ceil(width / 16.0) * 16;
int uvStride = (int) Math.ceil((yStride / 2) / 16.0) * 16;
int ySize = yStride * height;
int uvSize = uvStride * height / 2;
size = ySize + uvSize * 2;
}
break;
case ImageFormat.NV21: {
float bytesPerPix = (float) ImageFormat.getBitsPerPixel(format) / 8;
size = (int) (width * height * bytesPerPix);
}
break;
}
return size;
}
private void swapYV12toI420(byte[] yv12bytes, byte[] i420bytes, int width, int height) {
System.arraycopy(yv12bytes, 0, i420bytes, 0, width * height);
System.arraycopy(yv12bytes, width * height + width * height / 4, i420bytes, width * height, width * height / 4);
System.arraycopy(yv12bytes, width * height, i420bytes, width * height + width * height / 4, width * height / 4);
}
private class PreviewBufferInfo {
public byte[] buffer;
public int size;
public long timestamp;
}
private class CodecThread extends Thread {
@Override
public void run() {
Looper.prepare();
codecHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_ENCODE:
int res = Encoder.BUFFER_OK;
synchronized (mAvcEncLock) {
if (mPreviewBuffers_dirty != null && mPreviewBuffers_clean != null) {
Iterator<PreviewBufferInfo> ite = mPreviewBuffers_dirty.iterator();
while (ite.hasNext()) {
PreviewBufferInfo info = ite.next();
byte[] data = info.buffer;
int data_size = info.size;
if (format == ImageFormat.YV12) {
if (mRawData == null || mRawData.length < data_size) {
mRawData = new byte[data_size];
}
swapYV12toI420(data, mRawData, width, height);
} else {
Log.e(TAG, "preview size MUST be YV12, cur is " + format);
mRawData = data;
}
res = mEncoder.input(mRawData, data_size, info.timestamp);
if (res != Encoder.BUFFER_OK) {
// Log.e(TAG, "mEncoder.input, maybe wrong:" + res);
break; //the rest buffers shouldn't go into encoder, if the previous one get problem
} else {
ite.remove();
mPreviewBuffers_clean.add(info);
if (mCamera != null) {
mCamera.addCallbackBuffer(data);
}
}
}
}
}
while (res == Encoder.BUFFER_OK) {
int[] len = new int[1];
long[] ts = new long[1];
synchronized (mAvcEncLock) {
res = mEncoder.output(mAvcBuf, len, ts);
}
if (res == Encoder.BUFFER_OK) {
//傳送h264
if(sps_pps != null){
send(len[0]);
}
if (mDecodeBuffers_clean != null && mDecodeBuffers_dirty != null) {
synchronized (mAvcEncLock) {
Iterator<PreviewBufferInfo> ite = mDecodeBuffers_clean.iterator();
if (ite.hasNext()) {
PreviewBufferInfo bufferInfo = ite.next();
if (bufferInfo.buffer.length >= len[0]) {
bufferInfo.timestamp = ts[0];
bufferInfo.size = len[0];
System.arraycopy(mAvcBuf, 0, bufferInfo.buffer, 0, len[0]);
ite.remove();
mDecodeBuffers_dirty.add(bufferInfo);
} else {
Log.e(TAG, "decoder uni buffer too small, need " + len[0] + " but has " + bufferInfo.buffer.length);
}
}
}
initDecoder(len);
}
}
}
codecHandler.sendEmptyMessageDelayed(MSG_ENCODE, 30);
break;
case MSG_DECODE:
synchronized (mDecEncLock) {
int result = Decoder.BUFFER_OK;
//STEP 1: handle input buffer
if (mDecodeBuffers_dirty != null && mDecodeBuffers_clean != null) {
Iterator<PreviewBufferInfo> ite = mDecodeBuffers_dirty.iterator();
while (ite.hasNext()) {
PreviewBufferInfo info = ite.next();
result = mDecoder.input(info.buffer, info.size, info.timestamp);
if (result != Decoder.BUFFER_OK) {
break; //the rest buffers shouldn't go into encoder, if the previous one get problem
} else {
ite.remove();
mDecodeBuffers_clean.add(info);
}
}
}
int[] len = new int[1];
long[] ts = new long[1];
while (result == Decoder.BUFFER_OK) {
result = mDecoder.output(null, len, ts);
}
}
codecHandler.sendEmptyMessageDelayed(MSG_DECODE, 30);
break;
}
}
};
Looper.loop();
}
}
private void send(int len) {
try {
if(socket == null) socket = new DatagramSocket();
if(packet == null){
packet = new DatagramPacket(mPacketBuf,0,sps_pps.length + len);
packet.setAddress(InetAddress.getByName("192.168.43.1"));
packet.setPort(5006);
}
if(mAvcBuf[4] == 0x65){
System.arraycopy(sps_pps,0,mPacketBuf,0,sps_pps.length);
System.arraycopy(mAvcBuf,0,mPacketBuf,sps_pps.length,len);
len += sps_pps.length;
}else{
System.arraycopy(mAvcBuf,0,mPacketBuf,0,len);
}
packet.setLength(len);
socket.send(packet);
} catch (IOException e) {
e.printStackTrace();
}
}
private void initDecoder(int[] len) {
if(sps_pps == null){
sps_pps = new byte[len[0]];
System.arraycopy(mAvcBuf,0,sps_pps,0,len[0]);
}
if(mDecoder == null){
mDecoder = new Decoder();
try {
mDecoder.init();
} catch (IOException e) {
e.printStackTrace();
}
byte[] sps_nal = null;
int sps_len = 0;
byte[] pps_nal = null;
int pps_len = 0;
ByteBuffer byteb = ByteBuffer.wrap(mAvcBuf, 0, len[0]);
//SPS
if (true == AvcUtils.goToPrefix(byteb)) {
int sps_position = 0;
int pps_position = 0;
int nal_type = AvcUtils.getNalType(byteb);
if (AvcUtils.NAL_TYPE_SPS == nal_type) {
Log.d(TAG, "OutputAvcBuffer, AVC NAL type: SPS");
sps_position = byteb.position() - AvcUtils.START_PREFIX_LENGTH - AvcUtils.NAL_UNIT_HEADER_LENGTH;
//PPS
if (true == AvcUtils.goToPrefix(byteb)) {
nal_type = AvcUtils.getNalType(byteb);
if (AvcUtils.NAL_TYPE_PPS == nal_type) {
pps_position = byteb.position() - AvcUtils.START_PREFIX_LENGTH - AvcUtils.NAL_UNIT_HEADER_LENGTH;
sps_len = pps_position - sps_position;
sps_nal = new byte[sps_len];
int cur_pos = byteb.position();
byteb.position(sps_position);
byteb.get(sps_nal, 0, sps_len);
byteb.position(cur_pos);
//slice
if (true == AvcUtils.goToPrefix(byteb)) {
nal_type = AvcUtils.getNalType(byteb);
int pps_end_position = byteb.position() - AvcUtils.START_PREFIX_LENGTH - AvcUtils.NAL_UNIT_HEADER_LENGTH;
pps_len = pps_end_position - pps_position;
} else {
pps_len = byteb.position() - pps_position;
//pps_len = byteb.limit() - pps_position + 1;
}
if (pps_len > 0) {
pps_nal = new byte[pps_len];
cur_pos = byteb.position();
byteb.position(pps_position);
byteb.get(pps_nal, 0, pps_len);
byteb.position(cur_pos);
}
} else {
//Log.d(log_tag, "OutputAvcBuffer, AVC NAL type: "+nal_type);
throw new UnsupportedOperationException(
相關推薦
Android硬編解碼介面MediaCodec使用完全解析（一）
由於4月初要離職了，在找新工作，發現很多企業的招聘資訊都有“附上自己的技術部落格可以加分”類似的說明，正好最後的這段時間會比較閒，所以打算整理一下以前記錄的一些筆記發上來，也算是回顧一下。由於這些筆記或多或少的參考了其他資料，所以本人不擁有其版權，可以隨便
Android 開源框架Universal-Image-Loader完全解析（一）--- 基本介紹及使用
大家好！差不多兩個來月沒有寫文章了，前段時間也是在忙換工作的事，準備筆試面試什麼的事情，現在新工作找好了，新工作自己也比較滿意，唯一遺憾的就是自己要去一個新的城市，新的環境新的開始，希望自己能儘快的適應新環境，現在在準備交接的事情，自己也有一些時間了，所以就繼續給大家分享And
【Android自助餐】Handler訊息機制完全解析（二）MessageQueue的佇列管理
Android自助餐Handler訊息機制完全解析（二）MessageQueue的佇列管理
Android自助餐Handler訊息機制完全解析二MessageQueue的佇列管理
新增到訊息佇列enqueueMessage
從佇
【Android自助餐】Handler訊息機制完全解析（五）鳥瞰與總結
Android自助餐Handler訊息機制完全解析（五）鳥瞰與總結
Android自助餐Handler訊息機制完全解析五鳥瞰與總結
Message
MessageQueue
Handler
Looper
【Android自助餐】Handler訊息機制完全解析（四）Looper解析
Android自助餐Handler訊息機制完全解析（四）Looper解析
Android自助餐Handler訊息機制完全解析四Looper解析
Looper
初始化prepare
提供loope
Android 網路通訊框架Volley完全解析（一）
Volley簡介及Request基本用法
Google
I/O 2013上，Volley釋出了。Volley是Android平臺上的網路通訊庫，能使網路通訊更快，更簡單，更健壯。這是Volley名
Android 開源框架Universal-Image-Loader完全解析（二）--- 圖片快取策略詳解
本篇文章繼續為大家介紹Universal-Image-Loader這個開源的圖片載入框架，介紹的是圖片快取策略方面的，如果大家對這個開源框架的使用還不瞭解，大家可以看看我之前寫的一篇文章Android 開源框架Universal-Image-Loader完全解析（一）---
Android N App分屏模式完全解析（下）
在上篇中，介紹了什麼是App分屏模式，以及如何設定我們的App來進入分屏模式。這次我們看一下，作為開發者，我們應該如何讓自己的App進入分屏模式，當App進入分屏模式時，我們注意哪些問題。
簡單地說，我認為除了保證分屏時App功能、效能正常以外，我們需要重點學習 如何在分屏模式下開啟新的Activity 以
Android網路框架：OKHttp原始碼簡單解析（一）
這是第一次解析原始碼並把它寫出來，在之前，我一直以為只要會用別人的輪子就好，做出實際的效果就行，對看原始碼對自己的能力提升不以為然。後來偶然聽到一句話：看別人的DEMO，你就可以會用輪子，但是要想用好輪子，還是得看原始碼。我覺得看原始碼有兩個方面的好處：
1
Glide完全解析（一）初步使用完全教程教程
一、背景
現在Android上的圖片載入框架非常成熟，從最早的老牌圖片載入框架UniversalImageLoader，到後來Google推出的Volley，再到後來的新興軍Glide和Picasso，當然還有Facebook的Fresco。每一個都非常穩
Java上傳下載完全解析（一）
在Java Web開發中，經常會用到上傳與下載檔案，典型的案例即為伺服器獲取上傳的檔案，將其儲存至本地，並獲取其下載的檔案url，客戶端在獲取下載的url後，在伺服器進行下載。下面我們就來說一下Java中檔案的上傳。
一、設定CommonsMultipartReso
Android FM模組學習之四原始碼解析（一）
前一章我們瞭解了FM手動調頻，接下來我們要分析FM模組用到的原始碼。此原始碼是基於高通平臺的，別的平臺都大同小異，只不過是平臺自己作了些小改動而已。
首先要看的當然是主activity,
Android source code(7.1) 廣播機制解析（一）
廣播註冊的全部大致過程
無序廣播發送的全部大致過程
一、廣播註冊
關於廣播的註冊，從程式碼的角度進行跟蹤註冊的流程，主要用到ContextImp.java、ActivityManagerNative.java、ActivityManagerService
Android自帶硬編解碼器MediaCodec使用必看
一、背景隨著Android系統手機效能的不斷提升，現階段大部分手機都自帶GPU（承擔圖形顯示的專門硬體），大幅度提高手機顯示效能，在視訊顯示、遊戲畫面重新整理，和高分辨影象顯示方面必須使用GPU。GOOGLE在API 16 -4.1版本中增加MediaCodec類，專用於編解
Android Fragment 真正的完全解析（上）
watermark 展示 near 主界面 ddt comm 講解 超級 pro 版權聲明：本文為博主原創文章，未經博主允許不得轉載。 https://blog.csdn.net/lmj623565791/article/details/37970961
轉載請標明出處：
Android 屬性動畫（Property Animation） 完全解析 （上）【轉】
轉載請標明出處：http://blog.csdn.net/lmj623565791/article/details/38067475
1、概述
Android提供了幾種動畫型別：View Animation 、Drawable Animation 、Property Anima
Android進階——效能優化之程序拉活原理及手段完全解析（二）
引言
上一篇文章Android進階——效能優化之程序保活原理及手段完全解析（一）總結了Android程序和執行緒的相關知識，主要介紹了幾種提升程序優先順序的手段，通常僅僅是提高優先順序只能讓你的程序存活時間久一點，但是真正的被殺死之後就不會自動拉活的，如果你的程
Android安全攻防戰，反編譯與混淆技術完全解析（上）
轉載請註明出處：http://blog.csdn.net/guolin_blog/article/details/49738023
之前一直有猶豫過要不要寫這篇文章，畢竟去反編譯人家的程式並不是什麼值得驕傲的事情。不過單純從技術角度上來講，掌握反編譯功能確實是
Android Fragment 真正的完全解析（下）
上篇部落格中已經介紹了Fragment產生原因，以及一些基本的用法和各種API，如果你還不瞭解，請看：Android Fragment 真正的完全解析（上）。
本篇將介紹上篇部落格提到的：如何管理Fragment回退棧，Fragment如何與Activity互動，Frag
Android 屬性動畫（Property Animation） 完全解析 （上）
目錄(?)[+]
1、概述
Android提供了幾種動畫型別：View Animation 、Drawable Animation 、Property Animation 。View Animation相當簡單，不過只能支援簡單的縮放、平移、旋轉、透明度基本的動畫，