当前位置:   article > 正文

Android 音视频编解码(二) -- MediaCodec 解码(同步和异步)_mediacodec config textureview

mediacodec config textureview

音视频 系列文章
Android 音视频开发基础
Android 音视频编解码(一) – MediaCodec 初探
音视频工程

上面的文章Android 音视频编解码(一) – MediaCodec 初探 中,已经对 MediaCodec 有个感性的认知,这一章,来学习 MediaCodec 的解码功能。

本章效果如下:

在这里插入图片描述

一、同步解码

为了更好的理解 MediaCodec 的工作原理和工作步骤,首先先使用同步解码的方式去解码本地视频。

1.1 拿到视频参数

首先,我们先要准备一个视频,比如 MP4 格式的,它其实已经被编码过的,我们可以通过 MediaCodec 来获取该视频的 MediaFormat 信息,如果你对 MediaExtractor 不熟悉,可以通过 Android 音视频开发(五) – 使用 MediaExtractor 分离音视频,并使用 MediaMuxer合成新视频(音视频同步) 来学习;

定义一个 MyExtractor ,里面实现 MediaExtractor 用来专门解析视频,拿到视频数据:

    public MyExtractor(String path) {
        try {
            mediaExtractor = new MediaExtractor();
            // 设置数据源
            mediaExtractor.setDataSource(path);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //拿到所有的轨道
        int count = mediaExtractor.getTrackCount();
        for (int i = 0; i < count; i++) {
            //根据下标拿到 MediaFormat
            MediaFormat format = mediaExtractor.getTrackFormat(i);
            //拿到 mime 类型
            String mime = format.getString(MediaFormat.KEY_MIME);
            //拿到视频轨
            if (mime.startsWith("video")) {
                videoTrackId = i;
                videoFormat = format;
            } else if (mime.startsWith("audio")) {
                //拿到音频轨
                audioTrackId = i;
                audioFormat = format;
            }

        }
    }


    public void selectTrack(int trackId){
        mediaExtractor.selectTrack(trackId);
    }

    /**
     * 读取一帧的数据
     *
     * @param buffer
     * @return
     */
    public int readBuffer(ByteBuffer buffer) {
        //先清空数据
        buffer.clear();
        //选择要解析的轨道
      //  mediaExtractor.selectTrack(video ? videoTrackId : audioTrackId);
        //读取当前帧的数据
        int buffercount = mediaExtractor.readSampleData(buffer, 0);
        if (buffercount < 0) {
            return -1;
        }
        //记录当前时间戳
        curSampleTime = mediaExtractor.getSampleTime();
        //记录当前帧的标志位
        curSampleFlags = mediaExtractor.getSampleFlags();
        //进入下一帧
        mediaExtractor.advance();
        return buffercount;
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57

首先,先通过 selectTrack 来指定是解析视频还是音频,接着使用 readBuffer 这个方法,该方法使用 mediaExtractor.readSampleData(buffer, 0); 去拿到当前视频的 buffer,并通过 mediaExtractor.advance() 拿到下一帧的数据。

1.2 解码流程

上一章说到 MediaCodec 的解码是基于以下两张图的:

MediaCodec 工作图
MediaCodec工作原理图

MediaCodec状态图MediaCodec状态图
如果你对这两张图的流程不熟悉,请阅读 Android 音视频编解码(一) – MediaCodec 初探

为了方便后续的音频解码,这里我们定义一个基类,用来解析视频和音频,由于是同步解析视频,我们应该在线程中去解析,所以继承 Runnable:

    /**
     * 解码基类,用于解码音视频
     */
    abstract class BaseDecode implements Runnable {
        final static int VIDEO = 1;
        final static int AUDIO = 2;
        //等待时间
        final static int TIME_US = 1000;
        MediaFormat mediaFormat;
        MediaCodec mediaCodec;
        MyExtractor extractor;

        private boolean isDone;
        public BaseDecode() {
            try {
                //获取 MediaExtractor
                extractor = new MyExtractor(Constants.VIDEO_PATH);
                //判断是音频还是视频
                int type = decodeType();
                //拿到音频或视频的 MediaFormat
                mediaFormat = (type == VIDEO ? extractor.getVideoFormat() : extractor.getAudioFormat());
                String mime = mediaFormat.getString(MediaFormat.KEY_MIME);
                //选择要解析的轨道
                extractor.selectTrack(type == VIDEO ? extractor.getVideoTrackId() : extractor.getAudioTrackId());
                //创建 MediaCodec
                mediaCodec = MediaCodec.createDecoderByType(mime);
                //由子类去配置
                configure();
                //开始工作,进入编解码状态
                mediaCodec.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

可以看到,根据视频或者视频拿到不同的 MediaFormat ,并根据 mime 类型,创建 MediaCodec ;
MediaCodec状态图

这样,第一步就创建好了,接着,从上面的状态知道,现在处于Uninitialized 状态;
接着需要调用 configure方法,进入 Configured 状态,这一步由子类完成,比如视频的:

 @Override
 void configure() {
     mediaCodec.configure(mediaFormat, new Surface(mTextureView.getSurfaceTexture()), null, 0);
 }
  • 1
  • 2
  • 3
  • 4

可以看到,通过mediaCodec.configure() 配置了当前的 MediaFormat,和要播放视频的 Surface,这里用的是 TextureView。
接着,调用 MediaCodec 的 start() ,进入 Executing 状态,可以编解码了。

1.3 视频解码

解码流程根据这张图
MediaCodec工作原理图

1.3.1 输入

上面说到 BaseDecode 继承 Runnable ,所以,解码的流程在 run 方法中。

        @Override
        public void run() {


            try {
                
                MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
                //编码
                while (!isDone) {
                    /**
                     * 延迟 TIME_US 等待拿到空的 input buffer下标,单位为 us
                     * -1 表示一直等待,知道拿到数据,0 表示立即返回
                     */
                    int inputBufferId = mediaCodec.dequeueInputBuffer(TIME_US);

                    if (inputBufferId > 0) {
                        //拿到 可用的,空的 input buffer
                        ByteBuffer inputBuffer = mediaCodec.getInputBuffer(inputBufferId);
                        if (inputBuffer != null) {
                            /**
                             * 通过 mediaExtractor.readSampleData(buffer, 0) 拿到视频的当前帧的buffer
                             * 通过 mediaExtractor.advance() 拿到下一帧
                             */
                            int size = extractor.readBuffer(inputBuffer);
                            //解析数据
                            if (size >= 0) {
                                mediaCodec.queueInputBuffer(
                                        inputBufferId,
                                        0,
                                        size,
                                        extractor.getSampleTime(),
                                        extractor.getSampleFlags()
                                );
                            } else {
                                //结束,传递 end-of-stream 标志
                                mediaCodec.queueInputBuffer(
                                        inputBufferId,
                                        0,
                                        0,
                                        0,
                                        MediaCodec.BUFFER_FLAG_END_OF_STREAM
                                );
                                isDone = true;

                            }
                        }
                    }
                    //解码输出交给子类
                    boolean isFinish =  handleOutputData(info);
                    if (isFinish){
                        break;
                    }

                }

                done();

            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        protected void done(){
            try {
                isDone = true;
                //释放 mediacodec
                mediaCodec.stop();
                mediaCodec.release();

                //释放 MediaExtractor
                extractor.release();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        abstract boolean handleOutputData(MediaCodec.BufferInfo info);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77

在一个 while 循环中,不断的解码,上面的代码做到以下流程:

  1. 从 MediaCodec 拿到一个空闲的 buffer
  2. 从视频中,拿到视频的当前帧的数据,并填充到 MediaCodec 的buffer中
  3. 使用 mediaCodec.queueInputBuffer() 把buffer 的数据交给 MediaCodec 去解码

1.3.2 输出

上面的输出过程,由 handleOutputData() 去实现,去到 VideoDecodeSync ,代码实现如下:

@Override
boolean handleOutputData(MediaCodec.BufferInfo info) {
    //等到拿到输出的buffer下标
    int outputId = mediaCodec.dequeueOutputBuffer(info, TIME_US);

    if (outputId >= 0){
        //释放buffer,并渲染到 Surface 中
        mediaCodec.releaseOutputBuffer(outputId, true);
    }

    // 在所有解码后的帧都被渲染后,就可以停止播放了
    if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
        Log.e(TAG, "zsr OutputBuffer BUFFER_FLAG_END_OF_STREAM");

        return true;
    }

    return false;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

上面的代码也做到两件事:

  1. 拿到output buffer
  2. 释放 buffer,并渲染视频到 Surface 中,由 releaseOutputBuffer() 第二个参数控制。

这样,视频解码部分我们就写好了。效果如下:

在这里插入图片描述

但是,你会发现,视频好像是倍速播放一样。

1.3.3 矫正显示时间戳

为什么会出现上面的情况呢?
正常来说,我们的视频播放的帧率大概为 30,即 30fps,大概每 33.33ms 播放一帧;但解码的出一帧的时间大概就是几 ms 的事情,如果一解码就直接给 Surface 去显示的话,视频看起来就想倍速播放的一样。
那你可能说,直接延时 30ms 播放就可以了啊,那不是标准吗? 是的,30fps 是标准,但不代表每个视频都是30,这里就需要学习 音视频的基础知识 ,DTS 和 PTS。

  • DTS (Decoding Time Stamp) : 即解码时间戳,这个时间戳的意义在于告诉播放器该在什么时候解码这一帧的数据
  • PTS (Presentation Time Stamp) :显示时间戳,这个时间戳告诉播放器,什么时候播放这一帧
    需要注意的是,虽然 DTS 、PTS 是用于指导播放端的行为,但他们是在编码的时候,由编码器生成的。
    在没有B帧的情况下,DTS和 PTS 的输出顺序是一样的,一旦存在 B 帧,则顺序不一样。

这里,我们只需要关心 PTS ,即显示时间戳。通过 MediaCodec.BufferInfo 的 presentationTimeUs 可以拿到当前的 pts 时间戳,单位是微妙,它是相对于0开始播放的时间,所以,我们可以使用系统时间差来模仿两帧的时间差,这样当解码过来的 pts 比这个时间差快,则延时以下再输出到 Surface ,如果不是,则直接显示到 Surface 中。

由于在线程中,所以,我们可以使用 Thread.sleep() 去实现,在渲染到 Surface 之前:

 // 用于对准视频的时间戳
 private long startMs = -1;
if (outputId >= 0){
     if (mStartMs == -1) {
            mStartMs = System.currentTimeMillis();
      }
	//矫正pts
     sleepRender(info, startMs);
     //释放buffer,并渲染到 Surface 中
     mediaCodec.releaseOutputBuffer(outputId, true);
 }
#sleepRender
    /**
     * 数据的时间戳对齐
     **/
    private void sleepRender(MediaCodec.BufferInfo info, long startMs) {
        /**
         * 注意这里是以 0 为出事目标的,info.presenttationTimes 的单位为微秒
         * 这里用系统时间来模拟两帧的时间差
         */
        long ptsTimes = info.presentationTimeUs / 1000;
        long systemTimes = System.currentTimeMillis() - startMs;
        long timeDifference = ptsTimes - systemTimes;
        // 如果当前帧比系统时间差快了,则延时以下
        if (timeDifference > 0) {
            try {
                Thread.sleep(timeDifference);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

现在时间播放就正常了。
在这里插入图片描述

1.4 解码音频

上面已经理解了视频的解码,那么音频的解码就比较简单了,新建一个 AudioDecodeSync 类,继承BaseDecode ,在 configure 方法中去配置 MediaCodec ,由于不需要 Surface ,传递 null 即可。

 @Override
 void configure() {
     mediaCodec.configure(mediaFormat, null, null, 0);
 }
  • 1
  • 2
  • 3
  • 4

虽然我们不需要使用 Surface ,但是需要播放视频,那么则需要使用 AudioTrack,如果对它不需要,可以参考 Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音);AudioTrack播放音频.

所以,在 AudioDecodeSync 的构造方法中,需要配置以下 AudioTrack :

    class AudioDecodeSync extends BaseDecode {

        private int mPcmEncode;
        //一帧的最小buffer大小
        private final int minBufferSize;
        private AudioTrack audioTrack;


        public AudioDecodeSync() {
            //拿到采样率
            if (mediaFormat.containsKey(MediaFormat.KEY_PCM_ENCODING)) {
                mPcmEncode = mediaFormat.getInteger(MediaFormat.KEY_PCM_ENCODING);
            } else {
                //默认采样率为 16bit
                mPcmEncode = AudioFormat.ENCODING_PCM_16BIT;
            }

            //音频采样率
            int sampleRate = mediaFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE);
            //获取视频通道数
            int channelCount = mediaFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT);

            //拿到声道
            int channelConfig = channelCount == 1 ? AudioFormat.CHANNEL_IN_MONO : AudioFormat.CHANNEL_IN_STEREO;
            minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, mPcmEncode);


            /**
             * 设置音频信息属性
             * 1.设置支持多媒体属性,比如audio,video
             * 2.设置音频格式,比如 music
             */
            AudioAttributes attributes = new AudioAttributes.Builder()
                    .setUsage(AudioAttributes.USAGE_MEDIA)
                    .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                    .build();
            /**
             * 设置音频数据
             * 1. 设置采样率
             * 2. 设置采样位数
             * 3. 设置声道
             */
            AudioFormat format = new AudioFormat.Builder()
                    .setSampleRate(sampleRate)
                    .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
                    .setChannelMask(channelConfig)
                    .build();


            //配置 audioTrack
            audioTrack = new AudioTrack(
                    attributes,
                    format,
                    minBufferSize,
                    AudioTrack.MODE_STREAM, //采用流模式
                    AudioManager.AUDIO_SESSION_ID_GENERATE
            );
            //监听播放
            audioTrack.play();
        }
        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

拿到 AudioTrack 之后,就可以使用 play() 方法,去监听是否有数据写入,开始播放音频了。

在 handleOutputData:

        @Override
        boolean handleOutputData(MediaCodec.BufferInfo info) {
            //拿到output buffer
            int outputIndex = mediaCodec.dequeueOutputBuffer(info, TIME_US);
            ByteBuffer outputBuffer;
            if (outputIndex >= 0) {
                outputBuffer = mediaCodec.getOutputBuffer(outputIndex);
                //写数据到 AudioTrack 只,实现音频播放
                audioTrack.write(outputBuffer, info.size, AudioTrack.WRITE_BLOCKING);
                mediaCodec.releaseOutputBuffer(outputIndex, false);
            }
            // 在所有解码后的帧都被渲染后,就可以停止播放了
            if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                Log.e(TAG, "zsr OutputBuffer BUFFER_FLAG_END_OF_STREAM");

                return true;
            }
            return false;
        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

你会发现音频正常播放了,且没有什么快进的意思,因为音频的时间戳是比较连续的,因此不用矫正。

1.5 音视频同步

那么,如何让音视频同步呢?其实也不算难,就是开辟两个线程,让它同时播放即可:

if (mExecutorService.isShutdown()) {
            mExecutorService = Executors.newFixedThreadPool(2);
        }
        mVideoSync = new VideoDecodeSync();
        mAudioDecodeSync = new AudioDecodeSync();
        mExecutorService.execute(mVideoSync);
        mExecutorService.execute(mAudioDecodeSync);
  }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

二、异步解码

在 5.0 之后,google 建议使用异步解码的方式去使用 MediaCodec,使用也非常简单,只需要使用 setCallback 方法即可。
比如解析上面的视频,步骤可以如下:

  1. 使用 MediaExtractor 解析视频,拿到 MediaFormat
  2. 使用 MediaCodec.setCallback() 方法
  3. 调用 mediaCodec.configure() 和 mediaCodec.start() 开始解码

所以,代码如下:

    class AsyncDecode {
        MediaFormat mediaFormat;
        MediaCodec mediaCodec;
        MyExtractor extractor;

        public AsyncDecode() {
            try {
                //解析视频,拿到 mediaformat
                extractor = new MyExtractor(Constants.VIDEO_PATH);
                mediaFormat = (extractor.getVideoFormat());
                String mime = mediaFormat.getString(MediaFormat.KEY_MIME);
                extractor.selectTrack(extractor.getVideoTrackId());
                mediaCodec = MediaCodec.createDecoderByType(mime);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private void start() {
            //异步解码
            mediaCodec.setCallback(new MediaCodec.Callback() {
                @Override
                public void onInputBufferAvailable(@NonNull MediaCodec codec, int index) {
						ByteBuffer inputBuffer = codec.getInputBuffer(index);
                    int size = extractor.readBuffer(inputBuffer);
                    if (size >= 0) {
                        codec.queueInputBuffer(
                                index,
                                0,
                                size,
                                extractor.getSampleTime(),
                                extractor.getSampleFlags()
                        );
                        handler.sendEmptyMessage(1);
                    } 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) {
             			mediaCodec.releaseOutputBuffer(index, true);
                }

                @Override
                public void onError(@NonNull MediaCodec codec, @NonNull MediaCodec.CodecException e) {
                    codec.reset();
                }

                @Override
                public void onOutputFormatChanged(@NonNull MediaCodec codec, @NonNull MediaFormat format) {

                }
            });
            //需要在 setCallback 之后,配置 configure
            mediaCodec.configure(mediaFormat, new Surface(mTextureView.getSurfaceTexture()), null, 0);
            //开始解码
            mediaCodec.start();
        }

    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69

使用异步解码,与同步解码的流程基本一致;只不过,在同步的代码中,我们通过

int inputBufferId = mediaCodec.dequeueInputBuffer(TIME_US);
  • 1

去等待拿到空闲的 input buffer 下标,而在异步中,则是通过回调

void onInputBufferAvailable(@NonNull MediaCodec codec, int index) 
  • 1

拿到 input buffer 的下标。不出意外的话,你的视频已经开始播放了,但是也遇到上面的问题,就是倍速播放了,原因我们也解释过,就是没矫正 PTS 的问题。

由于我们的代码在主线程中去进行的,直接 Thread.sleep() 肯定会卡顿的,但是我们可以使用 HandlerThread 或其他线程的方式去解析,这里就不贴了,具体看源码吧。

参考:
https://www.jianshu.com/p/ba8db84f8fe8
https://mp.weixin.qq.com/s?__biz=MzUxODQ3MTk5Mg==&mid=2247483868&idx=1&sn=99dec978a4640136c870965ba853c204&chksm=f989298bcefea09dddae613023139e0c6bd2f4eaaa9dc3ec16400645fc4a0764414134ad73ea&scene=38#wechat_redirect
https://developer.android.google.cn/reference/android/media/MediaCodec?hl=en

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/684828
推荐阅读
相关标签
  

闽ICP备14008679号