Android RTMP推流之MediaCodec硬编码一(H.264进行flv封装)

在前面Android平台下使用FFmpeg进行RTMP推流(摄像头推流)的文章中,介绍了如何使用FFmpeg进行H264编码和Rtmp推流。接下来讲分几篇文章来介绍如何使用Android系统的MediaCodec进行H264硬编码,然后封装推流。这一块涉及的内容很多,其中涉及一些基础知识也会有单独文章介绍比如flv格式。这篇文章主要介绍如何用MediaCodec进行编码,然后将编码后的数据进行flv封装。

文章同步项目源码地址 注意版本为V1.3

3.png

MediaCodec介绍

学习个模块内容当然是参考官方文档Android MediaCodec。但有些兄弟可能没有大多耐心看英文,那我在推荐一个中文版的MediaCodec官方文档译文,如果还是没耐心看,或者没看懂,那就试试看下我的理解。 先上一张图:

1.png

这个图也是官网上抠下来的。对这个图的理解很关键。我先总结一下:

  • MediaCodec编码器包含两个缓冲区,一个输入缓冲区,一个输出缓冲区。
  • 客户端先从MediaCodec获取一个可用的输入缓冲区,然后将待编码的数据填充到缓冲区,然后交给MediaCodec去处理。
  • 客户端从输出缓冲区获取已经处理好的数据,客户端得到数据后并处理后,释放空间,最后将缓冲区还给MediaCodec。

我把整条线简单的描述了一下。也就是整个编码流程,客户端是如何操作的。下面我们要深入了解MediaoCodec如何工作,还是先上图

2.png

这里我也总结下:

  • 要用MediaCodec,首先需要创建,根据我们想要的编码格式创建。创建后就是Uninitialized状态
  • 创建完成之后还不能直接用,我们需要进行配置,进入Configured。这时候就准备就绪了
  • Configured后,就可以start。进行运行阶段了。
  • 运行阶段又分3个子状态。start()后就进入Flushed状态。
  • 当客户端获取一个有效的输入缓冲区后,就进入了Running,而MediaCodec大部分时间在这个状态
  • 如果客户端将得到的输入缓冲区入队时带有末尾标记时,编码器就进入End of Stream状态,这时候就不再接受后面缓冲区的输入
  • stop之后就会重新进入Uninitialized状态。
  • 如果出现错误就会进入Error状态

到这里我们就简单的吧MediaCodec介绍完了。当然我只是简单的介绍,大概了解后,我们先用起来,然后自己再体会就知道了。


MediaCodec编码

创建并配置MediaCodec

我们按前面的流程使用MediaCodec。先创建MediaCodec 先上代码

    private void initMediaCodec() {
        int bitrate = 2 * WIDTH * HEIGHT * FRAME_RATE / 20;
        try {
            MediaCodecInfo mediaCodecInfo = selectCodec(VCODEC_MIME);
            if (mediaCodecInfo == null) {
                Toast.makeText(this, "mMediaCodec null", Toast.LENGTH_LONG).show();
                throw new RuntimeException("mediaCodecInfo is Empty");
            }
            LogUtils.w("MediaCodecInfo " + mediaCodecInfo.getName());
            mMediaCodec = MediaCodec.createByCodecName(mediaCodecInfo.getName());
            MediaFormat mediaFormat = MediaFormat.createVideoFormat(VCODEC_MIME, WIDTH, HEIGHT);
            mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
            mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);
            mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT,
                    MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar);
            mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
            mMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            mMediaCodec.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
  • 查找编码器 MediaCodecInfo mediaCodecInfo = selectCodec(VCODEC_MIME); 我们看到selectCodec方法。我们要使用H.264编码,所以传入的参数 private static final String VCODEC_MIME = "video/avc";
    private MediaCodecInfo selectCodec(String mimeType) {
        int numCodecs = MediaCodecList.getCodecCount();
        for (int i = 0; i < numCodecs; i++) {
            MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
            //是否是编码器
            if (!codecInfo.isEncoder()) {
                continue;
            }
            String[] types = codecInfo.getSupportedTypes();
            LogUtils.w(Arrays.toString(types));
            for (String type : types) {
                LogUtils.e("equal " + mimeType.equalsIgnoreCase(type));
                if (mimeType.equalsIgnoreCase(type)) {
                    LogUtils.e("codecInfo " + codecInfo.getName());
                    return codecInfo;
                }
            }
        }
        return null;
    }

这段逻辑主要是获取系统的编码器并查找是否有我们需要的编码器并返回其信息。得到信息后我们就可以创建MediaCodec

