FFmpeg 与 C++ 构建音视频处理全链路实战（一）—— 环境配置与视频解封装

在数字媒体的浩瀚宇宙中，FFmpeg 就像一艘功能强大的星际战舰，承载着处理音视频数据的重任。而 C++ 作为一门高效、灵活的编程语言，犹如一位技艺精湛的星际工程师，能够精准操控 FFmpeg 战舰，完成各类复杂的音视频处理任务。本系列文章将带领你深入探索 FFmpeg 与 C++ 结合进行音视频衍生品开发的全过程，涵盖视频解封装、解码、封装、编码，视频尺寸变化，音频重采样等核心功能，为你揭开数字媒体开发的神秘面纱。

一、FFmpeg 与 C++ 的相遇：开启数字媒体开发之门

FFmpeg 是一套功能强大的开源音视频处理库，它几乎支持市面上所有的音视频格式，能够实现解封装、解码、编码、封装等一系列操作。从常见的 MP4、FLV 视频格式，到复杂的 H.264、H.265 编码标准，FFmpeg 都能轻松应对。而 C++ 语言以其高效的执行效率、强大的内存管理能力和面向对象的特性，成为与 FFmpeg 协作开发的理想选择。通过 C++ 调用 FFmpeg 的 API，我们可以构建出各种音视频处理应用，如视频播放器、视频编辑器、直播推流工具等。

在开始开发之前，我们需要先搭建开发环境，将 FFmpeg 库集成到 C++ 项目中。这就好比为星际工程师配备好专业的工具，以便后续的工作顺利开展。

首先安装qt和Vistual Studio，我使用的是windows11系统，安装的是QT6.7.3和Vistual Studio2022，配置好后进入FFmpeg官网下载编译好的库文件即可。

qt和Vistual Studio安装参考: VS+Qt —Vistual Studio 2022+Qt6安装教程以及解决Qt Vistual Studio Tools下载慢和VS无法打开.ui进行设计的问题FFmpeg下载安装参考：

【Windows】FFmpeg安装教程_ffmpeg win7-CSDN博客

我的ffmpeg直接使用夏曹俊老师提供的工程文档(FFmpeg4.2.1 SDK库): FFmpeg中文网站 中文教程 Android 安卓 @-ffmpeg sdk download 视频课程 中文教程 夏曹俊 老夏课堂

 文件结构如图：

我们打开Vistual Studio，创建一个控制台程序，创建路径设置到上图中的src内部，项目名称设定为firsttest，再firsttest.cpp中输入以下代码:

#include <iostream>
using namespace std;
extern "C"//c语言库c++程序引用
{
    #include <libavcodec/avcodec.h>
}
//预处理指令导入库
#pragma comment(lib,"avcodec.lib")

int main()
{
    std::cout << "First Test FFmpeg!\n";
    cout << avcodec_configuration() << endl;
    getchar();
    return 0;
}

 再解决方案资源管理器中右击本项目，点击属性：

再常规中设置输出目录如图

 点击调试，设置工作目录，这是为了本地调试时项目能找到动态库。

 再C/C++中设置附加包含目录，让程序能找到头文件

 再链接器中设置库文件路径，对于编译过程中的链接库，由于程序希望能跨平台，这里直接用预处理指令进行库的链接（#pragma comment(lib,"avcodec.lib")）

 设置好后点击本地调试器，输出如下则环境备好了

我们在学习编解码的过程中会一层层剥开视频封装，在这个过程中会产生各种各样格式的文件：aac裸流文件，h264裸流文件，pcm流文件，yuv流文件等等，这时我们就需要一个合适的能够播放各种格式文件的播放器来验证我们所产生的文件是否正确并能够正常播放。

进入vlc官网 ：VLC: Official site - Free multimedia solutions for all OS! - VideoLAN

点击下载安装即可。

海康威视YUV播放器：

二、解封装：探索音视频数据的 “包裹”

