【FFMPEG源码分析】从ffplay源码摸清ffmpeg框架(三)

news2025/1/10 2:55:17

从ffplay源码分析这篇文章中可以知道int stream_component_open(VideoState *is, int stream_index)函数是创建和初始化decoder的入口。本篇文章从此入口看下ffmpeg中decoder的内部结构是什么样子。
同样先提出几个问题，带着问题梳理源码，效率贼快啊

  1. ffmpeg decoder内部模块的结构关系是怎样的?
  2. 如何匹配到正确的decoder，h264还是vp9等 ？
  3. decoder数据流向是怎么样的？如何驱动数据流转的?

stream_component_open

static int stream_component_open(VideoState *is, int stream_index)
{
    AVFormatContext *ic = is->ic;
    AVCodecContext *avctx;
    const AVCodec *codec;
    ......................;
    avctx = avcodec_alloc_context3(NULL);
    avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar);
    avctx->pkt_timebase = ic->streams[stream_index]->time_base;
    codec = avcodec_find_decoder(avctx->codec_id);
    avctx->codec_id = codec->id;
    .......................;
    avcodec_open2(avctx, codec, &opts));

    is->eof = 0;
    ic->streams[stream_index]->discard = AVDISCARD_DEFAULT;
    switch (avctx->codec_type) {
    case AVMEDIA_TYPE_AUDIO:

        if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
            goto fail;
       
        if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
            goto out;
        ........................;
        break;
    case AVMEDIA_TYPE_VIDEO:
        if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
            goto fail;
        if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
            goto out;
        is->queue_attachments_req = 1;
        break;
    case AVMEDIA_TYPE_SUBTITLE:
        if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
            goto fail;
        if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
            goto out;
        break;
    default:
        break;
    }
    goto out;
    ..................;
    return ret;
}

经过删减后，列出了重点代码，再深入细节分析下:

avcodec_alloc_context3

下面代码用于创建一个AVCodecContext

AVCodecContext *avctx = avcodec_alloc_context3(NULL)

后面再看看这个指针放在什么地方去了。

AVCodecContext *avcodec_alloc_context3(const AVCodec *codec)
{
    AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext));
    //初始化， codec未NULL
    init_context_defaults(avctx, codec);
    return avctx;
}
//此函数暂不深入分析，代码先放在这里
static int init_context_defaults(AVCodecContext *s, const AVCodec *codec)
{
    const FFCodec *const codec2 = ffcodec(codec);
    int flags=0;
    memset(s, 0, sizeof(AVCodecContext));

    s->av_class = &av_codec_context_class;

    s->codec_type = codec ? codec->type : AVMEDIA_TYPE_UNKNOWN;
    if (codec) {
        s->codec = codec;
        s->codec_id = codec->id;
    }

    if(s->codec_type == AVMEDIA_TYPE_AUDIO)
        flags= AV_OPT_FLAG_AUDIO_PARAM;
    else if(s->codec_type == AVMEDIA_TYPE_VIDEO)
        flags= AV_OPT_FLAG_VIDEO_PARAM;
    else if(s->codec_type == AVMEDIA_TYPE_SUBTITLE)
        flags= AV_OPT_FLAG_SUBTITLE_PARAM;
    av_opt_set_defaults2(s, flags, flags);

    av_channel_layout_uninit(&s->ch_layout);

    s->time_base           = (AVRational){0,1};
    s->framerate           = (AVRational){ 0, 1 };
    s->pkt_timebase        = (AVRational){ 0, 1 };
    s->get_buffer2         = avcodec_default_get_buffer2;
    s->get_format          = avcodec_default_get_format;
    s->get_encode_buffer   = avcodec_default_get_encode_buffer;
    s->execute             = avcodec_default_execute;
    s->execute2            = avcodec_default_execute2;
    s->sample_aspect_ratio = (AVRational){0,1};
    s->ch_layout.order     = AV_CHANNEL_ORDER_UNSPEC;
    s->pix_fmt             = AV_PIX_FMT_NONE;
    s->sw_pix_fmt          = AV_PIX_FMT_NONE;
    s->sample_fmt          = AV_SAMPLE_FMT_NONE;

    s->reordered_opaque    = AV_NOPTS_VALUE;
    if(codec && codec2->priv_data_size){
        s->priv_data = av_mallocz(codec2->priv_data_size);
        if (!s->priv_data)
            return AVERROR(ENOMEM);
        if(codec->priv_class){
            *(const AVClass**)s->priv_data = codec->priv_class;
            av_opt_set_defaults(s->priv_data);
        }
    }
    if (codec && codec2->defaults) {
        int ret;
        const FFCodecDefault *d = codec2->defaults;
        while (d->key) {
            ret = av_opt_set(s, d->key, d->value, 0);
            av_assert0(ret >= 0);
            d++;
        }
    }
    return 0;
}

