ffmpeg笔记

struct AVBuffer {
    uint8_t *data; /**< data described by this buffer */
    int      size; /**< size of data in bytes */
    atomic_uint refcount;
    void (*free)(void *opaque, uint8_t *data);
    void *opaque;
    int flags;
};

/**
 * A reference to a data buffer.
 *
 * The size of this struct is not a part of the public ABI and it is not meant
 * to be allocated directly.
 */
typedef struct AVBufferRef {
    AVBuffer *buffer;
    uint8_t *data;
    int      size;
} AVBufferRef;

typedef struct BufferPoolEntry {
    uint8_t *data;
    void *opaque;
    void (*free)(void *opaque, uint8_t *data);
    AVBufferPool *pool;
    struct BufferPoolEntry *next;
} BufferPoolEntry;


struct AVBufferPool {
    AVMutex mutex;
    BufferPoolEntry *pool;
    atomic_uint refcount;
    int size;
    void *opaque;
    AVBufferRef* (*alloc)(int size);
    AVBufferRef* (*alloc2)(void *opaque, int size);
    void         (*pool_free)(void *opaque);
};	

/**
 * Allocate an AVBuffer of the given size using av_malloc().
 *
 * @return an AVBufferRef of given size or NULL when out of memory
 */
AVBufferRef *av_buffer_alloc(int size);


/**
 * Create an AVBuffer from an existing array.
 *
 * If this function is successful, data is owned by the AVBuffer. The caller may
 * only access data through the returned AVBufferRef and references derived from
 * it.
 * If this function fails, data is left untouched.
 * @param data   data array
 * @param size   size of data in bytes
 * @param free   a callback for freeing this buffer's data
 * @param opaque parameter to be got for processing or passed to free
 * @param flags  a combination of AV_BUFFER_FLAG_*
 *
 * @return an AVBufferRef referring to data on success, NULL on failure.
 */
AVBufferRef *av_buffer_create(uint8_t *data, int size,
			      void (*free)(void *opaque, uint8_t *data),
			      void *opaque, int flags);

/**
 * Allocate and initialize a buffer pool.
 *
 * @param size size of each buffer in this pool
 * @param alloc a function that will be used to allocate new buffers when the
 * pool is empty. May be NULL, then the default allocator will be used
 * (av_buffer_alloc()).
 * @return newly created buffer pool on success, NULL on error.
 */
AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size));


/**
 * Allocate and initialize a buffer pool with a more complex allocator.
 *
 * @param size size of each buffer in this pool
 * @param opaque arbitrary user data used by the allocator
 * @param alloc a function that will be used to allocate new buffers when the
 *              pool is empty.
 * @param pool_free a function that will be called immediately before the pool
 *                  is freed. I.e. after av_buffer_pool_uninit() is called
 *                  by the caller and all the frames are returned to the pool
 *                  and freed. It is intended to uninitialize the user opaque
 *                  data.
 * @return newly created buffer pool on success, NULL on error.
 */
AVBufferPool *av_buffer_pool_init2(int size, void *opaque,
				   AVBufferRef* (*alloc)(void *opaque, int size),
				   void (*pool_free)(void *opaque));

AVBufferRef *av_buffer_ref(AVBufferRef *buf)
{
    AVBufferRef *ret = av_mallocz(sizeof(*ret));

    if (!ret)
	return NULL;

    *ret = *buf;

    atomic_fetch_add_explicit(&buf->buffer->refcount, 1, memory_order_relaxed);

    return ret;
}

int av_buffer_make_writable(AVBufferRef **pbuf)
{
    AVBufferRef *newbuf, *buf = *pbuf;

    if (av_buffer_is_writable(buf))
	return 0;

    newbuf = av_buffer_alloc(buf->size);
    if (!newbuf)
	return AVERROR(ENOMEM);

    memcpy(newbuf->data, buf->data, buf->size);

    buffer_replace(pbuf, &newbuf);

    return 0;
}

