抽取一个多媒体文件中的视频流

最新推荐文章于 2024-01-08 18:26:35 发布

原创最新推荐文章于 2024-01-08 18:26:35 发布 · 244 阅读

0 ·

CC 4.0 BY-SA版权

音视频专栏收录该内容

12 篇文章

订阅专栏

核心流程：

打开mp4文件并打开目标文件用于存储H264数据
fopen(dst_fileName, “wb”);
err_code = avformat_open_input(&fmt_ctx, src_fileName, NULL, NULL);

初始化 AVPacket
av_init_packet(&pkt);

//找到最好的video流
video_stream_index = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);

//循环读取流中所有的包(AVPacket),为每个包添加特征码和sps/pps等数据(只有关键帧前面要添加sps/pps数据，其他的只需要添加特征码)
// ，都处理完后将数据写入文件保存。

while(av_read_frame(fmt_ctx, &pkt) >=0 )
{
if(pkt.stream_index == video_stream_index)//find video stream
{

        h264_mp4toannexb(fmt_ctx, &pkt, dst_fd);//write h264 data to dst_fd

    }

#include <stdio.h>
#include <libavutil/log.h>
#include <libavformat/avformat.h>


#ifndef AV_WB32
#   define AV_WB32(p, val) do {                 \
        uint32_t d = (val);                     \
        ((uint8_t*)(p))[3] = (d);               \
        ((uint8_t*)(p))[2] = (d)>>8;            \
        ((uint8_t*)(p))[1] = (d)>>16;           \
        ((uint8_t*)(p))[0] = (d)>>24;           \
    } while(0)
#endif

#ifndef AV_RB16
#   define AV_RB16(x)                           \
    ((((const uint8_t*)(x))[0] << 8) |          \
      ((const uint8_t*)(x))[1])
#endif


/*
 在帧前面添加特征码(一般SPS/PPS的帧的特征码用4字节表示，为0X00000001，其他的帧特征码用3个字节表示，为0X000001。也有都用4字节表示的，我们这里采用前面的方式)
 out是要输出的AVPaket
 sps_pps是SPS和PPS数据的指针，对于非关键帧就传NULL
 sps_pps_size是SPS/PPS数据的大小，对于非关键帧传0
 in是指向当前要处理的帧的头信息的指针
 in_size是当前要处理的帧大小(nal_size)
*/
int alloc_and_copy(AVPacket* out,const uint8_t* sps_pps, uint32_t sps_pps_size, const uint8_t* in, uint32_t in_size)
{
    uint32_t offset = out->size; // 偏移量，就是out已有数据的大小，后面再写入数据就要从偏移量处开始操作
    // 特征码的大小，SPS/PPS占4字节00 00 00 01，其余占3字节
    uint8_t nal_header_size = offset ? 3 : 4;
    int err;

    // 对之前分配的packet进行扩容
    err = av_grow_packet(out, sps_pps_size + in_size + nal_header_size);
    if (err < 0)
        return err;

    if (sps_pps)
        memcpy(out->data + offset, sps_pps, sps_pps_size);
    memcpy(out->data + sps_pps_size + nal_header_size + offset, in, in_size);
    if (!offset) {
        // 设置00 00 00 01
        AV_WB32(out->data + sps_pps_size, 1);
    }
    else {
        (out->data + offset + sps_pps_size)[0] =
        (out->data + offset + sps_pps_size)[1] = 0;
        (out->data + offset + sps_pps_size)[2] = 1;
    }

    return 0;
}