avcodec_parameters_to_context

avcodec_parameters_to_context(avctx, ic->streams[stream_index]->codecpar)

此函数的作用是将demuxer模块demux出来的stream的具体信息赋值到AVCodecContext

int avcodec_parameters_to_context(AVCodecContext *codec,
                                  const AVCodecParameters *par)
{
    int ret;
    codec->codec_type = par->codec_type;
    codec->codec_id   = par->codec_id;
    codec->codec_tag  = par->codec_tag;

    codec->bit_rate              = par->bit_rate;
    codec->bits_per_coded_sample = par->bits_per_coded_sample;
    codec->bits_per_raw_sample   = par->bits_per_raw_sample;
    codec->profile               = par->profile;
    codec->level                 = par->level;

    switch (par->codec_type) {
    case AVMEDIA_TYPE_VIDEO:
        codec->pix_fmt                = par->format;
        codec->width                  = par->width;
        codec->height                 = par->height;
        codec->field_order            = par->field_order;
        codec->color_range            = par->color_range;
        codec->color_primaries        = par->color_primaries;
        codec->color_trc              = par->color_trc;
        codec->colorspace             = par->color_space;
        codec->chroma_sample_location = par->chroma_location;
        codec->sample_aspect_ratio    = par->sample_aspect_ratio;
        codec->has_b_frames           = par->video_delay;
        break;
    case AVMEDIA_TYPE_AUDIO:
        codec->sample_fmt       = par->format;
        ...................................;
        codec->sample_rate      = par->sample_rate;
        codec->block_align      = par->block_align;
        codec->frame_size       = par->frame_size;
        codec->delay            =
        codec->initial_padding  = par->initial_padding;
        codec->trailing_padding = par->trailing_padding;
        codec->seek_preroll     = par->seek_preroll;
        break;
    case AVMEDIA_TYPE_SUBTITLE:
        codec->width  = par->width;
        codec->height = par->height;
        break;
    }

    if (par->extradata) {
        av_freep(&codec->extradata);
        codec->extradata = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
        if (!codec->extradata)
            return AVERROR(ENOMEM);
        memcpy(codec->extradata, par->extradata, par->extradata_size);
        codec->extradata_size = par->extradata_size;
    }

    return 0;
}

avcodec_find_decoder

AVCodec *codec = avcodec_find_decoder(avctx->codec_id);

通过demuxer模块中获取到的codec_id, 匹配到具体的codec即decoder，struct AVCodec实际对应一个struct FFCodec，struct FFCodec提供一个decode(…)函数执行具体的解码动作。

typedef struct AVCodec {
    const char *name;
    const char *long_name;
    enum AVMediaType type;
    enum AVCodecID id;
    ...................;
} AVCodec;

typedef struct FFCodec {
    AVCodec p;
   int (*decode)(struct AVCodecContext *avctx, void *outdata,
                  int *got_frame_ptr, struct AVPacket *avpkt);
    ..................;
}

下面来看看avcodec_find_decoder的实现细节