typedef struct AVFrame {
#define AV_NUM_DATA_POINTERS 8
 
    uint8_t *data[AV_NUM_DATA_POINTERS];
    int linesize[AV_NUM_DATA_POINTERS];
    uint8_t **extended_data;

    /**
     * for some private data of the user
     */
    void *opaque;
    
    AVBufferRef *buf[AV_NUM_DATA_POINTERS];
    AVBufferRef **extended_buf;
    int        nb_extended_buf;

    AVBufferRef *hw_frames_ctx;
    
    AVBufferRef *opaque_ref;
} AVFrame;

int av_frame_ref(AVFrame *dst, const AVFrame *src)
{
    int i, ret = 0;

    ...

    /* duplicate the frame data if it's not refcounted */
    if (!src->buf[0]) {
	ret = av_frame_get_buffer(dst, 32);//[0]
	if (ret < 0)
	    return ret;

	ret = av_frame_copy(dst, src);//[1]
	if (ret < 0)
	    av_frame_unref(dst);

	return ret;
    }

    /* ref the buffers */
    for (i = 0; i < FF_ARRAY_ELEMS(src->buf); i++) {
	if (!src->buf[i])
	    continue;
	dst->buf[i] = av_buffer_ref(src->buf[i]);//[2]
	if (!dst->buf[i]) {
	    ret = AVERROR(ENOMEM);
	    goto fail;
	}
    }

    if (src->extended_buf) {
	dst->extended_buf = av_mallocz_array(sizeof(*dst->extended_buf),
				       src->nb_extended_buf);
	if (!dst->extended_buf) {
	    ret = AVERROR(ENOMEM);
	    goto fail;
	}
	dst->nb_extended_buf = src->nb_extended_buf;

	for (i = 0; i < src->nb_extended_buf; i++) {
	    dst->extended_buf[i] = av_buffer_ref(src->extended_buf[i]);//[3]
	    if (!dst->extended_buf[i]) {
		ret = AVERROR(ENOMEM);
		goto fail;
	    }
	}
    }

    if (src->hw_frames_ctx) {
	dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);//[4]
	if (!dst->hw_frames_ctx) {
	    ret = AVERROR(ENOMEM);
	    goto fail;
	}
    }

    /* duplicate extended data */
    if (src->extended_data != src->data) {
	int ch = src->channels;

	if (!ch) {
	    ret = AVERROR(EINVAL);
	    goto fail;
	}
	CHECK_CHANNELS_CONSISTENCY(src);

	dst->extended_data = av_malloc_array(sizeof(*dst->extended_data), ch);
	if (!dst->extended_data) {
	    ret = AVERROR(ENOMEM);
	    goto fail;
	}
	memcpy(dst->extended_data, src->extended_data, sizeof(*src->extended_data) * ch);
    } else
	dst->extended_data = dst->data;

    memcpy(dst->data,     src->data,     sizeof(src->data));
    memcpy(dst->linesize, src->linesize, sizeof(src->linesize));

    return 0;

fail:
    av_frame_unref(dst);
    return ret;
}

AVFrame *av_frame_alloc(void)
{
    AVFrame *frame = av_mallocz(sizeof(*frame));

    if (!frame)
	return NULL;

    frame->extended_data = NULL;
    get_frame_defaults(frame);

    return frame;
}

static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
{
	const AVHWAccel *hwaccel = avctx->hwaccel;

	...

	if(hwaccel){
		if(hwaccel->alloc_frame){
			hwaccel->alloc_frame(avctx, frame);//[0]
		}
	}else{
		avctx->sw_pix_fmt = avctx->pix_fmt;
	}

	avctx->get_buffer2(avctx, frame, flag);//[1]

	...

	return ret;
}

FILE *fp_in = NULL;
AVFrame *frame_in;
unsigned char *frame_buffer_in;

fp_in = fopen("xxx.yuv", "rb");

/**
 * 先分配一个'空壳'avframe对象.
 */
frame_in = av_frame_alloc();

/**
 * 申请一张图片所需要的实际内存。
 */
frame_buffer_in = av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, in_width, in_height, 1));

/**
 * 根据图片格式和宽度信息填充avframe对象中的linesize字段，即yuv各个分量的数据量大小。
 */
av_image_fill_linesizes(frame_in->linesize, AV_PIX_FMT_YUV420P, in_width);