mMediaCodec = MediaCodec.createByCodecName(mediaCodecInfo.getName());
  • 配置编码器信息 前面我们已经查找并创建了编码器,这一步就是进行参数配置。主要是setInteger等方法进行类似key-value的设置。如:码率KEY_BIT_RATE、编码像素格式KEY_COLOR_FORMAT、帧率KEY_FRAME_RATE。 这里要注意KEY_COLOR_FORMAT像素格式的设置,后面涉及到格式的转换,同时不同的设备可能支持的格式不同,我测试的设备就不支持COLOR_FormatYUV420SemiPlanar
  • 配置 mMediaCodec.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE); 这一步也是必须的

编码

前面的文章我们已经讲到了如何采集获取Camera的数据,这里就不再累述。直接看到Camera.PreviewCallbackonPreviewFrame(final byte[] data, Camera camera)回调方法。

    public class StreamIt implements Camera.PreviewCallback {
        @Override
        public void onPreviewFrame(final byte[] data, Camera camera) {
            long endTime = System.currentTimeMillis();
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    encodeTime = System.currentTimeMillis();
                    flvPackage(data);
                    LogUtils.w("编码第:" + (encodeCount++) + "帧,耗时:" + (System.currentTimeMillis() - encodeTime));
                }
            });
            LogUtils.d("采集第:" + (++count) + "帧,距上一帧间隔时间:"
                    + (endTime - previewTime) + "  " + Thread.currentThread().getName());
            previewTime = endTime;
        }
    }

