解码mp4文件分别存储为pcm，yuv文件

// 解码分别写入对应文件
#include "myLog.h"
#include <iostream>

extern "C"
{
#include <libavformat\avformat.h>
#include <libavutil\avutil.h>
#include <libavcodec\avcodec.h>
#include <libavutil\imgutils.h>
#include <libavutil\samplefmt.h>
}
#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avcodec.lib")

class Decoder
{
public:
    Decoder(std::string src_filename, std::string dst_audio_filename, std::string dst_video_filename);
    ~Decoder();

    // 解封装
    int demuxer();

    // 解码
    int decodec();

    // 打印音视频播放格式
    void print_audio_play_str();
private:
    // 打开解码器
    int open_decodec();

    // 解码pkt
    int decode_pkt(AVCodecContext* codec_ctx, AVPacket* pkt);

    // 输出视频帧
    int output_video_frame(AVFrame* frame);

    // 输出音频帧
    int output_audio_frame(AVFrame* frame);

    // 获取音频格式
    int get_format_from_sample_fmt(std::string& fmtStr, enum AVSampleFormat sample_fmt);
private:
    AVFormatContext* ifmt_ctx_;                    // 格式上下文
    AVCodecContext*  video_decode_ctx_;            // 视频解码器上下文
    AVCodecContext*  audio_decode_ctx_;            // 音频解码器上下文

    int video_idx_;                                // 视频索引                        
    AVStream* video_stream_;                    // 视频流

    int audio_idx_;                                // 音频索引
    AVStream* audio_stream_;                    // 音频流

    std::string src_filename_;                    // 输入文件路径
    std::string dst_audio_filename_;            // 输出音频pcm文件路径
    std::string dst_video_filename_;            // 输出视频yuv路径                            
    FILE* dst_video_fp_;
    FILE* dst_audio_fp_;

    AVFrame* frame_;
    uint8_t* video_dst_data_[4];                // 记录video一行数据
    int video_dst_buf_size_;                    // 分配的真实buf大小 
    int linesize_[4];                            // 每行数据大小（YUV RGB 第四个为保留字段）
};

Decoder::Decoder(std::string src_filename, std::string dst_audio_filename, std::string dst_video_filename)
: ifmt_ctx_(nullptr)
, video_decode_ctx_(nullptr)
, audio_decode_ctx_(nullptr)
, video_stream_(nullptr)
, audio_stream_(nullptr)
, dst_video_fp_(nullptr)
, dst_audio_fp_(nullptr)
, frame_(nullptr)
, src_filename_(src_filename)
, dst_audio_filename_(dst_audio_filename)
, dst_video_filename_(dst_video_filename)
{
    for (int i = 0; i < 4; i++)
    {
        video_dst_data_[i] = NULL;
    }
}

Decoder::~Decoder()
{
    // 释放相关资源
    if (ifmt_ctx_)
    {
        avformat_close_input(&ifmt_ctx_);
    }
    if (audio_decode_ctx_)
    {
        avcodec_free_context(&audio_decode_ctx_);
    }
    if (video_decode_ctx_)
    {
        avcodec_free_context(&video_decode_ctx_);
    }
    if (dst_audio_fp_)
    {
        fclose(dst_audio_fp_);
    }    
    if (dst_video_fp_)
    {
        fclose(dst_video_fp_);
    }
    if (frame_)
    {
        av_frame_free(&frame_);
    }
    if (video_dst_data_)
    {
        av_free(video_dst_data_[0]);    // 释放数据指针(其它三个指针无需释放) data[0]指向缓冲区开始位置，data[1] - data[3]也是指向data[0]的数据指针
    }
}