while(fread(frame_buffer_in, in_width*in_height*3/2,1, fp_in) == 1){
	/**
	 * 将读取的图片信息装载进avframe中。
	 */
	av_image_fill_pointers(frame_in->data, AV_PIX_FMT_YUV420P,in_widht, frame_buffer_in, frame_in->linesize);
	
	...
}

typedef struct AVPacket {

    AVBufferRef *buf;
    
    ...
    
    uint8_t *data;
    int   size;
    int   stream_index;
    /**
     * A combination of AV_PKT_FLAG values
     */
    int   flags;
    /**
     * Additional packet data that can be provided by the container.
     * Packet can contain several types of side information.
     */
    AVPacketSideData *side_data;
    int side_data_elems;

    int64_t duration;
    int64_t pos;                            ///< byte position in stream, -1 if unknown
} AVPacket;

/**
 * Allocate an AVPacket and set its fields to default values.  The resulting
 * struct must be freed using av_packet_free().
 *
 * @return An AVPacket filled with default values or NULL on failure.
 *
 * @note this only allocates the AVPacket itself, not the data buffers. Those
 * must be allocated through other means such as av_new_packet.
 *
 * @see av_new_packet
 */
AVPacket *av_packet_alloc(void)
{
    AVPacket *pkt = av_mallocz(sizeof(AVPacket));
    if (!pkt)
	return pkt;

    av_packet_unref(pkt);

    return pkt;
}

static int packet_alloc(AVBufferRef **buf, int size)
{
    int ret;
    if (size < 0 || size >= INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
	return AVERROR(EINVAL);

    ret = av_buffer_realloc(buf, size + AV_INPUT_BUFFER_PADDING_SIZE);
    if (ret < 0)
	return ret;

    memset((*buf)->data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

    return 0;
}

/**
 * Allocate the payload of a packet and initialize its fields with
 * default values.
 *
 * @param pkt packet
 * @param size wanted payload size
 * @return 0 if OK, AVERROR_xxx otherwise
 */
int av_new_packet(AVPacket *pkt, int size)
{
    AVBufferRef *buf = NULL;
    int ret = packet_alloc(&buf, size);
    if (ret < 0)
	return ret;

    av_init_packet(pkt);
    pkt->buf      = buf;
    pkt->data     = buf->data;
    pkt->size     = size;

    return 0;
}

for(buf = buf_list; buf; buf = buf->next){
	
	av_new_packet(pkt, buf->size);
	
	memcpy(pkt->data, buf->buf, buf->size);
}

void av_packet_unref(AVPacket *pkt)
{
    av_packet_free_side_data(pkt);
    av_buffer_unref(&pkt->buf);
    av_init_packet(pkt);
    pkt->data = NULL;
    pkt->size = 0;
}

int av_packet_ref(AVPacket *dst, const AVPacket *src)
{
    int ret;

    ret = av_packet_copy_props(dst, src);
    if (ret < 0)
	return ret;

    if (!src->buf) {
	ret = packet_alloc(&dst->buf, src->size);
	if (ret < 0)
	    goto fail;
	if (src->size)
	    memcpy(dst->buf->data, src->data, src->size);

	dst->data = dst->buf->data;
    } else {
	dst->buf = av_buffer_ref(src->buf);
	if (!dst->buf) {
	    ret = AVERROR(ENOMEM);
	    goto fail;
	}
	dst->data = src->data;
    }

    dst->size = src->size;

    return 0;
fail:
    av_packet_free_side_data(dst);
    return ret;
}

/**
 * Filter definition. This defines the pads a filter contains, and all the
 * callback functions used to interact with the filter.
 */
typedef struct AVFilter {
    /**
     * Filter name. Must be non-NULL and unique among filters.
     */
    const char *name;

    ...

    const AVFilterPad *inputs;
    const AVFilterPad *outputs;

    ...

    int (*preinit)(AVFilterContext *ctx);
    int (*init)(AVFilterContext *ctx);
    int (*init_dict)(AVFilterContext *ctx, AVDictionary **options);
    void (*uninit)(AVFilterContext *ctx);
    int (*query_formats)(AVFilterContext *);

    ...

    /**
     * Used by the filter registration system. Must not be touched by any other
     * code.
     */
    struct AVFilter *next;

    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
    int (*init_opaque)(AVFilterContext *ctx, void *opaque);
    int (*activate)(AVFilterContext *ctx);
} AVFilter;

/** An instance of a filter */
struct AVFilterContext {
    const AVClass *av_class;        ///< needed for av_log() and filters common options

    const AVFilter *filter;         ///< the AVFilter of which this is an instance

    char *name;                     ///< name of this filter instance

    AVFilterPad   *input_pads;      ///< array of input pads
    AVFilterLink **inputs;          ///< array of pointers to input links
    unsigned    nb_inputs;          ///< number of input pads

    AVFilterPad   *output_pads;     ///< array of output pads
    AVFilterLink **outputs;         ///< array of pointers to output links
    unsigned    nb_outputs;         ///< number of output pads

    void *priv;                     ///< private data for use by the filter

    struct AVFilterGraph *graph;    ///< filtergraph this filter belongs to

    ...

    /**
     * An opaque struct for libavfilter internal use.
     */
    AVFilterInternal *internal;

    struct AVFilterCommand *command_queue;

    ...

    AVBufferRef *hw_device_ctx;

    ...

    /**
     * Ready status of the filter.
     * A non-0 value means that the filter needs activating;
     * a higher value suggests a more urgent activation.
     */
    unsigned ready;
};

/**
 * A filter pad used for either input or output.
 */
struct AVFilterPad {
   
    const char *name;

    /**
     * AVFilterPad type.
     */
    enum AVMediaType type;
   
    AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h);
    AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples);
    int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
    int (*poll_frame)(AVFilterLink *link);
    int (*request_frame)(AVFilterLink *link);
    int (*config_props)(AVFilterLink *link);

    int needs_fifo;
    int needs_writable;
};

