播放一个视频，都需要经过解封装、视频解码、音频解码、音视频同步、视频输出显示和音频输出播放等过程。
先简单介绍下视频解码的流程。

image.png

解协议：
就是将流媒体协议的数据，解析为标准的相应的封装格式数据。音视频在⽹络上传播的时候，常常采⽤各种流媒体协议，例如HTTP，RTMP，或是MMS等等。这些协议在传输视⾳频数据的同时，也会传输⼀些信令数据。这些信令数据包括对播放的控制（播放，暂停，停⽌），或者对⽹络状态的描述等。解协议的过程中会去除掉信令数据⽽只保留视⾳频数据。例如，采⽤RTMP协议传输的数据，经过解协议操作后，输出FLV格式的数据。
解封装：
就是将输⼊的封装格式的数据，分离成为⾳频流压缩编码数据和视频流压缩编码数据。封装格式种类很多，例如MP4，MKV，RMVB，TS，FLV，AVI等等，它的作⽤就是将已经压缩编码的视频数据和⾳频数据按照⼀定的格式放到⼀起。例如，FLV格式的数据，经过解封装操作后，输出H.264编码的视频码流和AAC编码的⾳频码流。
解码：
就是将视频/⾳频压缩编码数据，解码成为⾮压缩的视频/⾳频原始数据。⾳频的压缩编码标准包含AAC，MP3，AC-3等等，视频的压缩编码标准则包含H.264，MPEG2，VC-1等等。解码是整个系统中最重要也是最复杂的⼀个环节。通过解码，压缩编码的视频数据输出成为⾮压缩的颜⾊数据，例如YUV420P，RGB等等；压缩编码的⾳频数据输出成为⾮压缩的⾳频抽样数据，例如PCM数据。

利用FFmpeg进行视频解码

ffmpeg视频解码.png

这里需要说明下一些FFMpeg的重要结构体：
AVFormatContext：解封装功能的结构体，包含文件名、音视频流、时长、比特率等信息；
AVCodecContext：编解码器上下文，编码和解码时必须用到的结构体，包含编解码器类型、视频宽高、音频通道数和采样率等信息；
AVCodec：存储编解码器信息的结构体；
AVStream：存储音频或视频流信息的结构体；
AVPacket：存储音频或视频编码数据；
AVFrame：存储音频或视频解码数据（原始数据）；

具体代码实现

创建VideoDecoder类，分别实现init、start、release等3个方法。
init为初始化，对一些重要的结构体进行复制或者指向。
start为开始解码循环，读取帧数据
release为释放逻辑，在代码结束时释放。

int videoDecoder::init(const char *url) {
    strcpy(m_url, url);
    int result = -1;
    //1.创建封装格式上下文
    m_AVFormatContext = avformat_alloc_context();
    //2.打开文件
    if (avformat_open_input(&m_AVFormatContext, m_url, nullptr, nullptr) != 0) {
        LOGE("avformat_open_input fail");
    }
    //3.获取音视频流信息
    if (avformat_find_stream_info(m_AVFormatContext, nullptr) < 0) {

    }
    //4.获取视频流索引
    m_StreamIndex = av_find_best_stream(m_AVFormatContext, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    if (m_StreamIndex == -1) {

    }
    //5.获取解码器参数
    AVCodecParameters *codecParameters = m_AVFormatContext->streams[m_StreamIndex]->codecpar;
    //6.获取解码器
    m_AVCodec = avcodec_find_decoder(codecParameters->codec_id);
    if (m_AVCodec == nullptr) {

    }
    //7.创建解码器上下文
    m_AVCodecContext = avcodec_alloc_context3(m_AVCodec);
    //将流的参数（codecParameters）复制到解码器中，否则某些流可能无法正常解码
    if (avcodec_parameters_to_context(m_AVCodecContext, codecParameters) != 0) {

    }
    AVDictionary *pAVDictionary = nullptr;
    av_dict_set(&pAVDictionary, "buffer_size", "1024000", 0);
    av_dict_set(&pAVDictionary, "stimeout", "20000000", 0);
    av_dict_set(&pAVDictionary, "max_delay", "30000000", 0);
    av_dict_set(&pAVDictionary, "rtsp_transport", "tcp", 0);

    //8.打开解码器
    result = avcodec_open2(m_AVCodecContext, m_AVCodec, &pAVDictionary);
    if (result < 0) {

    }
    m_Duration = m_AVFormatContext->duration / AV_TIME_BASE * 1000;//us to ms
    //创建 AVPacket 存放编码数据
    m_Packet = av_packet_alloc();
    //创建 AVFrame 存放解码后的数据
    m_Frame = av_frame_alloc();
    return result;
}

void videoDecoder::release() {
//释放资源，解码完成
    if(m_Frame != nullptr) {
        av_frame_free(&m_Frame);
        m_Frame = nullptr;
    }

    if(m_Packet != nullptr) {
        av_packet_free(&m_Packet);
        m_Packet = nullptr;
    }

    if(m_AVCodecContext != nullptr) {
        avcodec_close(m_AVCodecContext);
        avcodec_free_context(&m_AVCodecContext);
        m_AVCodecContext = nullptr;
        m_AVCodec = nullptr;
    }

    if(m_AVFormatContext != nullptr) {
        avformat_close_input(&m_AVFormatContext);
        avformat_free_context(m_AVFormatContext);
        m_AVFormatContext = nullptr;
    }
}

int videoDecoder::start() {
    int result = av_read_frame(m_AVFormatContext, m_Packet);
    while (result >= 0) {
        //过滤数据，找出对应流，符合才进一步解码
        if (m_Packet->stream_index == m_StreamIndex) {
            //解码视频，将packet数据交给avcodec去处理
            if (avcodec_send_packet(m_AVCodecContext,m_Packet)!=0){
                return -1;
            }
            while (avcodec_receive_frame(m_AVCodecContext,m_Frame)==0){
                //获取到 m_Frame 解码数据，在这里进行格式转换，然后进行渲染并且显示
                LOGD("m_Frame pts is %ld",m_Frame->pts);
            }
        }
        av_packet_unref(m_Packet);
        result = av_read_frame(m_AVFormatContext, m_Packet);
    }
}

测试代码

checkPermission(object : RequestPermissionListener {
            override fun permissionAllGranted() {
                PlayLocalVideo("/sdcard/Download/v1080.mp4")
            }

            override fun permissionDenied(list: MutableList<String>) {
            }

        })

    private external fun PlayLocalVideo(url: String)

videoDecoder *vDecoder = new videoDecoder();
    const char *url = env->GetStringUTFChars(jUrl, nullptr);
    vDecoder->init(url);
    vDecoder->start();
    vDecoder->release();

测试结果

image.png

到这里为止，就已经是解码成功了。接下来实现如何将视频的数据，显示在手机上。显示的方法有很多种，OpenGL、ANativeWindow等，这里就先用Android自带的演示一下。

首先在布局中增加一个surfaceView

    <SurfaceView
        android:id="@+id/surfaceVideo"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintTop_toBottomOf="@id/sample_text" />

android代码中绑定窗口和传递参数

    binding.surfaceVideo.holder.addCallback(this)

    override fun surfaceCreated(holder: SurfaceHolder) {
        surface = holder.surface
        PlayLocalVideo("/sdcard/Download/v1080.mp4", surface!!)
    }

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
    }