/*
读取并拷贝sps/pps数据
codec_extradata是codecpar的扩展数据，sps/pps数据就在这个扩展数据里面
codec_extradata_size是扩展数据大小
out_extradata是输出sps/pps数据的AVPacket包
padding:就是宏AV_INPUT_BUFFER_PADDING_SIZE的值(64)，是用于解码的输入流的末尾必要的额外字节个数，需要它主要是因为一些优化的流读取器一次读取32或者64比特，可能会读取超过size大小内存的末尾。
*/
int h264_extradata_to_annexb(const uint8_t* codec_extradata, const int codec_extradata_size, AVPacket* out_extradata, int padding)
{
    uint64_t unit_size; // sps/pps数据长度
    uint64_t total_size = 0; // 所有sps/pps数据长度加上其特征码长度后的总长度

    /*
        out:是一个指向一段内存的指针，这段内存用于存放所有拷贝的sps/pps数据和其特征码数据
        unit_nb:sps/pps个数
        sps_done：sps数据是否已经处理完毕
        sps_seen：是否有sps数据
        pps_seen：是否有pps数据
        sps_offset：sps数据的偏移，为0
        pps_offset：pps数据的偏移，因为pps数据在sps后面，所以其偏移就是所有sps数据长度+sps的特征码所占字节数
    */
    uint8_t* out = NULL, unit_nb, sps_done = 0,
            sps_seen = 0, pps_seen = 0, sps_offset = 0, pps_offset = 0;
    const uint8_t* extradata = codec_extradata + 4; // 扩展数据的前4位是无用的数据，直接跳过拿到真正的扩展数据
    static const uint8_t nalu_header[4] = { 0, 0, 0, 1 }; // sps/pps数据前面的4bit的特征码

    // extradata第一个字节的最后2位用于指示后面每个sps/pps数据所占字节数。(*extradata表示extradata第一个字节的数据，之后自增1指向下一个字节)
    int length_size = (*extradata++ & 0x3) + 1;

    sps_offset = pps_offset = -1;

    // extradata第二个字节最后5位用于指示sps的个数,一般情况下一个扩展只有一个sps和pps，之后指针指向下一位
    unit_nb = *extradata++ & 0x1f; /* 拿到sps,pps的个数 */
    if (!unit_nb) { // unit_nb为0表示没有sps数据，直接跳转到处理pps的地方
        goto pps;
    }
    else { // unit_nb不为0表有sps数据，所以sps_seen赋值1，sps_offset赋值0
        sps_offset = 0;
        sps_seen = 1;
    }

    while (unit_nb--) { // 遍历每个sps或pps(先变量sps，然后再遍历pps)
        int err;

        // 再接着2个字节表示sps/pps数据的长度
        unit_size = AV_RB16(extradata);
        total_size += unit_size + 4;  // 4表示sps/pps特征码长度
        if (total_size > INT_MAX - padding) {  // total_size太大会造成数据溢出，所以要做判断
            av_log(NULL, AV_LOG_ERROR,
                   "Too big extradata size, corrupted stream or invalid MP4/AVCC bitstream\n");
            av_free(out);
            return AVERROR(EINVAL);
        }

        // extradata + 2 + unit_size比整个扩展数据都长了表明数据是异常的
        if (extradata + 2 + unit_size > codec_extradata + codec_extradata_size) {
            av_log(NULL, AV_LOG_ERROR, "Packet header is not contained in global extradata, "
                                       "corrupted stream or invalid MP4/AVCC bitstream\n");
            av_free(out);
            return AVERROR(EINVAL);
        }

        // av_reallocp()函数用于内存扩展，给out扩展总长加padding的长度
        if ((err = av_reallocp(&out, total_size + padding)) < 0)
            return err;
        // 先将4字节的特征码拷贝进out
        memcpy(out + total_size - unit_size - 4, nalu_header, 4);
        // 再将sps/pps数据拷贝进out,extradata + 2是因为那2字节是表示sps/pps长度的，所以要跳过
        memcpy(out + total_size - unit_size, extradata + 2, unit_size);
        // 本次sps/pps数据处理完后，指针extradata跳过本次sps/pps数据
        extradata += 2 + unit_size;
        pps:
        if (!unit_nb && !sps_done++) { // 执行到这里表明sps已经处理完了，接下来处理pps数据
            unit_nb = *extradata++; // pps的个数
            if (unit_nb) { // 如果pps个数大于0这给pps_seen赋值1表明数据中有pps
                pps_offset = total_size;
                pps_seen = 1;
            }
        }
    }

    if (out) // 如果out有数据，那么将out + total_size后面padding(即64)个字节用0替代
        memset(out + total_size, 0, padding);

    // 如果数据中没有sps或pps则给出提示
    if (!sps_seen)
        av_log(NULL, AV_LOG_WARNING,
               "Warning: SPS NALU missing or invalid. "
               "The resulting stream may not play.\n");

    if (!pps_seen)
        av_log(NULL, AV_LOG_WARNING,
               "Warning: PPS NALU missing or invalid. "
               "The resulting stream may not play.\n");

    // 给传进来的sps/pps的AVPaket赋值
    out_extradata->data = out;
    out_extradata->size = total_size;

    return length_size;
}