视频文件就像是一个个精心包装的包裹，里面封装着音频和视频数据。解封装的过程，就是打开这个包裹，将音频和视频数据分别提取出来。在 FFmpeg 中，通过avformat_open_input函数打开视频文件，然后使用avformat_find_stream_info函数获取文件的流信息，包括视频流和音频流的数量、编码格式等。

我们在之前的深入解析 FLV 封装格式：流媒体世界的轻骑兵一文中详细介绍过FLV 文件格式包含了文件头、标签等结构，解封装时需要按照其特定的格式解析出音视频数据。对于 MP4我们之前的文章剥开 MP4 的 千层 “数字洋葱”：从外到内拆解通用媒体容器的核心详细介绍了其封装结构，对于mp4与flv解封装过程和解析方式有所不同。

通过遍历流信息，我们可以找到视频流和音频流，并分别获取它们的相关参数。例如，对于视频流，我们可以获取到视频的宽度、高度、帧率等信息；对于音频流，可以获取到采样率、声道数等信息。这些信息对于后续的处理至关重要，就像星际工程师在执行任务前需要了解目标的详细参数一样。

现在，我们将用代码实现将视频文件解封装，并将其拆解为 AAC 音频文件和 H.264 视频文件，下面结合具体代码，深入剖析每一行代码的功能与作用：

（一）文件与变量初始化

const char* in_filename = "baseball.mp4";
const char* aac_filename = "baseball.aac";
const char* h264_filename = "baseball.h264";
FILE* aac_fd = NULL;
FILE* h264_fd = NULL;

AVFormatContext* ifmt_ctx = NULL;
AVPacket* pkt = NULL;

int video_index = -1;
int audio_index = -1;

int ret = 0;
char errors[ERROR_STRING_SIZE + 1];

首先定义了输入的 MP4 文件名in_filename，以及输出的 AAC 音频文件名aac_filename和 H.264 视频文件名h264_filename。接着声明了用于操作文件的文件指针aac_fd和h264_fd，以及 FFmpeg 中用于存储媒体文件格式信息的AVFormatContext指针ifmt_ctx，和用于存储音视频数据的AVPacket指针pkt。video_index和audio_index用于记录视频流和音频流在文件中的索引，ret用于存储函数调用的返回值，errors数组用于存储错误信息 

（二）打开输入文件与获取流信息

ret = fopen_s(&aac_fd,aac_filename, "wb");
if (ret < 0)
{
    printf("fopen %s failed\n", h264_filename);
    return -1;
}
ret = fopen_s(&h264_fd, h264_filename, "wb");
if (ret < 0)
{
    printf("fopen %s failed\n", h264_filename);
    return -1;
}

ret = avformat_open_input(&ifmt_ctx, in_filename, NULL, NULL);
if (ret < 0)
{
    av_strerror(ret, errors, ERROR_STRING_SIZE);
    printf("avformat_open_input failed:%d\n", ret);
    printf("avformat_open_input failed:%s\n", errors);
    avformat_close_input(&ifmt_ctx);
    return - 1;
}

ret = avformat_find_stream_info(ifmt_ctx, NULL);
if (ret < 0)
{
    av_strerror(ret, errors, ERROR_STRING_SIZE);
    printf("avformat_find_stream_info failed:%d\n", ret);
    printf("avformat_find_stream_info failed:%s\n", errors);
    avformat_close_input(&ifmt_ctx);
    return -1;
}

使用fopen_s函数分别打开用于写入 AAC 音频和 H.264 视频的文件，如果打开失败则输出错误信息并退出程序。

然后调用avformat_open_input函数打开输入的 MP4 文件，并将文件格式信息存储到ifmt_ctx中。如果打开失败，使用av_strerror获取错误信息并打印，关闭输入上下文后退出。接着调用avformat_find_stream_info函数获取文件中的流信息，同样在失败时进行错误处理。

 （三）获取视频流和音频流索引