const AVCodec *avcodec_find_decoder(enum AVCodecID id)
{
    return find_codec(id, av_codec_is_decoder);
}
static const AVCodec *find_codec(enum AVCodecID id, int (*x)(const AVCodec *))
{
    const AVCodec *p, *experimental = NULL;
    void *i = 0;
    id = remap_deprecated_codec_id(id);
    //遍历所有decoder，通过codec_id匹配到正确的decoder
    while ((p = av_codec_iterate(&i))) {
        if (!x(p))
            continue;
        if (p->id == id) {
            if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
                experimental = p;
            } else
                return p;
        }
    }
    return experimental;
}
const AVCodec *av_codec_iterate(void **opaque)
{
    uintptr_t i = (uintptr_t)*opaque;
    //codec_list是一个全局变量，可通过配置文件配置，如:
    //static const FFCodec * const codec_list[] = {
    //&ff_h264_decoder,
    // &ff_theora_decoder,
    // &ff_vp3_decoder,
    // &ff_vp8_decoder,
    // &ff_aac_decoder,
    // &ff_flac_decoder,
    // &ff_mp3_decoder,
    // &ff_vorbis_decoder,
    // &ff_pcm_alaw_decoder,
    // &ff_pcm_f32le_decoder,
    // &ff_pcm_mulaw_decoder,
    // &ff_pcm_s16be_decoder,
    // &ff_pcm_s16le_decoder,
    // &ff_pcm_s24be_decoder,
    // &ff_pcm_s24le_decoder,
    // &ff_pcm_s32le_decoder,
    // &ff_pcm_u8_decoder,
    // &ff_libopus_decoder,
    // NULL };
    const FFCodec *c = codec_list[i];
    ff_thread_once(&av_codec_static_init, av_codec_init_static);
    if (c) {
        *opaque = (void*)(i + 1);
        return &c->p;
    }
    return NULL;
}

我们来看看h264 decoder的定义？

const FFCodec ff_h264_decoder = {
    .p.name                = "h264",
    .p.long_name           = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
    .p.type                = AVMEDIA_TYPE_VIDEO,
    .p.id                  = AV_CODEC_ID_H264,
    .priv_data_size        = sizeof(H264Context),
    .init                  = h264_decode_init,
    .close                 = h264_decode_end,
    .decode                = h264_decode_frame,
    ..............................;
    .flush                 = h264_decode_flush,
    .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
    .update_thread_context_for_user = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context_for_user),
    .p.profiles            = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
    .p.priv_class          = &h264_class,
};

ff_h264_decoder中有定义codec id为AV_CODEC_ID_H264，ffmpeg\libavcodec\codec_id.h中定义了每一种codec的值。

avcodec_open2

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
{
    int ret = 0;
    AVCodecInternal *avci;
    const FFCodec *codec2;
    ........................;
    codec2 = ffcodec(codec);
    ...................;
    //将匹配到的AVCodec存入AVCodecContext.codec 
    avctx->codec = codec;
    ...........................;
    avci = av_mallocz(sizeof(*avci));
    //分配AVCodecInternal存入AVCodecContext.internal，后续具体decode都依赖AVCodecInternal
    avctx->internal = avci;
    avci->buffer_frame = av_frame_alloc();
    avci->buffer_pkt = av_packet_alloc();
    avci->es.in_frame = av_frame_alloc();
    avci->in_pkt = av_packet_alloc();
    avci->last_pkt_props = av_packet_alloc();
    avci->pkt_props = av_fifo_alloc2(1, sizeof(*avci->last_pkt_props),AV_FIFO_FLAG_AUTO_GROW);
    avci->skip_samples_multiplier = 1;
    //下面这一段代码是不是很熟悉，这个avctx->priv_data就是具体decoder的context。
    //如: const FFCodec ff_h264_decoder = {
    // .p.name                = "h264",
    // .p.long_name           = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
    // .p.type                = AVMEDIA_TYPE_VIDEO,
    // .p.id                  = AV_CODEC_ID_H264,
    // .priv_data_size        = sizeof(H264Context),
    //  .............................;
    //  }
    // 以ff_h264_decoder为例子，此处分配的是struct H264Context
    if (codec2->priv_data_size > 0) {
        if (!avctx->priv_data) {
            avctx->priv_data = av_mallocz(codec2->priv_data_size);
            if (!avctx->priv_data) {
                ret = AVERROR(ENOMEM);
                goto free_and_end;
            }
            if (codec->priv_class) {
                *(const AVClass **)avctx->priv_data = codec->priv_class;
                av_opt_set_defaults(avctx->priv_data);
            }
        }
        if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, options)) < 0)
            goto free_and_end;
    } else {
        avctx->priv_data = NULL;
    }
    .......................................;
    //继续初始化AVCodecContext的字段，其中比较重要的是创建并初始化一个Filter
    //AVCodecInternal中的AVBSFContext *bsf
    ff_decode_preinit(avctx);
    .........................................;
}