/*
	为包数据添加起始码、SPS/PPS等信息后写入文件。
	AVPacket数据包可能包含一帧或几帧数据，对于视频来说只有1帧，对音频来说就包含几帧
	in为要处理的数据包
	file为输出文件的指针
*/
void h264_mp4toannexb(AVFormatContext* fmt_ctx, AVPacket* in, FILE* dst_fd)
{
    AVPacket* out;
    AVPacket spsppsPkt;
    /*typedef signed char __int8_t;
    typedef unsigned char __uint8_t;
    typedef signed short int __int16_t;
    typedef unsigned short int __uint16_t;
    typedef signed int __int32_t;
    typedef unsigned int __uint32_t;
    #if __WORDSIZE == 64
    typedef signed long int __int64_t;
    typedef unsigned long int __uint64_t;*/

    int len; // fwrite()函数写入文件时的返回值
    uint8_t unitType; // NALU头中nal_unit_type，也就是NALU类型，5表示是I帧，7表示SPS，8表示PPS
    int32_t nalSzie; // 一个NALU(也就是一帧，其第一个字节是头信息)的大小，它存放在NALU的前面的4个字节中
    uint8_t nalSzieLen = 4; // 存放nal_size的字节数
    uint32_t cumulSize = 0; // 已经处理的字节数，当cumulSize==bufSize时表示整个包的数据都处理完了
    const uint8_t* buf; // 传进来的数据指针
    const uint8_t* bufEnd; // 传进来的数据末尾指针
    int bufSize; // 传进来的数据大小
    int ret = 0, i;

    out = av_packet_alloc();

    buf = in->data;
    bufSize = in->size;
    bufEnd = in->data + in->size; // 数据首地址加上数据大小就是数据尾地址

    do {
        ret = AVERROR(EINVAL);
        if (buf + 4 > bufEnd)  // 说明传进来的数据没有内容，是有问题的
            goto fail;

        // 取出NALU前面的4个字节得到这一帧的数据大小
        for (nalSzie = 0, i = 0; i < 4; i++)
            nalSzie = (nalSzie << 8) | buf[i];//4个8位数据变成一个32位数据

        // buf后移4位指向NALU的头信息(1个字节)
        buf += 4;
        // 取出NALU头信息的后面5个bit，这5bit记录NALU的类型
        unitType = *buf & 0x1f;

        // 数据有问题就退出
        if (nalSzie > bufEnd - buf || nalSzie < 0)
            goto fail;

        // unit_type是5表示是关键帧，对于关键帧要在其前面添加SPS和PPS信息
        if (unitType == 5) 
        {
            // 添加SPS和PPS信息，找FFmpeg中SPS和PPS信息存放在codecpar->extradata中
            h264_extradata_to_annexb(fmt_ctx->streams[in->stream_index]->codecpar->extradata,
                                     fmt_ctx->streams[in->stream_index]->codecpar->extradata_size,
                                     &spsppsPkt,
                                     AV_INPUT_BUFFER_PADDING_SIZE);

            // 为数据添加特征码(起始码，用于分隔一帧一帧的数据)s
            if ((ret = alloc_and_copy(out,spsppsPkt.data, spsppsPkt.size, buf, nalSzie)) < 0)
                goto fail;
        }
        else {
            // 非关键帧只需要添加特征码
            if ((ret = alloc_and_copy(out, NULL, 0, buf, nalSzie)) < 0)
                goto fail;
        }


        buf += nalSzie; // 一帧处理完后将指针移到下一帧
        cumulSize += nalSzie + nalSzieLen;// 累计已经处理好的数据长度
    } while (cumulSize < bufSize);

    // SPS、PPS和特征码都添加后将其写入文件
    len = fwrite(out->data, 1, out->size, dst_fd);
    if (len != out->size) 
    {
        av_log(NULL, AV_LOG_DEBUG, "warning, length of writed data isn't equal pkt.size(%d, %d)\n",
               len,
               out->size);
    }
    // fwrite()只是将数据写入缓存，fflush()才将数据正在写入文件
    fflush(dst_fd);

    fail:
    av_packet_free(&out);

}
int main(int argc,char * argv[])
{

    int err_code;
    char errors[1024];

    char *src_fileName = NULL;
    char *dst_fileName = NULL;

    FILE *dst_fd = NULL;
    //上下文
    AVFormatContext *fmt_ctx = NULL;


    //存储压缩数据
    AVPacket pkt;

    //要拷贝的流
    int video_stream_index = -1;
    //注册
    av_register_all();
    //拿到输入参数
    if(argc < 3)
    {
        av_log(NULL, AV_LOG_DEBUG, "the count of parameters should be more than three!\n");
        return -1;
    }
    src_fileName = argv[1];
    dst_fileName = argv[2];


    //open input file
    dst_fd = fopen(dst_fileName, "wb");
    if (!dst_fd)
    {
        av_log(NULL, AV_LOG_DEBUG, "Could not open destination file %s\n", dst_fileName);
        return -1;
    }
    //打开输入文件，关于输入文件的所有就保存到fmt_ctx中了
    err_code = avformat_open_input(&fmt_ctx, src_fileName, NULL, NULL);
    if (err_code < 0)
    {
        av_log(NULL, AV_LOG_ERROR, "cant open 1 file:%s\n", av_err2str(err_code));
        return -1;
    }

    /*dump input information*/
    av_dump_format(fmt_ctx, 0, src_fileName, 0);

    //初始化 AVPacket， 我们从文件中读出的数据会暂存在其中
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;

    //找到最好的video流
    video_stream_index = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if(video_stream_index < 0)
    {
        av_log(NULL, AV_LOG_DEBUG, "寻找最好video流失败，请检查输入文件！\n");
        return AVERROR(EINVAL);
    }

    while(av_read_frame(fmt_ctx, &pkt) >=0 ){
        if(pkt.stream_index == video_stream_index)//find video stream
        {
            //循环读取流中所有的包(AVPacket),为每个包添加特征码和sps/pps等数据(只有关键帧前面要添加sps/pps数据，其他的只需要添加特征码)
            // ，都处理完后将数据写入文件保存。
            h264_mp4toannexb(fmt_ctx, &pkt, dst_fd);//write h264 data to dst_fd

        }

        //release pkt->data
        av_packet_unref(&pkt);
    }

    //av_write_trailer(ofmt_ctx);

    /*close input media file*/
    avformat_close_input(&fmt_ctx);
    if(dst_fd)
    {
        fclose(dst_fd);
    }

    return 0;

}