1 解封装示意图

实例代码调用的示意图如下：

主要分成两部分，一部分是对于音频流进行处理，获取mp4文件中的音频数据，保存成AAC文件另外一部分则是对视频流进行处理，保存成h264文件。下文则分别对各个步骤进行说明。

2 MP4解封装

2.1 提取音频

一般ts文件解封装出来是带ADTS信息的，MP4文件解封装出来的音频是不附带ADTS头信息，对于没有带ADTS的文件，ffplays是播放不了的。因此，我们在提取音频信息时，需要手动加上ADTS头信息，形成ADTS帧。ADTS的头信息一般都是7个字节，分为两部分，一部分是固定头信息，一个是可变头信息。固定头信息中的数据的每一帧都相同，可变头信息则在帧与帧之间可变。可变头信息主要是包含了该ADTS帧的采样率，声道和帧长度等信息，其结构如下图所示。

下面是在本实验中添加adts_herder信息的，可以在ffplay中正常播放

不带ADTS头信息，不能正常播放。

2.2 提取视频

2.2.1 H264相关知识

H264使用帧内压缩和帧间压缩的方式提高编码压缩率，H264采用了独特的I帧、P帧和B帧的策略来实现连续帧之间的压缩。H264除了实现了对视频的压缩处理之外，为了方便网络传输，提供了对应的视频编码和分片策略。类似于网络数据封装成IP帧，在H264中将其称为组(GOP, group of pictures)、图片（picture）、片（slice)、宏块（Macroblock)、子块（subblock)这些一起组成了H264的码流分层结构。GOP主要用作形容一个IDR帧到下一个IDR帧之间间隔了多少个帧。