decoder_init & decoder_init

//将前面分配的AVCodecContext放置在Decoder.avctx中
static int decoder_init(Decoder *d, AVCodecContext *avctx, PacketQueue *queue, SDL_cond *empty_queue_cond) {
    memset(d, 0, sizeof(Decoder));
    d->pkt = av_packet_alloc();
    if (!d->pkt)
        return AVERROR(ENOMEM);
    d->avctx = avctx;
    d->queue = queue;
    d->empty_queue_cond = empty_queue_cond;
    d->start_pts = AV_NOPTS_VALUE;
    d->pkt_serial = -1;
    return 0;
}
//创建一个thread用于解码，如:video_thread
static int decoder_start(Decoder *d, int (*fn)(void *), const char *thread_name, void* arg)
{
    packet_queue_start(d->queue);
    d->decoder_tid = SDL_CreateThread(fn, thread_name, arg);
    if (!d->decoder_tid) {
        av_log(NULL, AV_LOG_ERROR, "SDL_CreateThread(): %s\n", SDL_GetError());
        return AVERROR(ENOMEM);
    }
    return 0;
}

stream_component_open总结

  1. 分配AVCodecContext
  2. 将demuxer stream中codecpar的信息赋值给AVCodecContext对应的字段
  3. 遍历所有decoder通过demuxer中的codec_id配到正确的decoder存储在AVCodecContext.codec
  4. 分配并初始化AVCodecContext.internal
  5. 再启动一个thread进行具体的decode动作。

decode流程分析

下面以video_thread源码进行decode流程分析，主要分析数据流转。

static int video_thread(void *arg)
{
    VideoState *is = arg;
    AVFrame *frame = av_frame_alloc();
    double pts;
    double duration;
    int ret;
    AVRational tb = is->video_st->time_base;
    AVRational frame_rate = av_guess_frame_rate(is->ic, is->video_st, NULL);
    ......................................;
    for (;;) {
        //获取解码之后的frame，重点分析下此函数
        ret = get_video_frame(is, frame);
        if (ret < 0)
            goto the_end;
        if (!ret)
            continue;
       duration = (frame_rate.num && frame_rate.den ? av_q2d((AVRational){frame_rate.den, frame_rate.num}) : 0);
       pts = (frame->pts == AV_NOPTS_VALUE) ? NAN : frame->pts * av_q2d(tb);
       //存入queue中供显示模块使将解码后的数据显示出来
       ret = queue_picture(is, frame, pts, duration, frame->pkt_pos, is->viddec.pkt_serial);
       av_frame_unref(frame);
       .......................;
    }
    .......................;
    return 0;
}

static int get_video_frame(VideoState *is, AVFrame *frame)
{
    int got_picture;
    if ((got_picture = decoder_decode_frame(&is->viddec, frame, NULL)) < 0)
        return -1;
    ..................................;
    return got_picture;
}

static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
    int ret = AVERROR(EAGAIN);
    for (;;) {
        //serial 和pkt_serial与seek相关，如果没有seek动作，serial，pkt_serial一直保持不变
        if (d->queue->serial == d->pkt_serial) {
            do {
                switch (d->avctx->codec_type) {
                    case AVMEDIA_TYPE_VIDEO:
                        //首先尝试获取解码后的frame，获取不到ret = EAGAIN，退出此死循环
                        ret = avcodec_receive_frame(d->avctx, frame);
                        .............................;
                        break;
                    case AVMEDIA_TYPE_AUDIO:
                      ....................; 
                      break;
                }
                if (ret >= 0)
                    return 1;
            } while (ret != AVERROR(EAGAIN));
        }

        do {
            if (d->packet_pending) {
                d->packet_pending = 0;
            } else {
                int old_serial = d->pkt_serial;
                //从demuxer输出的queue中获取packet
                if (packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial) < 0)
                    return -1;
                ....................;
            }
            if (d->queue->serial == d->pkt_serial)
                break;
            av_packet_unref(d->pkt);
        } while (1);

        if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
           .........................;
        } else {
            //将demux出来的packet送到decode模块
            if (avcodec_send_packet(d->avctx, d->pkt) == AVERROR(EAGAIN)) {
                av_log(d->avctx, AV_LOG_ERROR, "Receive_frame and send_packet both returned EAGAIN, which is an API violation.\n");
                d->packet_pending = 1;
            } else {
                av_packet_unref(d->pkt);
            }
        }
    }
}