接下来需要做的就是，如何把上面解码得到的数据，刷到这个SurfaceView中。在实现之前，需要知道显示的控件支持什么类型的数据。ANativeWindow 仅支持 RGB 类型的图像数据，所以我们还需要利用 libswscale 库将解码后的 YUV 数据转成 RGB 。

首先在初始化的方法里，加入ANativeWindow的初始化。

    //1. 利用 Java 层 SurfaceView 传下来的 Surface 对象，获取 ANativeWindow
    m_NativeWindow = ANativeWindow_fromSurface(env, surface);
    //显示窗口初始化
    ANativeWindow_setBuffersGeometry(m_NativeWindow, m_RenderWidth, m_RenderHeight,
                                     WINDOW_FORMAT_RGBA_8888);


    m_VideoWidth = m_AVCodecContext->width;
    m_VideoHeight = m_AVCodecContext->height;
    m_RGBAFrame = av_frame_alloc();
    //计算 Buffer 的大小
    int bufferSize = av_image_get_buffer_size(AV_PIX_FMT_RGBA, m_VideoWidth, m_VideoHeight, 1);
    //为 m_RGBAFrame 分配空间
    m_FrameBuffer = static_cast<uint8_t *>(av_malloc(bufferSize * sizeof(uint8_t)));
    av_image_fill_arrays(m_RGBAFrame->data, m_RGBAFrame->linesize, m_FrameBuffer, AV_PIX_FMT_RGBA,
                         m_VideoWidth, m_VideoHeight, 1);
    //获取转换的上下文
    m_SwsContext = sws_getContext(m_VideoWidth, m_VideoHeight, m_AVCodecContext->pix_fmt,
                                  m_VideoWidth, m_VideoHeight, AV_PIX_FMT_RGBA,
                                  SWS_BICUBIC, nullptr, nullptr, nullptr);

然后在上面读取帧数据的地方，加入转换和显示刷新的逻辑

sws_scale(m_SwsContext, m_Frame->data, m_Frame->linesize, 0,
              m_VideoHeight, m_RGBAFrame->data, m_RGBAFrame->linesize);
    if(m_NativeWindow == nullptr){
        LOGE("NativeWindow is null");
    return;
    }
    ANativeWindow_lock(m_NativeWindow, &m_NativeWindowBuffer, nullptr);
    uint8_t *dstBuffer = static_cast<uint8_t *>(m_NativeWindowBuffer.bits);

    int srcLineSize = m_RGBAFrame->linesize[0];//RGBA
    int dstLineSize = m_NativeWindowBuffer.stride * 4;

    for (int i = 0; i < m_VideoHeight; ++i) {
        memcpy(dstBuffer + i * dstLineSize,
               m_FrameBuffer + i * srcLineSize,
               srcLineSize);
    }

    ANativeWindow_unlockAndPost(m_NativeWindow);

这样就可以看到视频的播放了。但由于是demo代码，很多细节都没有处理，例如实际开发的时候，需要在异线程中进行解码、还有适当地增加Log提示、指针的处理等，避免产生bug。