video_index = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
if (video_index == -1) {
    printf("av_find_best_stream video_index failed\n");
    avformat_close_input(&ifmt_ctx);
    return -1;
}
std::cout << "video_index = " << video_index << std::endl;
audio_index = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
if (audio_index == -1) {
    printf("av_find_best_stream audio_index failed\n");
    avformat_close_input(&ifmt_ctx);
    return -1;
}
std::cout << "audio_index = " << audio_index << std::endl;

av_find_best_stream是ffmpeg新版本引入的函数，该函数用于分别查找视频流和音频流的索引。该函数会在文件的流信息中搜索指定类型（视频或音频）的最佳流，并返回其索引。如果查找失败，输出错误信息，关闭输入上下文后退出。找到索引后，将其打印到控制台，方便我们查看。

在ffmpeg就版本中，可以使用以下方法查找流索引并打印音视频流关键信息：

for (size_t i = 0; i < ifmt_ctx->nb_streams; i++)
{
    AVStream* in_stream = ifmt_ctx->streams[i];
    if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
    {
        std::cout << "=========================Audio inf=========================" << std::endl;
        audio_index = i;
        std::cout << "audio_index = " << audio_index << std::endl;
        std::cout << "Sample Rate: " << in_stream->codecpar->sample_rate << std::endl;
        if (in_stream->codecpar->format == AV_SAMPLE_FMT_FLTP)
        {
            std::cout << "sampleformat:AV_SAMPLE_FMT_FLTP" << std::endl;
        }
        else if (in_stream->codecpar->format == AV_SAMPLE_FMT_S16P)
        {
            std::cout << "sampleformat:AV_SAMPLE_FMT_S16P" << std::endl;
        }
        std::cout << "channles: " << in_stream->codecpar->channels << std::endl;
        if (in_stream->codecpar->codec_id == AV_CODEC_ID_AAC)
        {
            std::cout << "audio codec:AAC" << std::endl;
        }
        else if (in_stream->codecpar->codec_id == AV_CODEC_ID_MP3)
        {
            std::cout << "audio codec:MP3" << std::endl;

        }
        else
        {
            std::cout << "audio codec_id: " << in_stream->codecpar->codec_id << std::endl;
        }
        if (in_stream->duration != AV_NOPTS_VALUE)
        {
            int duration_audio = (in_stream->duration) * av_q2d(in_stream->time_base);
            printf("audio duration: %02d:%02d:%02d\n",
                duration_audio / 3600, (duration_audio % 3600) / 60, (duration_audio % 60));
        }
        else
        {
            printf("audio duration unknown");
        }
    }
    else if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
    {
        std::cout << "=========================Video inf=========================" << std::endl;
        video_index = i;
        std::cout << "video_index = " << video_index << std::endl;
        std::cout << "fps: " << av_q2d(in_stream->avg_frame_rate) << std::endl;
        std::cout << "width: " << in_stream->codecpar->width << " height: " << in_stream->codecpar->height << std::endl;
        if (in_stream->codecpar->codec_id == AV_CODEC_ID_MPEG4)
        {
            std::cout << "video codec:MPEG4" << std::endl;
        }
        else if (in_stream->codecpar->codec_id == AV_CODEC_ID_H264)
        {
            std::cout << "video codec:H264" << std::endl;

        }
        else
        {
            std::cout << "video codec: " << in_stream->codecpar->codec_id << std::endl;
        }

        if (in_stream->duration != AV_NOPTS_VALUE)
        {
            int duration_video = (in_stream->duration) * av_q2d(in_stream->time_base);
            printf("video duration: %02d:%02d:%02d\n",
                duration_video / 3600,
                (duration_video % 3600) / 60,
                (duration_video % 60)); //将视频总时长转换为时分秒的格式打印到控制台上
        }
        else
        {
            printf("video duration unknown");
        }
    }
}