从上面的代码可以知道，decode核心步骤为:

  1. packet_queue_get(…) 获取demux结果用于decode
  2. avcodec_send_packet(…) 将上述数据送入到decoer
  3. avcodec_receive_frame(…)从decoder中获取解码后的数据。

packet_queue_get

Decoder *d
packet_queue_get(d->queue, d->pkt, 1, &d->pkt_serial);
d->queue实际就是demuxer的输出queue，以video为例子，看看赋值的地方:
decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread))
d->queue就是is->videoq

packet_queue_get就是从PacketQueue中取出一个AVPacket，细节不做深入分析。

static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
{
    MyAVPacketList pkt1;
    for (;;) {
        if (av_fifo_read(q->pkt_list, &pkt1, 1) >= 0) {
            q->nb_packets--;
            q->size -= pkt1.pkt->size + sizeof(pkt1);
            q->duration -= pkt1.pkt->duration;
            av_packet_move_ref(pkt, pkt1.pkt);
            if (serial)
                *serial = pkt1.serial;
            av_packet_free(&pkt1.pkt);
            ret = 1;
            break;
        } 
    }
    return ret;
}

avcodec_send_packet

int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
{
    AVCodecInternal *avci = avctx->internal;
    int ret;
    ........................;
    //清空buffer_pkt
    av_packet_unref(avci->buffer_pkt);
    if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
        //将avpkt里面的数据info 和data全部拷贝到buffer_pkt中
        ret = av_packet_ref(avci->buffer_pkt, avpkt);
        if (ret < 0)
            return ret;
    }
    //将数据送入bsf中，下面深入分析下
    av_bsf_send_packet(avci->bsf, avci->buffer_pkt);
  
    if (!avci->buffer_frame->buf[0]) {
        //待avcodec_receive_frame源码梳理时再深入分析
        ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
        if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
            return ret;
    }

    return 0;
}

int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
{
    FFBSFContext *const bsfi = ffbsfcontext(ctx);
    int ret;
    ..............................;
    //将pkt->data中的数据拷贝到pkt->buf->data
    ret = av_packet_make_refcounted(pkt);
    if (ret < 0)
        return ret;
    //将pkt赋值给buffer_pkt
    av_packet_move_ref(bsfi->buffer_pkt, pkt);
    return 0;
}

avcodec_receive_frame

int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
{
    AVCodecInternal *avci = avctx->internal;
    int ret, changed;
    if (avci->buffer_frame->buf[0]) {
        av_frame_move_ref(frame, avci->buffer_frame);
    } else {
        //先看看这个函数
        ret = decode_receive_frame_internal(avctx, frame);
        if (ret < 0)
            return ret;
    }

    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
        ret = apply_cropping(avctx, frame);
        if (ret < 0) {
            av_frame_unref(frame);
            return ret;
        }
    }

    avctx->frame_number++;

    if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
       ..........................;
    }
    return 0;
}

static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
{
    AVCodecInternal *avci = avctx->internal;
    const FFCodec *const codec = ffcodec(avctx->codec);
    ........................;
    //当前大多codec没有实现codec->receive_frame这个接口
    //所以重点看下decode_simple_receive_frame
    if (codec->receive_frame) {
        ret = codec->receive_frame(avctx, frame);
        if (ret != AVERROR(EAGAIN))
            av_packet_unref(avci->last_pkt_props);
    } else
        ret = decode_simple_receive_frame(avctx, frame);
    .............................;
    return ret;
}