/**
 * A link between two filters. This contains pointers to the source and
 * destination filters between which this link exists, and the indexes of
 * the pads involved. In addition, this link also contains the parameters
 * which have been negotiated and agreed upon between the filter, such as
 * image dimensions, format, etc.
 *
 * Applications must not normally access the link structure directly.
 * Use the buffersrc and buffersink API instead.
 * In the future, access to the header may be reserved for filters
 * implementation.
 */
struct AVFilterLink {
    AVFilterContext *src;       ///< source filter
    AVFilterPad *srcpad;        ///< output pad on the source filter
    AVFilterContext *dst;       ///< dest filter
    AVFilterPad *dstpad;        ///< input pad on the dest filter
    enum AVMediaType type;      ///< filter media type

    ...

    /**
     * Graph the filter belongs to.
     */
    struct AVFilterGraph *graph;

    ...

    int frame_wanted_out;

    AVBufferRef *hw_frames_ctx;

#ifndef FF_INTERNAL_FIELDS
    char reserved[0xF000];

#else /* FF_INTERNAL_FIELDS */

    /**
     * Queue of frames waiting to be filtered.
     */
    FFFrameQueue fifo;
    int frame_blocked_in;
    int status_in;
    int64_t status_in_pts;
    int status_out;

#endif /* FF_INTERNAL_FIELDS */

};

int avfilter_link(AVFilterContext *src, unsigned srcpad,
		  AVFilterContext *dst, unsigned dstpad)
{
    AVFilterLink *link;

    ...

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

    src->outputs[srcpad] = dst->inputs[dstpad] = link;//[0]

    link->src     = src;
    link->dst     = dst;
    link->srcpad  = &src->output_pads[srcpad];
    link->dstpad  = &dst->input_pads[dstpad];
    link->type    = src->output_pads[srcpad].type;
    av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
    link->format  = -1;
    ff_framequeue_init(&link->fifo, &src->graph->internal->frame_queues);

    return 0;
}

input --> hflip -->output

AVFilterContext *buffersink_ctx, *buffersrc_ctx;


avfilter_register_all();

AVFilterGraph *filter_graph = avfilter_grahp_alloc();

/**
 * 创建buffer这个filter实例，并放进graph的filter容器中。
 */
