日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Android硬件解碼組件MediaCodec使用教程_Android

作者：lpf_wei ? 更新時間： 2022-12-19 編程語言

1.MediaCodec 是什么

MediaCodec類可以訪問底層媒體編解碼器框架（StageFright 或 OpenMAX），即編解碼組件。是Android 的低層多媒體基礎設施的一部分（通常與MediaExtractor、MediaSync、MediaMuxer、Image、Surface和AudioTrack一起使用），它本身并不具備Codec能力，通過調動底層編解碼組件獲得了Codec的能力。

2.創建MediaCodec的方式

2.1按照格式創建

  • createDecoderByType(String type)：創建解碼器
  • createEncoderByType(String type):創建編碼器

type是數據解析階段的mimeType，如"video/avc"

2.2按照名字創建

createByCodecName(String name)

OMX.google.h264.decoder: 軟解碼

OMX.MTK.VIDEO.DECODER>AVC：硬解碼

3.MediaCode硬件解碼并進行播放實例

    private String mFilePath="/sdcard/DCIM/189017886849403.mp4";
    private DecodeThread mDecodeThread;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
//        setContentView(R.layout.activity_media_codec_decode);
        SurfaceView surfaceView=new SurfaceView(this);
        /*不自己維護緩沖區，等待屏幕的渲染引擎 將內容推送到用戶前面*/
        surfaceView.getHolder().setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        surfaceView.getHolder().addCallback(this);
        setContentView(surfaceView);
    }
  • 定義播放的視頻路徑
  • 定義解碼的線程
  • 創建SurfaceView，并設置Callback