（四）初始化 H.264 比特流过滤器

const AVBitStreamFilter* bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
if (!bsfilter) {
    avformat_close_input(&ifmt_ctx);
    printf("av_bsf_get_by_name h264_mp4toannexb failed\n");
    return -1;
}
AVBSFContext* bsf_ctx = NULL;
ret = av_bsf_alloc(bsfilter, &bsf_ctx);
if (ret < 0) {
    av_strerror(ret, errors, ERROR_STRING_SIZE);
    printf("av_bsf_alloc failed:%s\n", errors);
    avformat_close_input(&ifmt_ctx);
    return -1;
}
ret = avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[video_index]->codecpar);
if (ret < 0) {
    av_strerror(ret, errors, ERROR_STRING_SIZE);
    printf("avcodec_parameters_copy failed:%s\n", errors);
    avformat_close_input(&ifmt_ctx);
    av_bsf_free(&bsf_ctx);
    return -1;
}
ret = av_bsf_init(bsf_ctx);
if (ret < 0) {
    av_strerror(ret, errors, ERROR_STRING_SIZE);
    printf("av_bsf_init failed:%s\n", errors);
    avformat_close_input(&ifmt_ctx);
    av_bsf_free(&bsf_ctx);
    return -1;
}
std::cout << "AVBitStreamFilter init done!" << std::endl;

由于从 MP4 文件中提取的 H.264 视频流格式需要转换为符合标准的 Annex B 格式（添加 SPS/PPS 等信息），所以这里初始化了一个 H.264 比特流过滤器。首先通过av_bsf_get_by_name获取名为h264_mp4toannexb的比特流过滤器，然后使用av_bsf_alloc分配过滤器上下文，将输入视频流的编码参数复制到过滤器上下文中，并调用av_bsf_init初始化过滤器。每一步操作都进行了错误处理，确保过滤器正确初始化。

 （五）读取并处理音视频数据包

pkt = av_packet_alloc();
av_init_packet(pkt);
while (1)
{
    ret = av_read_frame(ifmt_ctx, pkt);
    if (ret < 0) {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("av_read_frame failed:%s\n", errors);
        break;
    }
    if (pkt->stream_index == audio_index)
    {
        // 处理音频
        char adts_header_buf[7] = { 0 };
        adts_header(adts_header_buf, pkt->size,
            ifmt_ctx->streams[audio_index]->codecpar->profile,
            ifmt_ctx->streams[audio_index]->codecpar->sample_rate,
            ifmt_ctx->streams[audio_index]->codecpar->channels);
        fwrite(adts_header_buf, 1, 7, aac_fd);
        size_t size = fwrite(pkt->data, 1, pkt->size, aac_fd);
        if (size != pkt->size)
        {
            av_log(NULL, AV_LOG_DEBUG, "aac warning, length of writed data isn't equal pkt->size(%d, %d)\n",
                size,
                pkt->size);
        }
        av_packet_unref(pkt);
    }
    else if (pkt->stream_index == video_index)
    {
        // 处理视频
        ret = av_bsf_send_packet(bsf_ctx, pkt);
        if (ret < 0) {
            av_strerror(ret, errors, ERROR_STRING_SIZE);
            printf("av_bsf_send_packet failed:%s\n", errors);
            av_packet_unref(pkt);
            continue;
        }
        while (1) {
            ret = av_bsf_receive_packet(bsf_ctx, pkt);
            if (ret != 0) {
                break;
            }
            size_t size = fwrite(pkt->data, 1, pkt->size, h264_fd);
            if (size != pkt->size)
            {
                av_log(NULL, AV_LOG_DEBUG, "h264 warning, length of writed data isn't equal pkt->size(%d, %d)\n",
                    size,
                    pkt->size);
            }
            av_packet_unref(pkt);
        }
    }
    else
    {
        av_packet_unref(pkt);
    }
}