char args[512];
AVFilter *buffersrc = avfilter_get_by_name("buffer");
snprintf(args, sizeof(args), "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:
		pixel_aspect=%d/%d",w,h,AV_PIX_FMT_YUV420P,1,25,1,1);
avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);


/**
 * 创建buffersink实例，并放进graph的filter容器中。
 */
AVFilter *buffersink = avfilter_get_by_name("buffersink"); 
enum AVPixelFormat pix_fmts[] = {AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE};
buffersink_params = av_buffersink_params_alloc();
buffersink_params->pixel_fmts = pix_fmts;
avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, buffersink_params, filter_graph);
av_free(buffersink_params);

/**
 * 创建两个用于构建链路的节点(endpoint)对象实例，任何的链路都必须有'in'和'out'
 * 这两个endpoint。
 */
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs  = avfilter_inout_alloc();

outputs->name		= av_strdup("in");
outputs->filter_ctx	= buffersrc_ctx;
outputs->pad_idx	= 0;
outputs->next		= NULL;

inputs->name		= av_strdup("out");
inputs->filter_ctx 	= buffersink_ctx;
inputs->pad_idx		= 0;
inputs->next		= NULL;

/**
 * 自动创建hflip实例并构建最终的链路。
 */
const char *filter_desc = "hflip";
avfilter_graph_parse_ptr(filter_graph, filter_desc, &inputs, &outputs, NULL);

/**
 * 配置创建的链路。
 */
avfilter_graph_config(filter_graph, NULL);

		[main]
input --> split ------------------------------> overlay --> output
	     |					    ^	
	     | [tmp]			     [flip] |	
	     + -----> crop ---> vflip -------------+

outputs->name		= av_strdup("in");
outputs->filter_ctx	= buffersrc_ctx;
outputs->pad_idx	= 0;
outputs->next		= NULL;

inputs->name		= av_strdup("out");
inputs->filter_ctx 	= buffersink_ctx;
inputs->pad_idx		= 0;
inputs->next		= NULL;

int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters,
			 AVFilterInOut **open_inputs_ptr, AVFilterInOut **open_outputs_ptr,
			 void *log_ctx)
{
    int index = 0, ret = 0;
    char chr = 0;

    AVFilterInOut *curr_inputs = NULL;
    AVFilterInOut *open_inputs  = open_inputs_ptr  ? *open_inputs_ptr  : NULL;
    AVFilterInOut *open_outputs = open_outputs_ptr ? *open_outputs_ptr : NULL;

    if ((ret = parse_sws_flags(&filters, graph)) < 0)
	goto end;

    do {
	AVFilterContext *filter;
	const char *filterchain = filters;
	filters += strspn(filters, WHITESPACES);

	if ((ret = parse_inputs(&filters, &curr_inputs, &open_outputs, log_ctx)) < 0)//[0]
	    goto end;

	if ((ret = parse_filter(&filter, &filters, graph, index, log_ctx)) < 0)//[1]
	    goto end;

	...

	if ((ret = link_filter_inouts(filter, &curr_inputs, &open_inputs, log_ctx)) < 0)//[2]
	    goto end;

	if ((ret = parse_outputs(&filters, &curr_inputs, &open_inputs, &open_outputs,
				 log_ctx)) < 0)//[3]
	    goto end;

	filters += strspn(filters, WHITESPACES);
	chr = *filters++;
	
	...
	
	index++;
    } while (chr == ',' || chr == ';');//[4]

    ...
    
}

/*libavcodec/h264dec.c*/
static int h264_decode_frame(AVCodecContext *avctx, void *data, int *get_frame, AVPacket *avpkt)
{
	...
	
	/**
	 * end of stream, output what is still in the buffers
	 */
	if(buf_size == 0)
		return send_next_delayed_frame(h, pict, got_frame, 0);
		
	...
	
	decode_nal_units(h, buf, buf_size);//[0]
	 
	...
	
	ff_h264_field_end(h, &h->slice_ctx[0], 0);//[1]
	
	/**
	 * wait for second field.
	 */

	if(h->next_output_pic)
		finalize_frame(h, pict, h->next_output_pic, got_frame);//[2]
		
	...	
}