这个回调方法大家就很首席了data就是采集到的原始YUV数据。为了方便调试,我就把第几帧和编码时间以及采集时间打印出来。而这里的YUV数据和Camera的参数设置有关params.setPreviewFormat(ImageFormat.YV12);系统默认使用的N21,这里我使用YV12格式。 接下来重点就是flvPackage(data);调用了

    private void flvPackage(byte[] buf) {
        final int LENGTH = HEIGHT * WIDTH;
        //YV12数据转化成COLOR_FormatYUV420Planar
        LogUtils.d(LENGTH + "  " + (buf.length - LENGTH));
        for (int i = LENGTH; i < (LENGTH + LENGTH / 4); i++) {
            byte temp = buf[i];
            buf[i] = buf[i + LENGTH / 4];
            buf[i + LENGTH / 4] = temp;
//            char x = 128;
//            buf[i] = (byte) x;
        }
        ByteBuffer[] inputBuffers = mMediaCodec.getInputBuffers();
        ByteBuffer[] outputBuffers = mMediaCodec.getOutputBuffers();
        try {
            //查找可用的的input buffer用来填充有效数据
            int bufferIndex = mMediaCodec.dequeueInputBuffer(-1);
            if (bufferIndex >= 0) {
                //数据放入到inputBuffer中
                ByteBuffer inputBuffer = inputBuffers[bufferIndex];
                inputBuffer.clear();
                inputBuffer.put(buf, 0, buf.length);
                //把数据传给编码器并进行编码
                mMediaCodec.queueInputBuffer(bufferIndex, 0,
                        inputBuffers[bufferIndex].position(),
                        System.nanoTime() / 1000, 0);
                MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();

                //输出buffer出队,返回成功的buffer索引。
                int outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
                while (outputBufferIndex >= 0) {
                    ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
                    //进行flv封装
                    mFlvPacker.onVideoData(outputBuffer, bufferInfo);
                    mMediaCodec.releaseOutputBuffer(outputBufferIndex, false);
                    outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);
                }
            } else {
                LogUtils.w("No buffer available !");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

我们看到第一步有一个格式转换,YV12数据转化成COLOR_FormatYUV420Planar。因为编码器支持的输入是COLOR_FormatYUV420Planar,而我们采集到的是YV12。所以需要转换。两者的区别就是U、V分量颠倒了个位置。在Android平台下使用FFmpeg进行RTMP推流(摄像头推流)有具体介绍。

接下来就是关键部分了MediaCodec进行H264编码。客户端的使用流程我们按照对图1的总结来进行操作 首先获取编码器的输入和输出缓冲区

        ByteBuffer[] inputBuffers = mMediaCodec.getInputBuffers();
        ByteBuffer[] outputBuffers = mMediaCodec.getOutputBuffers();

接下来获取一个可用的输入缓冲区索引

int bufferIndex = mMediaCodec.dequeueInputBuffer(-1);

如果返回>0说明有效。然后获取到对应的ByteBuffer ByteBuffer inputBuffer = inputBuffers[bufferIndex]; 接下来就是讲图像数据填充到inputBuffer中。

                inputBuffer.clear();
                inputBuffer.put(buf, 0, buf.length);

然后告诉编码器开始编码

 //把数据传给编码器并进行编码
                mMediaCodec.queueInputBuffer(bufferIndex, 0,
                inputBuffers[bufferIndex].position(),
                System.nanoTime() / 1000, 0);

接下来就是获取编码后的数据,这里先得到输出缓冲区索引

int outputBufferIndex = mMediaCodec.dequeueOutputBuffer(bufferInfo, 0);

然后就可以得到对应的ByteBuffer。也就是编码后的数据,得到数据后我们就可以进行flv封装。 最后我们需要释放缓冲区

mMediaCodec.releaseOutputBuffer(outputBufferIndex, false);

到这里我们就了解了如何具体使用MediaCodec,接下来就是如何进行flv封装


flv封装

前面已经讲到如何进行H264编码,并得到编码后的数据。接下来就是如何将原始的H264数据封装成flv格式的数据。在将flv封装之前,大家一定要熟悉flv的格式。flv格式相对比较简单,可以参考flv格式详解+实例剖析。否则接下来的内容大家会一脸懵逼。在讲代码前,还是先总结下流程:

  • flv文件封装视频数据前先写入flv头,metadata数据。
  • MediaCodec进行编码后的第一个数据是sps、pps数据,也是flv中的第一个video tag。
  • 后面收到的MediaCodec编码后的数据就是正常的视频h264数据,封装到flv中。

封装h264的调用:

//进行flv封装
mFlvPacker.onVideoData(outputBuffer, bufferInfo);

我们进入代码看到:

    @Override
    public void onVideoData(ByteBuffer bb, MediaCodec.BufferInfo bi) {
        mAnnexbHelper.analyseVideoData(bb, bi);
    }

再跟进方法

    /**
     * 将硬编得到的视频数据进行处理生成每一帧视频数据,然后传给flv打包器
     * @param bb 硬编后的数据buffer
     * @param bi 硬编的BufferInfo
     */
    public void analyseVideoData(ByteBuffer bb, MediaCodec.BufferInfo bi) {
        bb.position(bi.offset);
        bb.limit(bi.offset + bi.size);

        ArrayList<byte[]> frames = new ArrayList<>();
        boolean isKeyFrame = false;

        while(bb.position() < bi.offset + bi.size) {
            byte[] frame = annexbDemux(bb, bi);
            if(frame == null) {
                LogUtils.e("annexb not match.");
                break;
            }
            // ignore the nalu type aud(9)
            if (isAccessUnitDelimiter(frame)) {
                continue;
            }
            // for pps
            if(isPps(frame)) {
                mPps = frame;
                continue;
            }
            // for sps
            if(isSps(frame)) {
                mSps = frame;
                continue;
            }
            // for IDR frame
            if(isKeyFrame(frame)) {
                isKeyFrame = true;
            } else {
                isKeyFrame = false;
            }
            byte[] naluHeader = buildNaluHeader(frame.length);
            frames.add(naluHeader);
            frames.add(frame);
        }
        if (mPps != null && mSps != null && mListener != null && mUploadPpsSps) {
            if(mListener != null) {
                mListener.onSpsPps(mSps, mPps);
            }
            mUploadPpsSps = false;
        }
        if(frames.size() == 0 || mListener == null) {
            return;
        }
        int size = 0;
        for (int i = 0; i < frames.size(); i++) {
            byte[] frame = frames.get(i);
            size += frame.length;
        }
        byte[] data = new byte[size];
        int currentSize = 0;
        for (int i = 0; i < frames.size(); i++) {
            byte[] frame = frames.get(i);
            System.arraycopy(frame, 0, data, currentSize, frame.length);
            currentSize += frame.length;
        }
        if(mListener != null) {
            mListener.onVideo(data, isKeyFrame);
        }
    }

这个方法主要是从编码后的数据中解析得到NALU,然后判断NALU的类型,最后再把数据回调给FlvPacker去处理。那如何解析得到NALU,我们看到annexbDemux(bb, bi)方法

    /**
     * 从硬编出来的数据取出一帧nal
     * @param bb
     * @param bi
     * @return
     */
    private byte[] annexbDemux(ByteBuffer bb, MediaCodec.BufferInfo bi) {
        AnnexbSearch annexbSearch = new AnnexbSearch();
        avcStartWithAnnexb(annexbSearch, bb, bi);

        if (!annexbSearch.match || annexbSearch.startCode < 3) {
            return null;
        }

        for (int i = 0; i < annexbSearch.startCode; i++) {
            bb.get();
        }

        ByteBuffer frameBuffer = bb.slice();
        int pos = bb.position();
        while (bb.position() < bi.offset + bi.size) {
            avcStartWithAnnexb(annexbSearch, bb, bi);
            if (annexbSearch.match) {
                break;
            }
            bb.get();
        }

        int size = bb.position() - pos;
        byte[] frameBytes = new byte[size];
        frameBuffer.get(frameBytes);
        return frameBytes;
    }

方法返回得到NALU数据,那如何解析的呢,看到avcStartWithAnnexb(annexbSearch, bb, bi);方法调用

   /**
     * 从硬编出来的byteBuffer中查找nal
     * @param as
     * @param bb
     * @param bi
     */
    private void avcStartWithAnnexb(AnnexbSearch as, ByteBuffer bb, MediaCodec.BufferInfo bi) {
        as.match = false;
        as.startCode = 0;
        int pos = bb.position();
        while (pos < bi.offset + bi.size - 3) {
            // not match.
            if (bb.get(pos) != 0x00 || bb.get(pos + 1) != 0x00) {
                break;
            }

            // match N[00] 00 00 01, where N>=0
            if (bb.get(pos + 2) == 0x01) {
                as.match = true;
                as.startCode = pos + 3 - bb.position();
                break;
            }
            pos++;
        }
    }

这里逻辑也比较简单,遍历寻找NALU的开头,开头是有0x0000010x00000001开头。这里找到匹配的位置后设置的到AnnexbSearch中。

我们回到analyseVideoData方法,在调用byte[] frame = annexbDemux(bb, bi);后我们已经得到NALU数据,接下来就是判断NALU类型

        while(bb.position() < bi.offset + bi.size) {
            byte[] frame = annexbDemux(bb, bi);
            if(frame == null) {
                LogUtils.e("annexb not match.");
                break;
            }
            // ignore the nalu type aud(9)
            if (isAccessUnitDelimiter(frame)) {
                continue;
            }
            // for pps
            if(isPps(frame)) {
                mPps = frame;
                continue;
            }
            // for sps
            if(isSps(frame)) {
                mSps = frame;
                continue;
            }
            // for IDR frame
            if(isKeyFrame(frame)) {
                isKeyFrame = true;
            } else {
                isKeyFrame = false;
            }
            byte[] naluHeader = buildNaluHeader(frame.length);
            frames.add(naluHeader);
            frames.add(frame);
        }
        if (mPps != null && mSps != null && mListener != null && mUploadPpsSps) {
            if(mListener != null) {
                mListener.onSpsPps(mSps, mPps);
            }
            mUploadPpsSps = false;
        }

首先需要知道NALU是有header+Payload组成。而header固定1个字节,由3个部分组成forbidden_bit(1bit),nal_reference_bit(2bits)(优先级),nal_unit_type(5bits)(类型)。 这里重点看到类型:

3.jpg

所以我们看到代码的判断,解析第一个字节就可以啦:

    private boolean isSps(byte[] frame) {
        if (frame.length < 1) {
            return false;
        }
        // 5bits, 7.3.1 NAL unit syntax,
        // H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
        //  7: SPS, 8: PPS, 5: I Frame, 1: P Frame
        int nal_unit_type = (frame[0] & 0x1f);
        return nal_unit_type == SPS;
    }

    private boolean isPps(byte[] frame) {
        if (frame.length < 1) {
            return false;
        }
        // 5bits, 7.3.1 NAL unit syntax,
        // H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
        //  7: SPS, 8: PPS, 5: I Frame, 1: P Frame
        int nal_unit_type = (frame[0] & 0x1f);
        return nal_unit_type == PPS;
    }

    private boolean isKeyFrame(byte[] frame) {
        if (frame.length < 1) {
            return false;
        }
        // 5bits, 7.3.1 NAL unit syntax,
        // H.264-AVC-ISO_IEC_14496-10.pdf, page 44.
        //  7: SPS, 8: PPS, 5: I Frame, 1: P Frame
        int nal_unit_type = (frame[0] & 0x1f);
        return nal_unit_type == IDR;
    }

回到analyseVideoData方法,当sps和pps都回去到后,就可以调用mListener.onSpsPps(mSps, mPps);把数据回调给FlvPacker。我们看到实现部分

    @Override
    public void onSpsPps(byte[] sps, byte[] pps) {
        if(packetListener == null) {
            return;
        }
        //写入Flv header信息
        writeFlvHeader();
        //写入Meta 相关信息
        writeMetaData();
        //写入第一个视频信息
        writeFirstVideoTag(sps, pps);
        //写入第一个音频信息
        writeFirstAudioTag();
        mStartTime = System.currentTimeMillis();
        isHeaderWrite = true;
    }

因为sps和pps有且仅有一个而且是第一个。所以在这里,同事写入flv的头部信息和metaData数据,然后将sps和pps信息写入。至于每个tag的封装,这里就不做讲解了,大家针对前面flv格式详解+实例剖析文章,再对照代码就很清晰了。 再看到mListener.onVideo(data, isKeyFrame);

    @Override
    public void onVideo(byte[] video, boolean isKeyFrame) {
        if(packetListener == null || !isHeaderWrite) {
            return;
        }
        int compositionTime = (int) (System.currentTimeMillis() - mStartTime);
        int packetType = INTER_FRAME;
        if(isKeyFrame) {
            isKeyFrameWrite = true;
            packetType = KEY_FRAME;
        }
        //确保第一帧是关键帧,避免一开始出现灰色模糊界面
        if(!isKeyFrameWrite) {
            return;
        }

        int videoPacketSize = VIDEO_HEADER_SIZE + video.length;
        int dataSize = videoPacketSize + FLV_TAG_HEADER_SIZE;
        int size = dataSize + PRE_SIZE;
        ByteBuffer buffer = ByteBuffer.allocate(size);
        FlvPackerHelper.writeFlvTagHeader(buffer, FlvPackerHelper.FlvTag.Video, videoPacketSize, compositionTime);
        FlvPackerHelper.writeH264Packet(buffer, video, isKeyFrame);
        buffer.putInt(dataSize);
        packetListener.onPacket(buffer.array(), packetType);
    }

这里就是正常的视频NALU数据写入了。 两个回调方法最后都调用了packetListener.onPacket(buffer.array(), packetType);。这个packetListener就是我们CameraMediaCodecActivity中设置的回调

        mFlvPacker.setPacketListener(new Packer.OnPacketListener() {
            @Override
            public void onPacket(byte[] data, int packetType) {
                IOUtils.write(mOutStream, data, 0, data.length);
                LogUtils.w(data.length + " " + packetType);
            }
        });

代码会简单就是讲封装好的flv数据写入到文件中。

到此,我们就基本了解如何使用MediaCodec进行H.264硬编码,然后坐Flv格式封装。后续会陆续推出将封装的flv数据进行RTMP推流,请大家关注!

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Android先生

RxJava2 实战知识梳理(5) - 简单及进阶的轮询操作

今天,我们介绍一种新的场景,轮询操作。也就是说,我们会尝试间隔一段时间就向服务器发起一次请求,在使用RxJava之前,该需求的实现一般有两种方式:

25620
来自专栏林冠宏的技术文章

浅谈 Glide - BitmapPool 的存储时机 & 解答 ViewTarget 在同一View显示不同的图片时,总用同一个 Bitmap 引用的原因

作者:林冠宏 / 指尖下的幽灵 掘金:https://juejin.im/user/587f0dfe128fe100570ce2d8 博客:htt...

431100
来自专栏知识分享

Android 多线程-----AsyncTask详解

本篇随笔将讲解一下Android的多线程的知识,以及如何通过AsyncTask机制来实现线程之间的通信。

12230
来自专栏郭耀华‘s Blog

android中handler用法总结

一、Handler的定义:  Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI,用来跟UI主线程交互用。比如可以用handler发送...

41590
来自专栏Android 开发学习

data-binding 踩坑记

23040
来自专栏Java呓语

旧问新解·ListView 中的 OnItemSelectedListener 不生效

今天在写颜色识别的Demo 时有个场景是需要用户做出单项选择,脑中蹦出首选的方案就是 ListView 配合 ChoiceMode。

9220
来自专栏向治洪

Volley解析之表单提交篇

要实现表单的提交,就要知道表单提交的数据格式是怎么样,这里我从某知名网站抓了一条数据,先来分析别人提交表单的数据格式。  数据包: Connection: ...

23750
来自专栏向治洪

Android杀毒实现原理及实例

一个杀毒软甲最核心的部分一个是病毒库一个是杀毒引擎,病毒库从服务器中获得,杀毒引擎实际上是判断程序中的包名和签名是否匹配病毒库中的包名和签名,如果匹配则为病毒,...

30070
来自专栏飞雪无情的博客

Android Intents and Intent Filters(三)

每个data定义一个URI和数据类型(MIME),URI由4个属性来定义,分别是android:scheme,android:host,android:port...

8830
来自专栏Java与Android技术栈

用kotlin打印出漂亮的android日志写在最后

Kotlin号称是Android版本的swift,距离它1.0正式版本的推出快一年了。它像swift一样,可以写客户端也可以写服务端。由于公司项目比较繁忙,我一...

15520

扫码关注云+社区

领取腾讯云代金券