h264测试

h264测试

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



static char err_buf[128] = {0};
static char* av_get_err(int errnum)
{
    av_strerror(errnum, err_buf, 128);
    return err_buf;
}

/*
AvCodecContext->extradata[]中为nalu长度
*   codec_extradata:
*   1, 64, 0, 1f, ff, e1, [0, 18], 67, 64, 0, 1f, ac, c8, 60, 78, 1b, 7e,
*   78, 40, 0, 0, fa, 40, 0, 3a, 98, 3, c6, c, 66, 80,
*   1, [0, 5],68, e9, 78, bc, b0, 0,
*/

//ffmpeg -i 2018.mp4 -codec copy -bsf:h264_mp4toannexb -f h264 tmp.h264
//ffmpeg 从mp4上提取H264的nalu h
int main(int argc, char **argv)
{
    AVFormatContext *ifmt_ctx = NULL;
    int             videoindex = -1;
    AVPacket        *pkt = NULL;
    int             ret = -1;
    int             file_end = 0; // 文件是否读取结束

    if(argc < 3)
    {
        printf("usage inputfile outfile\n");
        return -1;
    }
    FILE *outfp=fopen(argv[2],"wb");
    printf("in:%s out:%s\n", argv[1], argv[2]);

    // 分配解复用器的内存，使用avformat_close_input释放
    ifmt_ctx = avformat_alloc_context();
    if (!ifmt_ctx)
    {
        printf("[error] Could not allocate context.\n");
        return -1;
    }

    // 根据url打开码流，并选择匹配的解复用器
    ret = avformat_open_input(&ifmt_ctx,argv[1], NULL, NULL);
    if(ret != 0)
    {
        printf("[error]avformat_open_input: %s\n", av_get_err(ret));
        return -1;
    }

    // 读取媒体文件的部分数据包以获取码流信息
    ret = avformat_find_stream_info(ifmt_ctx, NULL);
    if(ret < 0)
    {
        printf("[error]avformat_find_stream_info: %s\n", av_get_err(ret));
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    // 查找出哪个码流是video/audio/subtitles
    videoindex = -1;
    // 推荐的方式, 通过av_find_best_stream()函数来获取流的索引
    videoindex = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if(videoindex == -1)
    {
        printf("Didn't find a video stream.\n");
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    // 分配数据包
    pkt = av_packet_alloc();
    av_init_packet(pkt);

    // 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");
    AVBSFContext *bsf_ctx = NULL;
    //2.过滤器分配内存
    av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
    // 3 添加解码器属性
    avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->codecpar);
    //4 初始化过滤器上下文
    av_bsf_init(bsf_ctx);

    file_end = 0;
    while (0 == file_end)
    {
        if((ret = av_read_frame(ifmt_ctx, pkt)) < 0)    //判断数据是否读取完
        {
            // 没有更多包可读
            file_end = 1;
            printf("read file end: ret:%d\n", ret);
        }
        if(ret == 0 && pkt->stream_index == videoindex)
        {
//#if 0
            int input_size = pkt->size;
            int out_pkt_count = 0;
            if (av_bsf_send_packet(bsf_ctx, pkt) != 0) // bitstreamfilter内部去维护内存空间
            {   //发送每个数据包后，过滤器必须完全排空
                av_packet_unref(pkt);   // 你不用了就把资源释放掉
                continue;       // 继续送
            }
            av_packet_unref(pkt);   // 释放资源
            while(av_bsf_receive_packet(bsf_ctx, pkt) == 0)
            {//必须使用av_packet_unref() 释放内存
                out_pkt_count++;
                // printf("fwrite size:%d\n", pkt->size);
                size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
                if(size != pkt->size)
                {
                    printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
                }
                av_packet_unref(pkt);
            }
            if(out_pkt_count >= 2)
            {
                printf("cur pkt(size:%d) only get 1 out pkt, it get %d pkts\n",
                       input_size, out_pkt_count);
            }
//#else
            // TS流可以直接写入, bitstreamfilter可以自动判别格式,可以做到正常的识别,如果有了startcode就不会在添加statcode了
            size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
            if(size != pkt->size)
            {
                printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
            }
            av_packet_unref(pkt);
//#endif
        }
        else
        {
            if(ret == 0)
                av_packet_unref(pkt);        // 释放内存
        }
    }
    if(outfp)
        fclose(outfp);
    if(bsf_ctx)
        av_bsf_free(&bsf_ctx);
    if(pkt)
        av_packet_free(&pkt);
    if(ifmt_ctx)
        avformat_close_input(&ifmt_ctx);
    printf("finish\n");

    return 0;
}

av_bsf_get_by_name
定义指定比特流过滤器

/**
* @return 具有指定名称的比特流过滤器，如果没有，则返回 NULL
  * 存在比特流过滤器。
 */
const AVBitStreamFilter *av_bsf_get_by_name(const char *name);

源码:

const AVBitStreamFilter *av_bsf_get_by_name(const char *name)
{
    const AVBitStreamFilter *f = NULL;
    void *i = 0;

    if (!name)
        return NULL;

    while ((f = av_bsf_iterate(&i))) {
        if (!strcmp(f->name, name))
            return f;
    }

    return NULL;
}

av_bsf_iterate

/**
* 迭代所有注册的比特流过滤器。
  *
  * @param opaque 一个指针，其中 libavcodec 将存储迭代状态。 必须
  * 指向 NULL 开始迭代。
  *
  * @return 下一个注册的比特流过滤器或迭代时为NULL
  *         完成的
 */
const AVBitStreamFilter *av_bsf_iterate(void **opaque);

源码:

const AVBitStreamFilter *av_bsf_iterate(void **opaque)
{
    uintptr_t i = (uintptr_t)*opaque;
    const AVBitStreamFilter *f = bitstream_filters[i];

    if (f)
        *opaque = (void*)(i + 1);

    return f;
}

av_bsf_alloc()

/**
* 为给定的比特流过滤器分配上下文。 来电者必须填写
  * 文档中描述的上下文参数，然后调用
  * av_bsf_init() 在向过滤器发送任何数据之前。
  *
  * @param filter 为其分配实例的过滤器。
  * @param ctx 指向新分配上下文的指针
  * 将被写入。 它必须在 av_bsf_free() 之后释放
  * 过滤完成。
  *
  * @return 成功时返回 0，失败时返回负的 AVERROR 代码
 */
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);