IDR(instantaneous Decoding Refresh,即时解码刷新），一个GOP的第一个图像叫做IDR图像，IDR图像都是I帧图像，但是I帧图像不一定是IDR图像。其核心作用是为了解码的重同步，当解码器解码到IDR图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找参数集，开始一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像的数据来进行解码。

NALU

NALU结构
H.264原始码流（裸流）是由一个接一个NALU组成，它的功能分为两层，VCL(视频编码层）和NAL(网络提取层）

• VCL :包括核心压缩引擎和块，宏块和片的语法级别定义，设计目标是尽可能的独立于网络进行高效的编码。
• NAL：负责将VCL产⽣的⽐特字符串适配到各种各样的⽹络和多元环境中，覆盖了所有⽚级以上的语法级别。

在VCL进⾏数据传输或存储之前，这些编码的VCL数据，被映射或封装进NAL单元。
NALU结构单元的主体结构如下所示；⼀个原始的H.264 NALU单元通常由[StartCode] [NALUHeader] [NALU Payload]三部分组成，其中 Start Code ⽤于标示这是⼀个NALU 单元的开始，必须是"00 00 00 01" 或"00 00 01"，除此之外基本相当于⼀个NAL header + RBSP。

H264有两种封装：

• ⼀种是annexb模式，传统模式，有startcode，SPS和PPS是在ES中
• 一 种是mp4模式，⼀般mp4 mkv都是mp4模式，没有startcode，SPS和PPS以及其它信息被封装在container中，每⼀个frame前⾯4个字节是这个frame的⻓度。

很多解码器只⽀持annexb这种模式，因此需要将mp4做转换：在ffmpeg中⽤h264_mp4toannexb_filter可以做转换。
本文中使用的MP4文件是mp4模式的，因此是不带startcode的，所以需要做转换。ts文件解封装出来时带startcoded的，本文主要使用h264_mp4toannexb_filter做转换。

 const AVBitStreamFilter *bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
 AVBSFContext *bsf_ctx = NULL;
 // 2 初始化过滤器上下⽂
 av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
 // 3 添加解码器属性
 avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->cod
ecpar);
 av_bsf_init(bsf_ctx);

代码展示

#include <stdio.h>
/**
 * @brief mp4文件解封装，并添加对应的头消息，将文件分别保存成aac和h264文件
 * 使用adts给aac裸流添加文件头，以防文件播放不了
 * MP4文件可能不包含SPS PPS等信息，也可能不包含分隔符号，
   所以需要使用AVBitStreamFilter来加上这些信息，方便解码
 * @return
 */

#include "libavutil/log.h"
#include "libavformat/avformat.h"

#define ERROR_STRNG_SIZE 1024

#define ADTS_HERDER_LEN 7

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; //48000
    int adtsLen = data_length +7;   //?为什么是+7，ADTS的头部信息总是占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                     1111 1111  位数不足则用0补齐
    p_adts_header[1] = 0xf0;                                            //syncword:0xfff                          低4bits                     前面的4bit是属于syncword，后面的才是重新赋值                     1111 0000
    p_adts_header[1] |= (0<< 3);                                        //MPEG Version:0 for MPEG-4,1 for MPEG-2  1bit                       |= 按位或后赋值 1111 0000  和 0000  = 1111 0000
    p_adts_header[1] |=  (0 <<1);                                       //Layer:0                                 2bits                       1111 0000 和 00
    p_adts_header[1] |= 1;                                              // protection absent:1   不校验                 1bit                      1111 00000 和 1  = 1111 0000   0000 0001=  1111 0001

    p_adts_header[2] = (profile <<6);                                   //profile:profile               2bits                    profile :1110 0011  左移6位 1100 0000
    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
    return 0;
}


int main(int argc ,char ** argv)
{
    
    if(argc != 4){
    
        printf("usage app : input.mp4 out.h264 out.aac");
        return -1;
    }

    char *in_filename = argv[1];
    char *h264_filename = argv[2];
    char *aac_filename = argv[3];
    FILE *aac_fd = NULL;
    FILE *h264_fd = NULL;

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

    AVFormatContext *ifmt_ctx = NULL;
    int video_index = -1;
    int audio_index = -1;
    AVPacket *pkt = NULL;
    int ret = 0;
    char errors[ERROR_STRNG_SIZE+1];     //用来缓存解析ffmpeg api 返回值错误的string

    ifmt_ctx =avformat_alloc_context();
    if(!ifmt_ctx)
    {
    
        printf("avformat_alloc_context failed \n");
        return -1;
    }

    ret = avformat_open_input(&ifmt_ctx,in_filename,NULL,NULL);
    if(ret < 0)
    {
    
        av_strerror(ret,errors,ERROR_STRNG_SIZE);
        printf("avformat_open_input failed:%d\n",ret);
        printf("avformat_open_input failed:%s\n",errors);
        avformat_close_input(&ifmt_ctx);
        //go failed;
        return -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;
    }

    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;
    }

    const AVBitStreamFilter *bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
    if(!bsfilter)
    {
    
        avformat_close_input(&ifmt_ctx);
        printf("av_bsf_get_by_name failed \n");
        return -1;
    }

    AVBSFContext *bsf_ctx = NULL;
    ret = av_bsf_alloc(bsfilter,&bsf_ctx);
    if(ret <0)
    {
    
        av_strerror(ret,errors,ERROR_STRNG_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_STRNG_SIZE);
        printf("avcodec_parameters_copy failed :%s \n",errors);
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    ret = av_bsf_init(bsf_ctx);
    if(ret <0)
    {
    
        av_strerror(ret,errors,ERROR_STRNG_SIZE);
        printf("av_bsf_init failed:%s\n",errors);
        avformat_close_input(&ifmt_ctx);
        return -1;
    }
    pkt = av_packet_alloc();
    av_init_packet(pkt);
    while(1)
    {
    
        ret = av_read_frame(ifmt_ctx,pkt);          //使用完记得释放pkt buf不然会出现内存泄漏
        if(ret < 0)
        {
    
            av_strerror(ret,errors,ERROR_STRNG_SIZE);
            printf("av_read_frame feailed:%s\n",errors);
            break;
        }

        if(pkt->stream_index == video_index)
        {
    
            //处理视频
            ret = av_bsf_send_packet(bsf_ctx,pkt);
            if(ret < 0)
            {
    
                av_strerror(ret,errors,ERROR_STRNG_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 WARING,length of writed data isn't equal pkt->size(%d,%d)\n",size,pkt->size);
                }
            }
            av_packet_unref(pkt);
        }
        else if(pkt->stream_index == audio_index)
        {
    
            //处理音频
            char adts_header_buf[7] = {
    0};
            //添加adts头部信息
            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);
            //写adts header
            fwrite(adts_header_buf,1,7,aac_fd);
            //写adts信息
            size_t size = fwrite(pkt->data,1,pkt->size,aac_fd);
            if(size != pkt->size)
            {
    
                av_log(NULL,AV_LOG_DEBUG,"aac waring ,length of write data isn't equal pkt->size(%d,%d)\n",size,pkt->size);
            }
            av_packet_unref(pkt);
        }else{
    
            av_packet_unref(pkt);
        }

    }
    printf("while finish\n");
failed:
    if(h264_fd) {
    
        fclose(h264_fd);
    }
    if(aac_fd) {
    
        fclose(aac_fd);
    }
    if(pkt)
        av_packet_free(&pkt);
    if(ifmt_ctx)
        avformat_close_input(&ifmt_ctx);
    return 0;
}