static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
{
    while (!frame->buf[0]) {
        ret = decode_simple_internal(avctx, frame, &discarded_samples);
        ........................;
    }
    return 0;
}

static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
{
    AVCodecInternal   *avci = avctx->internal;
    AVPacket     *const pkt = avci->in_pkt;
    const FFCodec *const codec = ffcodec(avctx->codec);
    int got_frame, actual_got_frame;
    int ret;

    if (!pkt->data && !avci->draining) {
        av_packet_unref(pkt);
        //通过前面的源码分析，avcodec_send_packet是将数据送到了FFBSFContext下的buffer_pkt中，
        // 下面这个函数实际上在FFBSFContext做了一些其他操作后，将buffer_pkt取出来，后面可以详细看下这个代码实现
        ret = ff_decode_get_packet(avctx, pkt);
        if (ret < 0 && ret != AVERROR_EOF)
            return ret;
    }
    ..........................................;
    got_frame = 0;
    if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) {
        ret = ff_thread_decode_frame(avctx, frame, &got_frame, pkt);
    } else {
        //调用具体的decoder进行decode
        ret = codec->decode(avctx, frame, &got_frame, pkt);
        ..................;
    }
    .............................;
    return ret < 0 ? ret : 0;
}

int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
{
    AVCodecInternal *avci = avctx->internal;
    int ret;
    ret = av_bsf_receive_packet(avci->bsf, pkt);
    ..................;
}

int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
{
    //调用到具体的FFBitStreamFilter的filter接口
    return ff_bsf(ctx->filter)->filter(ctx, pkt);
}
//以ff_h264_metadata_bsf为例，看看filter接口的实现
const FFBitStreamFilter ff_h264_metadata_bsf = {
    .p.name         = "h264_metadata",
    .p.codec_ids    = h264_metadata_codec_ids,
    .p.priv_class   = &h264_metadata_class,
    .priv_data_size = sizeof(H264MetadataContext),
    .init           = &h264_metadata_init,
    .close          = &ff_cbs_bsf_generic_close,
    .filter         = &ff_cbs_bsf_generic_filter,
};

int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt)
{
    CBSBSFContext           *ctx = bsf->priv_data;
    CodedBitstreamFragment *frag = &ctx->fragment;
    int err;
    err = ff_bsf_get_packet_ref(bsf, pkt);
    if (err < 0)
        return err;
    ........................;
    return err;
}

int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt)
{
    FFBSFContext *const bsfi = ffbsfcontext(ctx);
    //取出buffer_pkt
    av_packet_move_ref(pkt, bsfi->buffer_pkt);
    return 0;
}

总结

  1. ffmpeg decoder内部模块的结构关系是怎样的?
    具体关系看下图
  2. 如何匹配到正确的decoder，h264还是vp9等 ？
    demuxer模块会demux出具体的codec，然后给根据此codec的codec id匹配到正确的decoder
  3. decoder数据流向是怎么样的？如何驱动数据流转的?
    avcodec_send_packet()将未解码的数据存储在filter模块，然后再调用avcodec_recieve_frame() 从decoder中获取解码后的frame
    ffmpeg_decoder

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/343606.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux（Linux的连接使用）

Linux（Linux的连接使用）

连接Linux我们一般使用CRT或者Xshell工具进行连接使用。 如CRT使用SSH的方式 输出主机&#xff0c;账户&#xff0c;密码那些就可以连接上了。 Linux系统是一个文件型操作系统&#xff0c;有一句话说Linux的一切皆是文件。Linux系统的启动大致有下面几个步骤 Linux系统有7个运…
阅读更多...
excel应用技巧：如何用函数制作简易抽奖动图

excel应用技巧：如何用函数制作简易抽奖动图

利用INDEX函数和随机整数函数RANDBETWEEN配合&#xff0c;在Excel中做一个简单的抽奖器&#xff0c;可以随机抽取姓名或者奖品。有兴趣的伙伴可以做出来试试&#xff0c;撞撞2023年好运气。每次年会大家最期待的就是抽奖环节。为了看看自己今年运气怎么样&#xff0c;会不会获奖…
阅读更多...
中国版ChatGPT来了！ 如何解读ChatGPT将带来的技术变革