/*libavcodec/h264dec.c*/
static int decodec_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
{
	...
	
	/**
	 * 拆分协议信息。
	 */
	ff_h245_packet_split(&h->pkt, buf, buf_size, avctx, ...);
	
	...
	
	/**
	 * 对上面拆分出的各个NALU进行逐个解析。
	 */
	for(i = 0; i < h->pkt.nb_nals; i++)
	{
		...
		
		switch(nal->type){
			case H264_NAL_IDR_SLICE:
			case H264_NAL_SLICE_SCALABLE:
			case H264_NAL_SLICE:
				h->has_slice = 1;
				
				ff_h264_queue_decode_slice(h, nal);//[0]
				
				if(h->current_slice == 1){
					...
					
					/**
					 * avctx中的hwaccel句柄如果有效，说明开启的是vaapi流程。
					 */
					if(h->avctx->hwaccel)
						h->avctx->hwaccel->start_frame(...);	
						
					...	
				}
				
				max_slice_ctx = avctx->hwaccel ? 1 : h->nb_silce_ctx;
				if(h->nb_slice_ctx_queued == max_slice_ctx){
					if(h->avctx->hwaccel){
						/**
						 * 这里只是进行硬件解码器的参数设置。
						 */
						avctx->hwaccel->decoded_slice(...);
						h->nb_slice_ctx_queued = 0;
					}else{
						...
						/**
						 * 如果是软解，调用
						 * ff_h264_execute_decode_slice()进行解码。
						 */
					}
				}
				
				break;
				
			case H264_NAL_SEI:
				/**
				 * 解析SEI信息。
				 */
				 ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
				
			case H264_NAL_SPS:
				/**
				 * 解析sps信息。
				 */
				ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0);
				...
			break;
			
			case H264_NAL_PPS:
				/**
				 * 解析PPS信息。
				 */
				ff_h264_decode_picture_parameter_set(...);
				...
			break;
			
			case xxx:
				...
			
		}
		
		/**
		 * error handle
		 */
		 ...
	}
}

int ff_h264_queue_decode_slice(H264Context *h, H2645NAL *nal)
{
	H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
	int first_slice = sl = h->slice_ctx && !h->current_slice;
	
	...
	
	if(nal->type == H264_NAL_SLICE_SCALABLE && nal->svc_ext_flag == 1)
		h264_slice_header_in_scalable_ext_parse(h, sl, nal);//[0]
	else
		h264_slice_header_parse(h, sl, nal);//[1]
		
	...
	
	if(sl->first_mb_addr == 0){
		if(h->current_slice){
			/**
			 * 场解码处理
			 */
			...
		}
		/**
		 * 场解码处理
		 */
		...
	}
	
	if(!first_slice){
		/**
		 * 场解码中pps和sps一致性检测。
		 */
		...
	}
	
	if(h->current_slice == 0){
		/**
		 * 帧解码处理、或者是场解码中上半场处理。
		 */
		h264_field_start(h, sl, nal, first_slice);//[3]
	
	}else{
		/**
		 * 场解码中一致性检测。
		 */
		...
	}
	
	h264_slice_init(h, sl, nal);//[4]

	h->nb_slice_ctx_queued++;
	
	return 0;
}

/**
 * This function is called right after decoding the slice header for a first
 * slice in a field(or a frame). It decides whether we are decoding a new frame
 * or a second field in a pair and does the necessary setup
 */
static int h264_field_start(...)
{
	...
	
	if(h->poc.frame_num != h->poc.prev_frame_num){
		...
	}
	
	if(h->first_filed){
		...
	}
	
	...

	if(h->first_field){
	
	}else{
		/*frame or first field in a potentially complementary pair*/
		h->first_field = FIELD_PICTURE(h);
	}
	
	if(!FIELD_PICTURE(h) || h->first_field){
		h264_frame_start(h);//[0]
	}else{
		...
	}
	
	...
	
	ff_h264_init_poc(...);//[1]
	
	...
	
	if(!FIELD_PICTURE(h) || !h->first_field || h->missing_fileds > 1){
		...
		
		h264_select_output_frame(h);//[2]
	}
	
	return 0;
}