首先使用av_packet_alloc和av_init_packet分配并初始化一个AVPacket对象，用于存储读取到的音视频数据包。

在一个无限循环中，调用av_read_frame从输入文件中读取一个数据包。如果读取失败，获取错误信息并退出循环。

当读取到的数据包的流索引与音频流索引相同时，调用adts_header函数（具体实现见附录）生成 ADTS 头部信息，将头部信息和音频数据写入 AAC 输出文件。如果写入的数据长度与数据包长度不一致，打印警告信息。最后使用av_packet_unref释放数据包的引用计数。

当数据包的流索引与视频流索引相同时，将数据包发送到 H.264 比特流过滤器进行格式转换，然后通过循环接收转换后的数据包，并将其写入 H.264 输出文件。同样在写入长度不一致时打印警告信息，处理完后释放数据包。

对于其他流索引的数据包，直接释放引用计数。

（六）资源释放与程序结束

if (aac_fd)
    fclose(aac_fd);
if (h264_fd)
    fclose(h264_fd);
if (bsf_ctx)
    av_bsf_free(&bsf_ctx);
if (pkt)
    av_packet_free(&pkt);
if (ifmt_ctx)
    avformat_close_input(&ifmt_ctx);
getchar();
return 0;

在程序结束前，依次关闭打开的 AAC 和 H.264 文件，释放比特流过滤器上下文、数据包和输入格式上下文占用的资源，确保没有内存泄漏和文件资源未关闭的情况。最后通过getchar()等待用户输入（防止控制台窗口一闪而过），然后返回 0 表示程序正常结束。

（七）打印结果并测试输出文件

进入项目文件夹下的bin\win64下找到长生的AAC和H.264文件，用VLC播放测试：

附录

ADTS格式可以参考：深入探索 AAC 编码原理与 ADTS 格式：音频世界的智慧结晶-CSDN博客

完整代码如下：

#include <iostream>
#include <stdio.h>
extern "C"
{
    #include <libavformat/avformat.h>
}
#pragma comment(lib,"avformat.lib")
#pragma comment(lib,"avutil.lib")
#pragma comment(lib,"avcodec.lib")

#define ADTS_HEADER_LEN  7
#define ERROR_STRING_SIZE 1024

const int sampling_frequencies[] = {
    96000,  // 0x0
    88200,  // 0x1
    64000,  // 0x2
    48000,  // 0x3
    44100,  // 0x4
    32000,  // 0x5
    24000,  // 0x6
    22050,  // 0x7
    16000,  // 0x8
    12000,  // 0x9
    11025,  // 0xa
    8000   // 0xb
    // 0xc d e f是保留的
};