中国版ChatGPT来了！ 如何解读ChatGPT将带来的技术变革

最近这段时间&#xff0c;ChatGPT真的是太火了&#xff01;各平台都在铺天盖地式的宣传&#xff0c;相信在这么些天的宣传中&#xff0c;大家也对ChatGPT有了一个大概的了解&#xff0c;我们这边也就简单介绍一下。据ChatGPT自我介绍&#xff0c;它是一款预训练语言模型&#x…
阅读更多...
ContextCapture Master 倾斜摄影测量实景三维建模技术

ContextCapture Master 倾斜摄影测量实景三维建模技术

ContextCapture实景建模大师是一套无需人工干预&#xff0c;通过影像自动生成高分辨率的三维模型的软件解决方案。它集合了全球最先进数字影像处理、计算机虚拟现实以及计算机几何图形算法&#xff0c;在易用性、数据兼容性、运算性能、友好的人机交互及自由的硬件配置兼容性等…
阅读更多...
Java设计模式-02工厂模式

Java设计模式-02工厂模式

为什么需要工厂模式&#xff0c;其作用什么&#xff1f;如何实现&#xff0c;代码演示解析优缺点。Q1:为什么需要工厂模式&#xff1f;工厂模式的作用(优点)是什么&#xff1f; 解耦。把对象的创建和使用的过程分开。就是Class A 想调用 Class B &#xff0c;那么A只是调用B的…
阅读更多...
安装jdk8

安装jdk8

目录标题一、下载地址&#xff08;一&#xff09;Linux下载&#xff08;二&#xff09;Win下载二、安装&#xff08;一&#xff09;Linux&#xff08;二&#xff09;Win三、卸载&#xff08;一&#xff09;Linux&#xff08;二&#xff09;Win一、下载地址 jdk8最新版 jdk8其他…
阅读更多...
Tessent Mbist(5) 并行static Retention(静态保持)测试

Tessent Mbist(5) 并行static Retention(静态保持)测试

本章描述当嵌入存储器被不同的memory BIST控制器所测试或者被不同的memory BIST controller steps按顺序进行测试时如何进行retention测试. 在跑PSRT(parallel static retention testing)之前,建议先跑BIST in HWDefault 或者 RunTimeProg 模式去保证有足够高的fault覆盖率;PSR…
阅读更多...
iOS 奔溃EXC_BAD_ACCESS(KERN_INVALID_ADDRESS)分析

iOS 奔溃EXC_BAD_ACCESS(KERN_INVALID_ADDRESS)分析

EXC_BAD_ACCESS (KERN_INVALID_ADDRESS)是一种常见的iOS应用程序崩溃错误&#xff0c;可能有以下原因&#xff1a; 尝试访问已释放的对象&#xff1a;即使是一个引用计数为0的对象&#xff0c;尝试访问它将导致崩溃。 尝试访问不正确的内存地址&#xff1a;例如&#xff0c;尝…
阅读更多...
SpringBoot+Vue实现养老智慧服务平台

SpringBoot+Vue实现养老智慧服务平台

文末获取源码 开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 5.7/8.0 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven3.3.9 浏…
阅读更多...
高姿态下的面部表情识别系统

高姿态下的面部表情识别系统

效果展示&#xff1a; python表情、性别识别面部表情识别 (FER) 在计算机安全、神经科学、心理学和工程学方面有大量应用。由于其非侵入性&#xff0c;它被认为是打击犯罪的有用技术。然而&#xff0c;FER 面临着几个挑战&#xff0c;其中最严重的是它在严重的头部姿势下的预测…
阅读更多...
浅谈二维数组元素的地址

浅谈二维数组元素的地址

一维数组元素的地址大家都比较容易理解&#xff0c;但对于二维数组&#xff0c;就很容易搞混了.今天我又被这个问题给弄糊涂了&#xff0c;翻了翻老谭的书本&#xff0c;对这个问题有了更深的认识. 首先给出一个二维数组a&#xff0c;它的定义为: int a[3][4] {{1,3,5,7}, {9,…
阅读更多...
同花顺2023届春招内推

同花顺2023届春招内推