@Override
public void surfaceCreated(@NonNull SurfaceHolder holder) {
}
@Override
public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
    if (mDecodeThread ==null){
        mDecodeThread =new DecodeThread(holder.getSurface());
        mDecodeThread.start();
    }
}
@Override
public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
    if (mDecodeThread !=null){
        mDecodeThread.interrupt();   //停止線程的正確姿勢
    }
}
  • 在SurfaceView的回調函數surfaceChanged 開啟線程
  • 在SurfaceView的回調函數surfaceDestroyed 打斷線程
 private class DecodeThread extends Thread{
        private MediaExtractor mMediaExtractor;
        private MediaCodec mMediaCodec;
        private Surface mSurface;
        /*通過構造方法將surface傳遞進來*/
        public DecodeThread(Surface surface){
            mSurface = surface;
        }
        @Override
        public void run() {
            super.run();
            mMediaExtractor = new MediaExtractor();
            try {
                mMediaExtractor.setDataSource(mFilePath);
            } catch (IOException e) {
                e.printStackTrace();
            }
            int trackCount = mMediaExtractor.getTrackCount();
            //從媒體提取器中拿到了 MIME 以及MediaFormat   通過MIME 創建的硬件解碼器   通過MediaFormat配置的硬件解碼器
            for (int i = 0; i < trackCount; i++) {
                MediaFormat trackFormat = mMediaExtractor.getTrackFormat(i);
                Log.d("lpf","trackFormat is "+trackFormat);
                String mime=trackFormat.getString(MediaFormat.KEY_MIME);
                Log.d("lpf","mime is "+mime);
                if (mime.startsWith("video/")){
                    mMediaExtractor.selectTrack(i);
                    try {
                        mMediaCodec=MediaCodec.createDecoderByType(mime);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    //這樣配置之后，解碼之后的數據就會 直接顯示在mSurface 上邊  這里是核心點
                    mMediaCodec.configure(trackFormat,mSurface,null,0);
                    break;
                }
            }
            if (mMediaCodec == null){
                return;
            }
            //調用Start 如果沒有異常信息，表示成功構建組件
            mMediaCodec.start();
            ByteBuffer[] inputBuffers = mMediaCodec.getInputBuffers();
            ByteBuffer[] outputBuffers = mMediaCodec.getOutputBuffers();
            //每個Buffer的元數據包括具體的范圍以及偏移大小，以及數據中心相關解碼的buffer
            MediaCodec.BufferInfo info=new MediaCodec.BufferInfo();
            boolean isEOF=false;
            long startMs=System.currentTimeMillis();
            while (!Thread.interrupted()){//只要線程不中斷
                if (!isEOF){
                    //返回有效的buffer 索引，如果沒有相關的Buffer可用，就返回-1
                    //傳入的timeoutUs為0表示立即返回
//                    如果數據的buffer可用，將無限期等待timeUs的單位是納秒
                    int index =mMediaCodec.dequeueInputBuffer(10000);
                    if (index >= 0){
                        ByteBuffer byteBuffer=inputBuffers[index];
                        Log.d("lpf","bytebuffer is "+byteBuffer);
                        int sampleSize=mMediaExtractor.readSampleData(byteBuffer,0);
                        Log.d("lpf","sampleSize is "+sampleSize);
                        if (sampleSize < 0){
                            Log.d("lpf","inputBuffer is BUFFER_FLAG_END_OF_STREAMING");
                            mMediaCodec.queueInputBuffer(index,0,0,0,MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                            isEOF=true;
                        }else{
                            mMediaCodec.queueInputBuffer(index,0,sampleSize,mMediaExtractor.getSampleTime(),0);
                            mMediaExtractor.advance();  //下一幀數據
                        }
                    }
                }
                int outIndex=mMediaCodec.dequeueOutputBuffer(info,100000);
                switch (outIndex){
                    case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
                        //當buffer變化時，必須重新指向新的buffer
                        outputBuffers=mMediaCodec.getOutputBuffers();
                        break;
                    case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
                        //當Buffer的封裝格式發生變化的時候，需重新指向新的buffer格式
                        Log.d("lpf","output  buffer changed");
                            break;
                    case MediaCodec.INFO_TRY_AGAIN_LATER:
                        //dequeueOutputBuffer 超時的時候會到這個case
                        Log.d("lpf","dequeueOutputBuffer timeout");
                        break;
                    default:
                        ByteBuffer buffer=outputBuffers[outIndex];
                        //由于配置的時候 將Surface 傳進去了  所以解碼的時候 將數據直接交給了Surface進行顯示了
                        //使用簡單的時鐘的方式保持視頻的fps（每秒顯示的幀數），不然視頻會播放的比較快
                        Log.d("lpf","解碼之后的 buffer數據="+buffer);
                        while (info.presentationTimeUs/1000>System.currentTimeMillis()-startMs){
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        mMediaCodec.releaseOutputBuffer(outIndex,true);
                        break;
                }
                if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0){
                    Log.d("lpf","outputBuffer BUFFER_FLAG_END_OF_STREAM");
                    break;
                }
            }
            mMediaCodec.stop();
            mMediaCodec.release();// 釋放組件
            mMediaExtractor.release();
        }
    }
  • 定義媒體提取器：MediaExtractor,通過媒體提取器，得到視頻的MIME以及MediaFormat數據
  • 通過媒體提取器拿到的MIME 類型來創建硬件解碼器MediaCodec，再通過上一步拿到的額MediaFormat來配置硬件解碼器。
  • 配置完成后，調用硬件解碼器的start函數，解碼器就開始工作了
  • 從解碼器上拿到輸入和輸出Buffer數組，用于解碼使用
  • dequeueInputBuffer通過這個函數得到待解碼的數據index，然后通過index拿到ByteBuffer
  • 然后mMediaExtractor調用readSampleData來讀取數據，將數據得到ByteBuffer中去
  • 接下來將數據丟入編碼隊列，這個隊列在MediaCodec中
  • 然后就可以從硬件解碼器中獲取數據了，由于配置的時候將Surface當做參數配置給了MediaCodec，所以數據會直接通過SurfaceView進行顯示。

4.MediaCodec 異步解碼進行播放

public void startSyncPlay(Surface surface){
    mMediaExtractor = new MediaExtractor();
    try {
        mMediaExtractor.setDataSource(mFilePath);
    } catch (IOException e) {
        e.printStackTrace();
    }
    int trackCount = mMediaExtractor.getTrackCount();
    //從媒體提取器中拿到了 MIME 以及MediaFormat   通過MIME 創建的硬件解碼器   通過MediaFormat配置的硬件解碼器
    for (int i = 0; i < trackCount; i++) {
        MediaFormat trackFormat = mMediaExtractor.getTrackFormat(i);
        Log.d("lpf","trackFormat is "+trackFormat);
        String mime=trackFormat.getString(MediaFormat.KEY_MIME);
        Log.d("lpf","mime is "+mime);
        if (mime.startsWith("video/")) {
            mMediaExtractor.selectTrack(i);
            try {
                mMediaCodec=MediaCodec.createDecoderByType(mime);
                if (mMediaCodec == null){
                    return;
                }
                //這樣配置之后，解碼之后的數據就會 直接顯示在mSurface 上邊  這里是核心點
                mMediaCodec.configure(trackFormat,surface,null,0);
                mMediaCodec.setCallback(new MediaCodec.Callback() {
                    @Override
                    public void onInputBufferAvailable(@NonNull MediaCodec codec, int index) {
                        ByteBuffer inputBuffer = codec.getInputBuffer(index);
                        int sampleSize=mMediaExtractor.readSampleData(inputBuffer,0);
                        if (sampleSize>0) {
                            codec.queueInputBuffer(index,0,sampleSize,mMediaExtractor.getSampleTime(),0);
                            mMediaExtractor.advance();  //下一幀數據
                        }else {
                            codec.queueInputBuffer(index,0,0,0,MediaCodec.BUFFER_FLAG_END_OF_STREAM);
                        }
                    }
                    @Override
                    public void onOutputBufferAvailable(@NonNull MediaCodec codec, int index, @NonNull MediaCodec.BufferInfo info) {
                        if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0){
                            Log.d("lpf","outputBuffer BUFFER_FLAG_END_OF_STREAM");
                            codec.stop();
                            codec.release();// 釋放組件
                            mMediaExtractor.release();
                            return;
                        }
                        if (index>0){
                            if (startMs==-1){
                                startMs=System.currentTimeMillis();
                            }
                            sleepRender(info,startMs);
                        }
                        codec.releaseOutputBuffer(index,true);  //釋放緩沖區，并交給Surface 進行播放
                    }
                    @Override
                    public void onError(@NonNull MediaCodec codec, @NonNull MediaCodec.CodecException e) {
                    }
                    @Override
                    public void onOutputFormatChanged(@NonNull MediaCodec codec, @NonNull MediaFormat format) {
                    }
                });
                //調用Start 如果沒有異常信息，表示成功構建組件
                mMediaCodec.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

異步的方式進行解碼操作，比較簡單，推薦使用這個方式

  • onInputBufferAvailable，將需要編碼的數據從這個回調方法中添加到解碼隊列
  • onOutputBufferAvailable 在這個回調方法中就能拿到編碼好的數據，可以說非常便利，思路也比同步的時候更加簡潔。

原文鏈接：https://blog.csdn.net/u014078003/article/details/127952067

欄目分類
最近更新