源码:

int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
{
    AVBSFContext *ctx;
    int ret;

    ctx = av_mallocz(sizeof(*ctx));
    if (!ctx)
        return AVERROR(ENOMEM);

    ctx->av_class = &bsf_class;
    ctx->filter   = filter;

    ctx->par_in  = avcodec_parameters_alloc();
    ctx->par_out = avcodec_parameters_alloc();
    if (!ctx->par_in || !ctx->par_out) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    ctx->internal = av_mallocz(sizeof(*ctx->internal));
    if (!ctx->internal) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    ctx->internal->buffer_pkt = av_packet_alloc();
    if (!ctx->internal->buffer_pkt) {
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    av_opt_set_defaults(ctx);

    /* allocate priv data and init private options */
    if (filter->priv_data_size) {
        ctx->priv_data = av_mallocz(filter->priv_data_size);
        if (!ctx->priv_data) {
            ret = AVERROR(ENOMEM);
            goto fail;
        }
        if (filter->priv_class) {
            *(const AVClass **)ctx->priv_data = filter->priv_class;
            av_opt_set_defaults(ctx->priv_data);
        }
    }

    *pctx = ctx;
    return 0;
fail:
    av_bsf_free(&ctx);
    return ret;
}

avcodec_parameters_copy

/**
  * 将src的内容复制到dst。 dst 中任何分配的字段都被释放并且
  * 替换为新分配的 src 中相应字段的重复项。
  *
  * @return >= 0 成功，失败时返回负的 AVERROR 代码。
 */
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);

源码

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
{
    codec_parameters_reset(dst);
    memcpy(dst, src, sizeof(*dst));

    dst->extradata      = NULL;
    dst->extradata_size = 0;
    if (src->extradata) {
        dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
        if (!dst->extradata)
            return AVERROR(ENOMEM);
        memcpy(dst->extradata, src->extradata, src->extradata_size);
        dst->extradata_size = src->extradata_size;
    }

    return 0;
}

av_bsf_send_packet

/**
* 提交数据包进行过滤。
  *
  * 发送每个数据包后，过滤器必须通过调用完全排空
  * av_bsf_receive_packet() 重复直到它返回 AVERROR(EAGAIN) 或
  * AVERROR_EOF。
  *
  * @param pkt 要过滤的数据包。 比特流过滤器将拥有
  * 包和重置pkt的内容。 如果发生错误，则不会触及 pkt。
  * 此参数可能为 NULL，表示流结束（即不再
  * 将发送数据包）。 这将导致过滤器输出它的任何数据包
  * 可能已在内部缓冲。
  *
  * @return 成功时返回 0，错误时返回负 AVERROR。
 */
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);

av_bsf_receive_packet

/**
* 检索过滤后的数据包。
 *
 * @param[out] pkt 这个结构体将填充过滤后的内容
 * 包。它归调用者所有，必须使用
 * av_packet_unref() 不再需要时。
 * 这个参数应该是“干净的”（即新分配的
 * 使用 av_packet_alloc() 或未使用 av_packet_unref())
 * 当这个函数被调用时。如果这个函数返回
 * 成功，pkt的内容将完整
 * 被返回的数据覆盖。失败时，pkt 不是
 * 感动。
 *
 * @return 0 成功。 AVERROR(EAGAIN) 如果需要将更多数据包发送到
 * 过滤器（使用 av_bsf_send_packet()）以获得更多输出。 AVERROR_EOF 如果有
 * 将不再从过滤器输出。另一个负 AVERROR 值，如果
 * 发生错误。
 *
 * @note 一个输入包可能会产生多个输出包，所以发送后
 * 一个带有av_bsf_send_packet()的包，需要调用这个函数
 * 重复，直到它停止返回 0。过滤器也可以
 * 输出的数据包少于发送给它的数据包，因此此函数可能会返回
 * av_bsf_send_packet() 调用成功后立即出现 AVERROR(EAGAIN)。
 */
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);