同花顺2023届春招开始啦&#xff01; 同花顺是国内首家上市的互联网金融信息服务平台&#xff0c;如果你对互联网金融感兴趣&#xff0c;如果你有志向在人工智能方向发挥所长&#xff0c;如果你也是一个激情澎湃的小伙伴&#xff0c;欢迎加入我们&#xff01;岗位类别&#xf…
阅读更多...
企业级信息系统开发学习笔记1.1 初探Spring——采用Spring配置文件管理Bean

企业级信息系统开发学习笔记1.1 初探Spring——采用Spring配置文件管理Bean

文章目录零、本讲学习目标一、Web开发技术二、Spring框架&#xff08;一&#xff09;Spring官网&#xff08;二&#xff09;Spring框架优点&#xff08;三&#xff09;为什么要选择Spring&#xff1f;&#xff08;四&#xff09; Spring框架因何而来&#xff08;五&#xff09;…
阅读更多...
寒假学习内容总结

寒假学习内容总结

1.html看视频过了一遍&#xff0c;没什么要学的。 2.CSS系统学习完了 全程做了详细的笔记 并复刻了几个网页页面 规范了自己的css代码书写方式 http://t.csdn.cn/VxOih css引入方式&#xff0c;字体&#xff0c; 文本水平对齐方式&#xff0c;选择器&#xff0c;快捷语法&…
阅读更多...
解决Idea启动项目失败，提示Error running ‘XXXApplication‘: Command line is too long

解决Idea启动项目失败，提示Error running ‘XXXApplication‘: Command line is too long

IDEA版本为&#xff1a;IntelliJ IDEA 2018.2 (Ultimate Edition)一、问题描述有时当我们使用IDEA&#xff0c;Run/Debug一个SpringBoot项目时&#xff0c;可能会启动失败&#xff0c;并提示以下错误。Error running XXXApplication: Command line is too long. Shorten comman…
阅读更多...
Transformer简介

Transformer简介

Transformer: 总体架构 Transformer是“编码器—解码器”架构&#xff0c;由编码器(encoder)和解码器(decoder)组成&#xff0c;其都是多头自注意力模块的叠加。其中&#xff0c;input sequence分成两部分&#xff0c;分别为源(input)输入序列和目标(output)输出序列。前者输入…
阅读更多...
包管理工具-npm-npx-yarn-cnpm

包管理工具-npm-npx-yarn-cnpm

代码共享方案 在我们通过模块化的方式将代码划分成一个个小的结构后&#xff0c;在以后的开发中我们就可以通过模块化的方式来封装自己的代码&#xff0c;并且封装成一个工具&#xff0c;这个工具我们可以让同事通过导入的方式来使用&#xff0c;甚至你可以分享给世界各地的程…
阅读更多...
数字货币的路在哪里？

数字货币的路在哪里？

在人工智能、分布式数据、边缘计算等核心技术不断发展和普及的过程中&#xff0c;Web3 以其对传统互联网的惊人重塑展现出无穷的发展潜力。在最初的构想中&#xff0c;数字货币是方便用户在 Web3 世界自由交互的通行证。但随着加密货币市场刚刚从长期的动荡中缓慢复苏&#xff…
阅读更多...
4个月的测试经验，来面试就开口要17K，面试完，我连5K都不想给他.....

4个月的测试经验，来面试就开口要17K，面试完，我连5K都不想给他.....

2021年8月份我入职了深圳某家创业公司&#xff0c;刚入职还是很兴奋的&#xff0c;到公司一看我傻了&#xff0c;公司除了我一个测试&#xff0c;公司的开发人员就只有3个前端2个后端还有2个UI&#xff0c;在粗略了解公司的业务后才发现是一个从零开始的项目&#xff0c;目前啥…
阅读更多...
系统应用 odex 转 dex

系统应用 odex 转 dex

说下为什会有这个需求&#xff0c;以某系统应用为例&#xff0c;我们通过 adb 获取到的 apk 反编译查看只有少部分代码和资源&#xff0c;关键代码看不到。 经过一系列操作&#xff0c;把 odex 转换为 dex 可以看到源码。 工具下载 Smali 下载 1、使用 adb shell pm list pa…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023