static int h264_frame_start(H264Context *h)
{
	...
	
	release_unused_pictures(h, 1);//[0]
	h->cur_pic_ptr = NULL;
	
	i = find_unused_picture(h);
	
	pic = &h->DPB[i];
	
	...
	
	/**
	 * Zero key_frame here; IDR markings per slice in frame or fields are ORed in later.
	 */
	pic->f->key_frame = 0; 
	...
	
	alloc_picture(h, pic);//[1]
	
	h->cur_pic_ptr = pic;
	ff_h264_unref_picture(h, &h->cur_pic);
	
	...
	
	ff_h264_ref_picture(h, &h->cur_pic, h->cur_pic_ptr);
	
	...
	

	h->cur_pic_ptr->reference = 0;
	
	h->next_output_pic = NULL;

	...
	
	return 0;
}

static int alloc_picture(H264Context *h, H264Picture *pic)
{
	...
	
	pic->tf.f = pic->f;
	/**
	 * 在硬件解码中，该函数会调用我们在初始化时注册的申请GPU内存的
	 * 的回调函数avctx->get_buffer2.
	 */
	ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ? AV_GET_BUFFER_FLAGS_REF:0);//[0]
	
	...
	
	/**
	 * 分配硬件解码vaapi对象，该对象在vaapi_h264.c文件中注册为ff_h264_vaapi_hwaccel。
	 * 这个vaapi对象作为h264解码器对象的priv域，相对于一个后端引擎。
	 * 这是软件分层设计的常规手法。
	 */
	if(h->avctx->hwaccel){
		const AVHWAccel *hwaccel = h->avctx->hwaccel;
		if(hwaccel->frame_priv_data_size){
			pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
			
			pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
		}
	}
	
	...
	
	return ret;
}

static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
{
	const AVHWAccel *hwaccel = avctx->hwaccel;
	
	...
	
	if(hwaccel){
		if(hwaccel->alloc_frame){
			hwaccel->alloc_frame(avctx, frame);//[0]
		}
	}else{
		avctx->sw_pix_fmt = avctx->pix_fmt;
	}
	
	avctx->get_buffer2(avctx, frame, flag);//[1]
		
	...
	
	return ret;
}

static int va_get_buffer(struct AVCodecContext *avctx, AVFrame *pic, int flags)
{
	AVBufferRef *surf_buf = NULL;
	vaapi_surface_t *surface = NULL;
	
	...
	
	surface = (uint8_t *)(uintptr_t)(surface_id);//[0]
	
	surf_buf = av_buffer_create(NULL, 0, free_surf_buf, surface, AV_BUFFER_FLAG_READONLY);
	
	pic->buf[0] = surf_buf;
	/**
	 * 软解时使用data[0-2]传递解码数据的CPU内存地址，
	 * 硬解时使用data[3]传递解码后GPU内存句柄，即surface_id。
	 */
	pic->data[3] = surface;

	return 0;
}

static int h264_select_output_frame(H264Context *h)
{
	H264Picture *cur = h->cur_pic_ptr;

	...

	pics = 0;
	while(h->delayed_pic[pics])
		pics++;

	h->delayed_pic[pics++] = cur;

	...

	if(!out_of_order || pics > h->avctx->has_b_frames){
	        /**
		 * next_output_pic就是指向了下个要输出的帧，这帧可能是
		 * 之前解码后缓存到h->delayed_pic[]中的，也可能就是上面通过调用
		 * va_get_buffer()刚刚创建的GPU用来存储解码后数据的内存。
		 */
		h->next_output_pic = out;
		
		...
	}
	
	...
}

int ff_h264_field_end(H264Context *h. H264SliceContext *sl, int in_setup)
{
	AVCodecContext *const avctx = h->avctx;
	
	...
	
	if(avctx->hwaccel){
		avctx->hwaccel->end_frame(avctx);
	}

	...
}

static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
{
	...
	
	output_frame(h, dst, out);
	
	*got_frame = 1;

	...
}

static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
{
	AVFrame *src = srcp->f;
	
	...
	
	av_frame_ref(dst, src);
	
	...
}