int adts_header(char* const p_adts_header, const int data_length,
    const int profile, const int samplerate,
    const int channels)
{

    int sampling_frequency_index = 3; // 默认使用48000hz
    int adtsLen = data_length + 7;

    int frequencies_size = sizeof(sampling_frequencies) / sizeof(sampling_frequencies[0]);
    int i = 0;
    for (i = 0; i < frequencies_size; i++)
    {
        if (sampling_frequencies[i] == samplerate)
        {
            sampling_frequency_index = i;
            break;
        }
    }
    if (i >= frequencies_size)
    {
        printf("unsupport samplerate:%d\n", samplerate);
        return -1;
    }

    p_adts_header[0] = 0xff;         //syncword:0xfff                          高8bits
    p_adts_header[1] = 0xf0;         //syncword:0xfff                          低4bits
    p_adts_header[1] |= (0 << 3);    //MPEG Version:0 for MPEG-4,1 for MPEG-2  1bit
    p_adts_header[1] |= (0 << 1);    //Layer:0                                 2bits
    p_adts_header[1] |= 1;           //protection absent:1                     1bit

    p_adts_header[2] = (profile) << 6;            //profile:profile               2bits
    p_adts_header[2] |= (sampling_frequency_index & 0x0f) << 2; //sampling frequency index:sampling_frequency_index  4bits
    p_adts_header[2] |= (0 << 1);             //private bit:0                   1bit
    p_adts_header[2] |= (channels & 0x04) >> 2; //channel configuration:channels  高1bit

    p_adts_header[3] = (channels & 0x03) << 6; //channel configuration:channels 低2bits
    p_adts_header[3] |= (0 << 5);               //original：0                1bit
    p_adts_header[3] |= (0 << 4);               //home：0                    1bit
    p_adts_header[3] |= (0 << 3);               //copyright id bit：0        1bit
    p_adts_header[3] |= (0 << 2);               //copyright id start：0      1bit
    p_adts_header[3] |= ((adtsLen & 0x1800) >> 11);           //frame length：value   高2bits

    p_adts_header[4] = (uint8_t)((adtsLen & 0x7f8) >> 3);     //frame length:value    中间8bits
    p_adts_header[5] = (uint8_t)((adtsLen & 0x7) << 5);       //frame length:value    低3bits
    p_adts_header[5] |= 0x1f;                                 //buffer fullness:0x7ff 高5bits
    p_adts_header[6] = 0xfc;      //‭11111100‬       //buffer fullness:0x7ff 低6bits
    // number_of_raw_data_blocks_in_frame：
    //    表示ADTS帧中有number_of_raw_data_blocks_in_frame + 1个AAC原始帧。

    return 0;
}