int Decoder::demuxer()
{
    // 1. 打开文件
    int nRet = avformat_open_input(&ifmt_ctx_, src_filename_.c_str(), NULL, NULL);
    if (nRet < 0)
    {
        LOG_WARNING("avformat_open_input error\n");
        return -1;
    }

    // 2. 查找流信息
    nRet = avformat_find_stream_info(ifmt_ctx_, NULL);
    if (nRet < 0)
    {
        avformat_close_input(&ifmt_ctx_);
        LOG_WARNING("avformat_find_stream_info error\n");
        return -2;
    }

    // 3. 获取音视频流索引
    audio_idx_ = av_find_best_stream(ifmt_ctx_, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
    video_idx_ = av_find_best_stream(ifmt_ctx_, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);

    return 0;
}

int Decoder::open_decodec()
{
    // 打开音频解码器
    if (audio_idx_ >= 0)
    {
        audio_stream_ = ifmt_ctx_->streams[audio_idx_];
        // 查找解码器
        AVCodec* audio_decodec = avcodec_find_decoder(audio_stream_->codecpar->codec_id);
        if (!audio_decodec)
        {
            LOG_WARNING("avcodec_find_decoder error\n");
            return AVERROR(ENOMEM);
        }

        // 给解码上下文分配内存
        audio_decode_ctx_ = avcodec_alloc_context3(audio_decodec);
        if (!audio_decode_ctx_)
        {
            LOG_WARNING("avcodec_alloc_context3 error\n");
            return AVERROR(ENOMEM);
        }

        // 拷贝解码参数到解码上下文
        int nRet = avcodec_parameters_to_context(audio_decode_ctx_, audio_stream_->codecpar);
        if (nRet < 0)
        {
            LOG_WARNING("avcodec_parameters_to_context error\n");
            return -1;
        }
        // 打开解码器
        nRet = avcodec_open2(audio_decode_ctx_, audio_decodec, NULL);
        if (nRet < 0)
        {
            LOG_WARNING("avcodec_open2 error\n");
            return -2;
        }

        dst_audio_fp_ = fopen(dst_audio_filename_.c_str(), "wb");
        if (!dst_audio_fp_)
        {
            LOG_WARNING("fopen dst_audio_filename_ error\n");
            return -1;
        }
    }

    // 打开视频解码器
    if (video_idx_ >= 0)
    {
        video_stream_ = ifmt_ctx_->streams[video_idx_];
        // 查找解码器
        AVCodec* video_decodec = avcodec_find_decoder(video_stream_->codecpar->codec_id);
        if (!video_decodec)
        {
            LOG_WARNING("avcodec_find_decoder error\n");
            return AVERROR(ENOMEM);
        }

        // 给解码上下文分配内存
        video_decode_ctx_ = avcodec_alloc_context3(video_decodec);
        if (!video_decode_ctx_)
        {
            LOG_WARNING("avcodec_alloc_context3 error\n");
            return AVERROR(ENOMEM);
        }

        // 拷贝解码参数到解码上下文
        int nRet = avcodec_parameters_to_context(video_decode_ctx_, video_stream_->codecpar);
        if (nRet < 0)
        {
            LOG_WARNING("avcodec_parameters_to_context error\n");
            return -1;
        }
        // 打开解码器
        nRet = avcodec_open2(video_decode_ctx_,video_decodec, NULL);
        if (nRet < 0)
        {
            LOG_WARNING("avcodec_open2 error\n");
            return -2;
        }

        video_dst_buf_size_ = av_image_alloc(video_dst_data_, linesize_,
            video_decode_ctx_->width, video_decode_ctx_->height, video_decode_ctx_->pix_fmt, 1);

        dst_video_fp_ = fopen(dst_video_filename_.c_str(), "wb");
        if (!dst_video_fp_)
        {
            LOG_WARNING("fopen dst_video_filename_ error\n");
            return -1;
        }
    }
}

int Decoder::decodec()
{
    // 打开解码器
    int nRet = open_decodec();
    if (nRet < 0)
    {
        LOG_WARNING("open_decodec error\n");
        return -666;
    }

    AVPacket* pkt = av_packet_alloc();
    av_init_packet(pkt);
    pkt->data = NULL;
    pkt->size = 0;

    while (av_read_frame(ifmt_ctx_, pkt) >= 0)
    {
        if (pkt->stream_index == audio_idx_)    // 音频包
        {
            nRet = decode_pkt(audio_decode_ctx_, pkt);
        }
        else if (pkt->stream_index == video_idx_) // 视频包
        {
            nRet = decode_pkt(video_decode_ctx_, pkt);
        }
        av_packet_unref(pkt);
        if (nRet < 0)
        {
            break;
        }
    }

    // 冲刷解码器
    if (video_decode_ctx_)
    {
        decode_pkt(video_decode_ctx_, NULL);
    }
    if (audio_decode_ctx_)
    {
        decode_pkt(video_decode_ctx_, NULL);
    }
    return 0;
}

int Decoder::decode_pkt(AVCodecContext* codec_ctx, AVPacket* pkt)
{
    int nRet = avcodec_send_packet(codec_ctx, pkt);
    if (nRet < 0)
    {
        LOG_WARNING("avcodec_send_packet fflush codec\n");
        return -1;
    }

    // 一个包可能对应多个frame
    frame_ = av_frame_alloc();
    while (nRet >= 0)
    {
        nRet = avcodec_receive_frame(codec_ctx, frame_);
        if (nRet < 0)
        {
            if (nRet == AVERROR_EOF || nRet == AVERROR(EAGAIN))
                return 0;
            return nRet;
        }
        // 写数据
        if (codec_ctx->codec->type == AVMEDIA_TYPE_AUDIO)
        {
            nRet = output_audio_frame(frame_);
        }
        else if (codec_ctx->codec->type == AVMEDIA_TYPE_VIDEO)
        {
            nRet = output_video_frame(frame_);
        }
        av_frame_unref(frame_);
        if (nRet < 0)
            return nRet;
    }
}

int Decoder::output_video_frame(AVFrame* frame)
{
    if (video_dst_buf_size_ < 0)
    {
        LOG_WARNING("av_image_alloc error\n");
        return -2;
    }
    // 写入帧到文件
    if (frame->width != video_decode_ctx_->width ||
        frame->height != video_decode_ctx_->height ||
        frame->format != video_decode_ctx_->pix_fmt)
    {
        LOG_WARNING("frame and video_decode_ctx_ error\n");
        return -3;
    }
    // 填充数据到 video_dst_data
    av_image_copy(video_dst_data_, linesize_,
        (const uint8_t**)(frame->data), frame->linesize,
        video_decode_ctx_->pix_fmt, video_decode_ctx_->width, video_decode_ctx_->height);
    size_t write_video_size = fwrite(video_dst_data_[0], 1, video_dst_buf_size_, dst_video_fp_);
    fflush(dst_video_fp_);
    return 0;
}

int Decoder::output_audio_frame(AVFrame* frame)
{
    // 计算一帧音频数据的bytes
    size_t a_sample_point_bytes = frame->nb_samples * av_get_bytes_per_sample((AVSampleFormat)frame->format);
    // 写入数据到文件
    fwrite(frame->extended_data[0], 1, a_sample_point_bytes, dst_audio_fp_);
    fflush(dst_audio_fp_);
    return 0;
}

int Decoder::get_format_from_sample_fmt(std::string& fmtStr, enum AVSampleFormat sample_fmt)
{
    struct sample_fmt_entry {
        enum AVSampleFormat sample_fmt; 
        std::string fmt_be;
        std::string fmt_le;
    } sample_fmt_entries[] = {
        { AV_SAMPLE_FMT_U8, "u8", "u8" },
        { AV_SAMPLE_FMT_S16, "s16be", "s16le" },
        { AV_SAMPLE_FMT_S32, "s32be", "s32le" },
        { AV_SAMPLE_FMT_FLT, "f32be", "f32le" },
        { AV_SAMPLE_FMT_DBL, "f64be", "f64le" },
    };

    for (int i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) {
        struct sample_fmt_entry *entry = &sample_fmt_entries[i];
        if (sample_fmt == entry->sample_fmt) {
            fmtStr = AV_NE(entry->fmt_be, entry->fmt_le);
            return 0;
        }
    }

    fprintf(stderr, "sample format %s is not supported as output format\n", av_get_sample_fmt_name(sample_fmt));
    return -1;
}

void Decoder::print_audio_play_str()
{
    if (audio_stream_) {
        enum AVSampleFormat sfmt = audio_decode_ctx_->sample_fmt;
        int n_channels = audio_decode_ctx_->channels;
        std::string fmtStr;

        if (av_sample_fmt_is_planar(sfmt))    // 是planar格式
        {
            const char *packed = av_get_sample_fmt_name(sfmt);
            LOG_INFO("Warning: the sample format the decoder produced is planar "
                "(%s). This example will output the first channel only.\n",
                packed ? packed : "?");
            sfmt = av_get_packed_sample_fmt(sfmt);
            n_channels = 1;
        }

        int ret = -1;
        if ((ret = get_format_from_sample_fmt(fmtStr, sfmt)) < 0)
            return;

        LOG_INFO("Play the output audio file with the command:\n"
            "ffplay -f %s -ac %d -ar %d %s\n",
            fmtStr.c_str(), n_channels, audio_decode_ctx_->sample_rate,
            dst_audio_filename_.c_str());

        LOG_INFO("play video yuv:\nffplay -video_size %dx%d -f rawvideo -pixel_format yuv420p %s",
            video_decode_ctx_->width, video_decode_ctx_->height, dst_video_filename_.c_str());
    }
}

int main()
{
    std::string src_filename = "./MediaFile/HTA_13s.mp4";    // input_5s
    std::string dst_audio_filename = "./MediaFile/HTA_13s_decodec_audio.pcm"; // HTA_13s_decodec_audio
    std::string dst_video_filename = "./MediaFile/HTA_13s_decodec_video.yuv"; // HTA_13s_decodec_video

    Decoder decoder(src_filename, dst_audio_filename, dst_video_filename);
    // 解复用
    int nRet = decoder.demuxer();
    if (nRet < 0)
    {
        LOG_WARNING("main demuxer error\n");
        return -666;
    }
    // 解码写入到文件
    nRet = decoder.decodec();
    if (nRet < 0)
    {
        LOG_WARNING("main decodec error\n");
        return -777;
    }

    LOG_INFO("decode finish, write file success\n");
    decoder.print_audio_play_str();

    getchar();
    return 0;
}

注意：使用av_image_alloc为一个char* data[4]的数组分配内存时，其内部只是为data[0]分配内存，其余的data[1] - data[3]指针指向data[0]的某个位置（根据像素格式的不同）