av_bsf_get_by_name,av_bsf_iterate, av_bsf_alloc,avcodec_parameters_copy

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

标签：alloc,return,dst,ctx,av,const,bsf
来源： https://blog.csdn.net/weixin_42123332/article/details/120767670