int main(int argc, char* argv[])
{
    const char* in_filename = "baseball.mp4";
    const char* aac_filename = "baseball.aac";
    const char* h264_filename = "baseball.h264";
    FILE* aac_fd = NULL;
    FILE* h264_fd = NULL;

    AVFormatContext* ifmt_ctx = NULL;
    AVPacket* pkt = NULL;

    int video_index = -1;
    int audio_index = -1;

    int ret = 0;
    char errors[ERROR_STRING_SIZE + 1];

    ret = fopen_s(&aac_fd,aac_filename, "wb");
    if (ret < 0)
    {
        printf("fopen %s failed\n", h264_filename);
        return -1;
    }
    ret = fopen_s(&h264_fd, h264_filename, "wb");
    if (ret < 0)
    {
        printf("fopen %s failed\n", h264_filename);
        return -1;
    }

    ret = avformat_open_input(&ifmt_ctx, in_filename, NULL, NULL);
    if (ret < 0)
    {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("avformat_open_input failed:%d\n", ret);
        printf("avformat_open_input failed:%s\n", errors);
        avformat_close_input(&ifmt_ctx);
        return - 1;
    }

    ret = avformat_find_stream_info(ifmt_ctx, NULL);
    if (ret < 0)
    {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("avformat_find_stream_info failed:%d\n", ret);
        printf("avformat_find_stream_info failed:%s\n", errors);
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    std::cout << "===========================dump information begin==============================" << std::endl;
    av_dump_format(ifmt_ctx, 0, in_filename, 0);
    std::cout << "============================dump information end===============================" << std::endl;

    std::cout << "stream_nums: " << ifmt_ctx->nb_streams << std::endl;
    std::cout << "average ratios: " << ifmt_ctx->bit_rate << std::endl;
    std::cout << "video codec id: " << ifmt_ctx->video_codec_id << std::endl;
    std::cout << "audio codec id: " << ifmt_ctx->audio_codec_id << std::endl;

    int total_seconds, hours, mins, secs;
    total_seconds = (ifmt_ctx->duration) / AV_TIME_BASE;
    hours = total_seconds / 3600;
    mins = (total_seconds % 3600) / 60;
    secs = (total_seconds % 60);
    std::cout << "total duration: " << hours << ":" << mins << ":" << secs << std::endl;
    //查找流索引方法1
    video_index = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if (video_index == -1) {
        printf("av_find_best_stream video_index failed\n");
        avformat_close_input(&ifmt_ctx);
        return -1;
    }
    std::cout << "video_index = " << video_index << std::endl;
    audio_index = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
    if (audio_index == -1) {
        printf("av_find_best_stream audio_index failed\n");
        avformat_close_input(&ifmt_ctx);
        return -1;
    }
    std::cout << "audio_index = " << audio_index << std::endl;
    //查找流索引方法2
    for (size_t i = 0; i < ifmt_ctx->nb_streams; i++)
    {
        AVStream* in_stream = ifmt_ctx->streams[i];
        if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
        {
            std::cout << "=========================Audio inf=========================" << std::endl;
            audio_index = i;
            std::cout << "audio_index = " << audio_index << std::endl;
            std::cout << "Sample Rate: " << in_stream->codecpar->sample_rate << std::endl;
            if (in_stream->codecpar->format == AV_SAMPLE_FMT_FLTP)
            {
                std::cout << "sampleformat:AV_SAMPLE_FMT_FLTP" << std::endl;
            }
            else if (in_stream->codecpar->format == AV_SAMPLE_FMT_S16P)
            {
                std::cout << "sampleformat:AV_SAMPLE_FMT_S16P" << std::endl;
            }
            std::cout << "channles: " << in_stream->codecpar->channels << std::endl;
            if (in_stream->codecpar->codec_id == AV_CODEC_ID_AAC)
            {
                std::cout << "audio codec:AAC" << std::endl;
            }
            else if (in_stream->codecpar->codec_id == AV_CODEC_ID_MP3)
            {
                std::cout << "audio codec:MP3" << std::endl;

            }
            else
            {
                std::cout << "audio codec_id: " << in_stream->codecpar->codec_id << std::endl;
            }
            if (in_stream->duration != AV_NOPTS_VALUE)
            {
                int duration_audio = (in_stream->duration) * av_q2d(in_stream->time_base);
                printf("audio duration: %02d:%02d:%02d\n",
                    duration_audio / 3600, (duration_audio % 3600) / 60, (duration_audio % 60));
            }
            else
            {
                printf("audio duration unknown");
            }
        }
        else if (in_stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            std::cout << "=========================Video inf=========================" << std::endl;
            video_index = i;
            std::cout << "video_index = " << video_index << std::endl;
            std::cout << "fps: " << av_q2d(in_stream->avg_frame_rate) << std::endl;
            std::cout << "width: " << in_stream->codecpar->width << " height: " << in_stream->codecpar->height << std::endl;
            if (in_stream->codecpar->codec_id == AV_CODEC_ID_MPEG4)
            {
                std::cout << "video codec:MPEG4" << std::endl;
            }
            else if (in_stream->codecpar->codec_id == AV_CODEC_ID_H264)
            {
                std::cout << "video codec:H264" << std::endl;

            }
            else
            {
                std::cout << "video codec: " << in_stream->codecpar->codec_id << std::endl;
            }

            if (in_stream->duration != AV_NOPTS_VALUE)
            {
                int duration_video = (in_stream->duration) * av_q2d(in_stream->time_base);
                printf("video duration: %02d:%02d:%02d\n",
                    duration_video / 3600,
                    (duration_video % 3600) / 60,
                    (duration_video % 60)); //将视频总时长转换为时分秒的格式打印到控制台上
            }
            else
            {
                printf("video duration unknown");
            }
        }
    }

    // 1 获取相应的比特流过滤器
    //FLV/MP4/MKV等结构中，h264需要h264_mp4toannexb处理。添加SPS/PPS等信息。
    // FLV封装时，可以把多个NALU放在一个VIDEO TAG中,结构为4B NALU长度+NALU1+4B NALU长度+NALU2+...,
    // 需要做的处理把4B长度换成00000001或者000001
    const AVBitStreamFilter* bsfilter = av_bsf_get_by_name("h264_mp4toannexb");      // 对应面向对象的方法
    if (!bsfilter) {
        avformat_close_input(&ifmt_ctx);
        printf("av_bsf_get_by_name h264_mp4toannexb failed\n");
        return -1;
    }
    AVBSFContext* bsf_ctx = NULL;        // 对应面向对象的变量
    ret = av_bsf_alloc(bsfilter, &bsf_ctx);
    if (ret < 0) {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("av_bsf_alloc failed:%s\n", errors);
        avformat_close_input(&ifmt_ctx);
        return -1;
    }
    ret = avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[video_index]->codecpar);
    if (ret < 0) {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("avcodec_parameters_copy failed:%s\n", errors);
        avformat_close_input(&ifmt_ctx);
        av_bsf_free(&bsf_ctx);
        return -1;
    }
    ret = av_bsf_init(bsf_ctx);
    if (ret < 0) {
        av_strerror(ret, errors, ERROR_STRING_SIZE);
        printf("av_bsf_init failed:%s\n", errors);
        avformat_close_input(&ifmt_ctx);
        av_bsf_free(&bsf_ctx);
        return -1;
    }
    std::cout << "AVBitStreamFilter init done!" << std::endl;
    
    pkt = av_packet_alloc();
    av_init_packet(pkt);
    while (1)
    {
        std::cout << "*" << std::endl;
        ret = av_read_frame(ifmt_ctx, pkt);
        if (ret < 0) {
            av_strerror(ret, errors, ERROR_STRING_SIZE);
            printf("av_read_frame failed:%s\n", errors);
            break;
        }
        if (pkt->stream_index == audio_index)
        {
            // 处理音频
            char adts_header_buf[7] = { 0 };
            adts_header(adts_header_buf, pkt->size,
                ifmt_ctx->streams[audio_index]->codecpar->profile,
                ifmt_ctx->streams[audio_index]->codecpar->sample_rate,
                ifmt_ctx->streams[audio_index]->codecpar->channels);
            fwrite(adts_header_buf, 1, 7, aac_fd);  // 写adts header , ts流不适用，ts流分离出来的packet带了adts header
            size_t size = fwrite(pkt->data, 1, pkt->size, aac_fd);   // 写adts data
            if (size != pkt->size)
            {
                av_log(NULL, AV_LOG_DEBUG, "aac warning, length of writed data isn't equal pkt->size(%d, %d)\n",
                    size,
                    pkt->size);
            }
            av_packet_unref(pkt);
        }
        else if (pkt->stream_index == video_index)
        {
            // 处理视频
            ret = av_bsf_send_packet(bsf_ctx, pkt); // 内部把我们传入的buf转移到自己bsf内部
            if (ret < 0) {       // 基本不会进入该逻辑
                av_strerror(ret, errors, ERROR_STRING_SIZE);
                printf("av_bsf_send_packet failed:%s\n", errors);
                av_packet_unref(pkt);
                continue;
            }
            //            av_packet_unref(pkt); // 这里不需要去释放内存
            while (1) {
                ret = av_bsf_receive_packet(bsf_ctx, pkt);
                if (ret != 0) {
                    break;
                }
                size_t size = fwrite(pkt->data, 1, pkt->size, h264_fd);
                if (size != pkt->size)
                {
                    av_log(NULL, AV_LOG_DEBUG, "h264 warning, length of writed data isn't equal pkt->size(%d, %d)\n",
                        size,
                        pkt->size);
                }
                av_packet_unref(pkt);
            }
        }
        else
        {
                av_packet_unref(pkt);
        }
    }

    if (aac_fd)
        fclose(aac_fd);
    if (h264_fd)
        fclose(h264_fd);
    if (bsf_ctx)
        av_bsf_free(&bsf_ctx);
    if (pkt)
        av_packet_free(&pkt);
    if (ifmt_ctx)
        avformat_close_input(&ifmt_ctx);
    getchar();
    return 0;
}