FFmpeg
vaapi_h264.c
Go to the documentation of this file.
1 /*
2  * H.264 HW decode acceleration through VA API
3  *
4  * Copyright (C) 2008-2009 Splitted-Desktop Systems
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "h264dec.h"
24 #include "h264_ps.h"
25 #include "hwaccel_internal.h"
26 #include "vaapi_decode.h"
27 
28 /**
29  * @file
30  * This file implements the glue code between FFmpeg's and VA API's
31  * structures for H.264 decoding.
32  */
33 
34 /**
35  * Initialize an empty VA API picture.
36  *
37  * VA API requires a fixed-size reference picture array.
38  */
39 static void init_vaapi_pic(VAPictureH264 *va_pic)
40 {
41  va_pic->picture_id = VA_INVALID_ID;
42  va_pic->flags = VA_PICTURE_H264_INVALID;
43  va_pic->TopFieldOrderCnt = 0;
44  va_pic->BottomFieldOrderCnt = 0;
45 }
46 
47 /**
48  * Translate an FFmpeg Picture into its VA API form.
49  *
50  * @param[out] va_pic A pointer to VA API's own picture struct
51  * @param[in] pic A pointer to the FFmpeg picture struct to convert
52  * @param[in] pic_structure The picture field type (as defined in mpegvideo.h),
53  * supersedes pic's field type if nonzero.
54  */
55 static void fill_vaapi_pic(VAPictureH264 *va_pic,
56  const H264Picture *pic,
57  int pic_structure)
58 {
59  if (pic_structure == 0)
60  pic_structure = pic->reference;
61  pic_structure &= PICT_FRAME; /* PICT_TOP_FIELD|PICT_BOTTOM_FIELD */
62 
63  va_pic->picture_id = ff_vaapi_get_surface_id(pic->f);
64  va_pic->frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;
65 
66  va_pic->flags = 0;
67  if (pic_structure != PICT_FRAME)
68  va_pic->flags |= (pic_structure & PICT_TOP_FIELD) ? VA_PICTURE_H264_TOP_FIELD : VA_PICTURE_H264_BOTTOM_FIELD;
69  if (pic->reference)
70  va_pic->flags |= pic->long_ref ? VA_PICTURE_H264_LONG_TERM_REFERENCE : VA_PICTURE_H264_SHORT_TERM_REFERENCE;
71 
72  va_pic->TopFieldOrderCnt = 0;
73  if (pic->field_poc[0] != INT_MAX)
74  va_pic->TopFieldOrderCnt = pic->field_poc[0];
75 
76  va_pic->BottomFieldOrderCnt = 0;
77  if (pic->field_poc[1] != INT_MAX)
78  va_pic->BottomFieldOrderCnt = pic->field_poc[1];
79 }
80 
81 /** Decoded Picture Buffer (DPB). */
82 typedef struct DPB {
83  int size; ///< Current number of reference frames in the DPB
84  int max_size; ///< Max number of reference frames. This is FF_ARRAY_ELEMS(VAPictureParameterBufferH264.ReferenceFrames)
85  VAPictureH264 *va_pics; ///< Pointer to VAPictureParameterBufferH264.ReferenceFrames array
86 } DPB;
87 
88 /**
89  * Append picture to the decoded picture buffer, in a VA API form that
90  * merges the second field picture attributes with the first, if
91  * available. The decoded picture buffer's size must be large enough
92  * to receive the new VA API picture object.
93  */
94 static int dpb_add(DPB *dpb, const H264Picture *pic)
95 {
96  int i, pic_frame_idx, merged = 0;
97 
98  if (dpb->size >= dpb->max_size)
99  return -1;
100 
101  pic_frame_idx = pic->long_ref ? pic->pic_id : pic->frame_num;
102 
103  for (i = 0; i < dpb->size; i++) {
104  VAPictureH264 * const va_pic = &dpb->va_pics[i];
105  int va_pic_long_ref = !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);
106  if (va_pic->picture_id == ff_vaapi_get_surface_id(pic->f) &&
107  va_pic_long_ref == pic->long_ref &&
108  va_pic->frame_idx == pic_frame_idx) {
109  VAPictureH264 temp_va_pic;
110  fill_vaapi_pic(&temp_va_pic, pic, 0);
111 
112  if ((temp_va_pic.flags ^ va_pic->flags) & (VA_PICTURE_H264_TOP_FIELD | VA_PICTURE_H264_BOTTOM_FIELD)) {
113  va_pic->flags |= temp_va_pic.flags & (VA_PICTURE_H264_TOP_FIELD | VA_PICTURE_H264_BOTTOM_FIELD);
114  /* Merge second field */
115  if (temp_va_pic.flags & VA_PICTURE_H264_TOP_FIELD) {
116  va_pic->TopFieldOrderCnt = temp_va_pic.TopFieldOrderCnt;
117  } else {
118  va_pic->BottomFieldOrderCnt = temp_va_pic.BottomFieldOrderCnt;
119  }
120  merged = 1;
121  }
122  }
123  }
124 
125  if (merged)
126  return 0;
127 
128  fill_vaapi_pic(&dpb->va_pics[dpb->size++], pic, 0);
129  return 0;
130 }
131 
132 /** Fill in VA API reference frames array. */
133 static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param,
134  const H264Context *h)
135 {
136  DPB dpb;
137  int i;
138 
139  dpb.size = 0;
140  dpb.max_size = FF_ARRAY_ELEMS(pic_param->ReferenceFrames);
141  dpb.va_pics = pic_param->ReferenceFrames;
142  for (i = 0; i < dpb.max_size; i++)
143  init_vaapi_pic(&dpb.va_pics[i]);
144 
145  for (i = 0; i < h->short_ref_count; i++) {
146  const H264Picture *pic = h->short_ref[i];
147  if (pic && pic->reference && dpb_add(&dpb, pic) < 0)
148  return -1;
149  }
150 
151  for (i = 0; i < 16; i++) {
152  const H264Picture *pic = h->long_ref[i];
153  if (pic && pic->reference && dpb_add(&dpb, pic) < 0)
154  return -1;
155  }
156  return 0;
157 }
158 
159 /**
160  * Fill in VA API reference picture lists from the FFmpeg reference
161  * picture list.
162  *
163  * @param[out] RefPicList VA API internal reference picture list
164  * @param[in] ref_list A pointer to the FFmpeg reference list
165  * @param[in] ref_count The number of reference pictures in ref_list
166  */
167 static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32],
168  const H264Ref *ref_list,
169  unsigned int ref_count)
170 {
171  unsigned int i, n = 0;
172  for (i = 0; i < ref_count; i++)
173  if (ref_list[i].reference)
174  fill_vaapi_pic(&RefPicList[n++], ref_list[i].parent,
175  ref_list[i].reference);
176 
177  for (; n < 32; n++)
179 }
180 
181 /**
182  * Fill in prediction weight table.
183  *
184  * VA API requires a plain prediction weight table as it does not infer
185  * any value.
186  *
187  * @param[in] h A pointer to the current H.264 context
188  * @param[in] list The reference frame list index to use
189  * @param[out] luma_weight_flag VA API plain luma weight flag
190  * @param[out] luma_weight VA API plain luma weight table
191  * @param[out] luma_offset VA API plain luma offset table
192  * @param[out] chroma_weight_flag VA API plain chroma weight flag
193  * @param[out] chroma_weight VA API plain chroma weight table
194  * @param[out] chroma_offset VA API plain chroma offset table
195  */
197  int list,
198  unsigned char *luma_weight_flag,
199  short luma_weight[32],
200  short luma_offset[32],
201  unsigned char *chroma_weight_flag,
202  short chroma_weight[32][2],
203  short chroma_offset[32][2])
204 {
205  const H264SliceContext *sl = &h->slice_ctx[0];
206  unsigned int i, j;
207 
208  *luma_weight_flag = sl->pwt.luma_weight_flag[list];
209  *chroma_weight_flag = sl->pwt.chroma_weight_flag[list];
210 
211  for (i = 0; i < sl->ref_count[list]; i++) {
212  /* VA API also wants the inferred (default) values, not
213  only what is available in the bitstream (7.4.3.2). */
214  if (sl->pwt.luma_weight_flag[list]) {
215  luma_weight[i] = sl->pwt.luma_weight[i][list][0];
216  luma_offset[i] = sl->pwt.luma_weight[i][list][1];
217  } else {
218  luma_weight[i] = 1 << sl->pwt.luma_log2_weight_denom;
219  luma_offset[i] = 0;
220  }
221  for (j = 0; j < 2; j++) {
222  if (sl->pwt.chroma_weight_flag[list]) {
223  chroma_weight[i][j] = sl->pwt.chroma_weight[i][list][j][0];
224  chroma_offset[i][j] = sl->pwt.chroma_weight[i][list][j][1];
225  } else {
226  chroma_weight[i][j] = 1 << sl->pwt.chroma_log2_weight_denom;
227  chroma_offset[i][j] = 0;
228  }
229  }
230  }
231 }
232 
233 /** Initialize and start decoding a frame with VA API. */
235  av_unused const uint8_t *buffer,
236  av_unused uint32_t size)
237 {
238  const H264Context *h = avctx->priv_data;
239  VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
240  const PPS *pps = h->ps.pps;
241  const SPS *sps = h->ps.sps;
242  VAPictureParameterBufferH264 pic_param;
243  VAIQMatrixBufferH264 iq_matrix;
244  int err;
245 
246  pic->output_surface = ff_vaapi_get_surface_id(h->cur_pic_ptr->f);
247 
248  pic_param = (VAPictureParameterBufferH264) {
249  .picture_width_in_mbs_minus1 = h->mb_width - 1,
250  .picture_height_in_mbs_minus1 = h->mb_height - 1,
251  .bit_depth_luma_minus8 = sps->bit_depth_luma - 8,
252  .bit_depth_chroma_minus8 = sps->bit_depth_chroma - 8,
253  .num_ref_frames = sps->ref_frame_count,
254  .seq_fields.bits = {
255  .chroma_format_idc = sps->chroma_format_idc,
256  .residual_colour_transform_flag = sps->residual_color_transform_flag,
257  .gaps_in_frame_num_value_allowed_flag = sps->gaps_in_frame_num_allowed_flag,
258  .frame_mbs_only_flag = sps->frame_mbs_only_flag,
259  .mb_adaptive_frame_field_flag = sps->mb_aff,
260  .direct_8x8_inference_flag = sps->direct_8x8_inference_flag,
261  .MinLumaBiPredSize8x8 = sps->level_idc >= 31, /* A.3.3.2 */
262  .log2_max_frame_num_minus4 = sps->log2_max_frame_num - 4,
263  .pic_order_cnt_type = sps->poc_type,
264  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
265  .delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag,
266  },
267  .pic_init_qp_minus26 = pps->init_qp - 26,
268  .pic_init_qs_minus26 = pps->init_qs - 26,
269  .chroma_qp_index_offset = pps->chroma_qp_index_offset[0],
270  .second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1],
271  .pic_fields.bits = {
272  .entropy_coding_mode_flag = pps->cabac,
273  .weighted_pred_flag = pps->weighted_pred,
274  .weighted_bipred_idc = pps->weighted_bipred_idc,
275  .transform_8x8_mode_flag = pps->transform_8x8_mode,
276  .field_pic_flag = h->picture_structure != PICT_FRAME,
277  .constrained_intra_pred_flag = pps->constrained_intra_pred,
278  .pic_order_present_flag = pps->pic_order_present,
279  .deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present,
280  .redundant_pic_cnt_present_flag = pps->redundant_pic_cnt_present,
281  .reference_pic_flag = h->nal_ref_idc != 0,
282  },
283  .frame_num = h->poc.frame_num,
284  };
285 
286  fill_vaapi_pic(&pic_param.CurrPic, h->cur_pic_ptr, h->picture_structure);
287  err = fill_vaapi_ReferenceFrames(&pic_param, h);
288  if (err < 0)
289  goto fail;
290 
291  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
292  VAPictureParameterBufferType,
293  &pic_param, sizeof(pic_param));
294  if (err < 0)
295  goto fail;
296 
297  memcpy(iq_matrix.ScalingList4x4,
298  pps->scaling_matrix4, sizeof(iq_matrix.ScalingList4x4));
299  memcpy(iq_matrix.ScalingList8x8[0],
300  pps->scaling_matrix8[0], sizeof(iq_matrix.ScalingList8x8[0]));
301  memcpy(iq_matrix.ScalingList8x8[1],
302  pps->scaling_matrix8[3], sizeof(iq_matrix.ScalingList8x8[0]));
303 
304  err = ff_vaapi_decode_make_param_buffer(avctx, pic,
305  VAIQMatrixBufferType,
306  &iq_matrix, sizeof(iq_matrix));
307  if (err < 0)
308  goto fail;
309 
310  return 0;
311 
312 fail:
313  ff_vaapi_decode_cancel(avctx, pic);
314  return err;
315 }
316 
317 /** End a hardware decoding based frame. */
319 {
320  const H264Context *h = avctx->priv_data;
321  VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
322  H264SliceContext *sl = &h->slice_ctx[0];
323  int ret;
324 
325  ret = ff_vaapi_decode_issue(avctx, pic);
326  if (ret < 0)
327  goto finish;
328 
329  ff_h264_draw_horiz_band(h, sl, 0, h->avctx->height);
330 
331 finish:
332  return ret;
333 }
334 
335 /** Decode the given H.264 slice with VA API. */
337  const uint8_t *buffer,
338  uint32_t size)
339 {
340  const H264Context *h = avctx->priv_data;
341  VAAPIDecodePicture *pic = h->cur_pic_ptr->hwaccel_picture_private;
342  const H264SliceContext *sl = &h->slice_ctx[0];
343  VASliceParameterBufferH264 slice_param;
344  int err;
345 
346  slice_param = (VASliceParameterBufferH264) {
347  .slice_data_size = size,
348  .slice_data_offset = 0,
349  .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
350  .slice_data_bit_offset = get_bits_count(&sl->gb),
351  .first_mb_in_slice = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x,
352  .slice_type = ff_h264_get_slice_type(sl),
353  .direct_spatial_mv_pred_flag = sl->slice_type == AV_PICTURE_TYPE_B ? sl->direct_spatial_mv_pred : 0,
354  .num_ref_idx_l0_active_minus1 = sl->list_count > 0 ? sl->ref_count[0] - 1 : 0,
355  .num_ref_idx_l1_active_minus1 = sl->list_count > 1 ? sl->ref_count[1] - 1 : 0,
356  .cabac_init_idc = sl->cabac_init_idc,
357  .slice_qp_delta = sl->qscale - h->ps.pps->init_qp,
358  .disable_deblocking_filter_idc = sl->deblocking_filter < 2 ? !sl->deblocking_filter : sl->deblocking_filter,
359  .slice_alpha_c0_offset_div2 = sl->slice_alpha_c0_offset / 2,
360  .slice_beta_offset_div2 = sl->slice_beta_offset / 2,
361  .luma_log2_weight_denom = sl->pwt.luma_log2_weight_denom,
362  .chroma_log2_weight_denom = sl->pwt.chroma_log2_weight_denom,
363  };
364 
365  fill_vaapi_RefPicList(slice_param.RefPicList0, sl->ref_list[0],
366  sl->list_count > 0 ? sl->ref_count[0] : 0);
367  fill_vaapi_RefPicList(slice_param.RefPicList1, sl->ref_list[1],
368  sl->list_count > 1 ? sl->ref_count[1] : 0);
369 
371  &slice_param.luma_weight_l0_flag,
372  slice_param.luma_weight_l0,
373  slice_param.luma_offset_l0,
374  &slice_param.chroma_weight_l0_flag,
375  slice_param.chroma_weight_l0,
376  slice_param.chroma_offset_l0);
378  &slice_param.luma_weight_l1_flag,
379  slice_param.luma_weight_l1,
380  slice_param.luma_offset_l1,
381  &slice_param.chroma_weight_l1_flag,
382  slice_param.chroma_weight_l1,
383  slice_param.chroma_offset_l1);
384 
385  err = ff_vaapi_decode_make_slice_buffer(avctx, pic,
386  &slice_param, 1, sizeof(slice_param),
387  buffer, size);
388  if (err) {
389  ff_vaapi_decode_cancel(avctx, pic);
390  return err;
391  }
392 
393  return 0;
394 }
395 
397  .p.name = "h264_vaapi",
398  .p.type = AVMEDIA_TYPE_VIDEO,
399  .p.id = AV_CODEC_ID_H264,
400  .p.pix_fmt = AV_PIX_FMT_VAAPI,
401  .start_frame = &vaapi_h264_start_frame,
402  .end_frame = &vaapi_h264_end_frame,
403  .decode_slice = &vaapi_h264_decode_slice,
404  .frame_priv_data_size = sizeof(VAAPIDecodePicture),
407  .frame_params = &ff_vaapi_common_frame_params,
408  .priv_data_size = sizeof(VAAPIDecodeContext),
409  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
410 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
ff_vaapi_get_surface_id
static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
Definition: vaapi_decode.h:30
H264Picture::f
AVFrame * f
Definition: h264dec.h:115
VAAPIDecodeContext
Definition: vaapi_decode.h:47
H264Ref
Definition: h264dec.h:169
vaapi_decode.h
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
av_unused
#define av_unused
Definition: attributes.h:131
FFHWAccel::p
AVHWAccel p
The public AVHWAccel.
Definition: hwaccel_internal.h:38
VAAPIDecodePicture
Definition: vaapi_decode.h:35
vaapi_h264_start_frame
static int vaapi_h264_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Initialize and start decoding a frame with VA API.
Definition: vaapi_h264.c:234
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:270
DPB
Decoded Picture Buffer (DPB).
Definition: vaapi_h264.c:82
RefPicList
Definition: hevcdec.h:192
fill_vaapi_RefPicList
static void fill_vaapi_RefPicList(VAPictureH264 RefPicList[32], const H264Ref *ref_list, unsigned int ref_count)
Fill in VA API reference picture lists from the FFmpeg reference picture list.
Definition: vaapi_h264.c:167
DPB::size
int size
Current number of reference frames in the DPB.
Definition: vaapi_h264.c:83
ff_h264_vaapi_hwaccel
const FFHWAccel ff_h264_vaapi_hwaccel
Definition: vaapi_h264.c:396
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:233
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:136
H264SliceContext
Definition: h264dec.h:180
vaapi_h264_decode_slice
static int vaapi_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Decode the given H.264 slice with VA API.
Definition: vaapi_h264.c:336
ff_vaapi_decode_make_param_buffer
int ff_vaapi_decode_make_param_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, int type, const void *data, size_t size)
Definition: vaapi_decode.c:34
finish
static void finish(void)
Definition: movenc.c:373
FFHWAccel
Definition: hwaccel_internal.h:34
fail
#define fail()
Definition: checkasm.h:188
DPB::max_size
int max_size
Max number of reference frames. This is FF_ARRAY_ELEMS(VAPictureParameterBufferH264....
Definition: vaapi_h264.c:84
H264SliceContext::deblocking_filter
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:196
H264PredWeightTable::luma_log2_weight_denom
int luma_log2_weight_denom
Definition: h264_parse.h:72
H264SliceContext::direct_spatial_mv_pred
int direct_spatial_mv_pred
Definition: h264dec.h:254
VAAPIDecodePicture::output_surface
VASurfaceID output_surface
Definition: vaapi_decode.h:36
H264PredWeightTable::chroma_weight
int chroma_weight[48][2][2][2]
Definition: h264_parse.h:78
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_vaapi_decode_init
int ff_vaapi_decode_init(AVCodecContext *avctx)
Definition: vaapi_decode.c:692
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:73
ff_vaapi_common_frame_params
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: vaapi_decode.c:668
H264PredWeightTable::chroma_weight_flag
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Definition: h264_parse.h:75
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
H264SliceContext::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264dec.h:197
ff_vaapi_decode_uninit
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
Definition: vaapi_decode.c:738
fill_vaapi_plain_pred_weight_table
static void fill_vaapi_plain_pred_weight_table(const H264Context *h, int list, unsigned char *luma_weight_flag, short luma_weight[32], short luma_offset[32], unsigned char *chroma_weight_flag, short chroma_weight[32][2], short chroma_offset[32][2])
Fill in prediction weight table.
Definition: vaapi_h264.c:196
H264PredWeightTable::luma_weight
int luma_weight[48][2][2]
Definition: h264_parse.h:77
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:186
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:103
ff_vaapi_decode_issue
int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:166
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
hwaccel_internal.h
SPS
Sequence parameter set.
Definition: h264_ps.h:44
PPS
Picture parameter set.
Definition: h264_ps.h:110
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
H264SliceContext::qscale
int qscale
Definition: h264dec.h:190
FIELD_OR_MBAFF_PICTURE
#define FIELD_OR_MBAFF_PICTURE(h)
Definition: h264dec.h:84
h264_ps.h
H264Picture::pic_id
int pic_id
pic_num (short -> no wrap version of pic_num, pic_num & max_pic_num; long -> long_pic_num)
Definition: h264dec.h:139
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
H264Picture::reference
int reference
Definition: h264dec.h:152
H264SliceContext::pwt
H264PredWeightTable pwt
Definition: h264dec.h:200
size
int size
Definition: twinvq_data.h:10344
ff_vaapi_decode_cancel
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:247
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:233
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2105
h264dec.h
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
H264Context
H264Context.
Definition: h264dec.h:340
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
vaapi_h264_end_frame
static int vaapi_h264_end_frame(AVCodecContext *avctx)
End a hardware decoding based frame.
Definition: vaapi_h264.c:318
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:271
ret
ret
Definition: filter_design.txt:187
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
H264SliceContext::slice_beta_offset
int slice_beta_offset
Definition: h264dec.h:198
AVCodecContext
main external API structure.
Definition: avcodec.h:451
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:134
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_vaapi_decode_make_slice_buffer
int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, int nb_params, size_t params_size, const void *slice_data, size_t slice_size)
Definition: vaapi_decode.c:75
H264Picture
Definition: h264dec.h:114
fill_vaapi_pic
static void fill_vaapi_pic(VAPictureH264 *va_pic, const H264Picture *pic, int pic_structure)
Translate an FFmpeg Picture into its VA API form.
Definition: vaapi_h264.c:55
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:272
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
init_vaapi_pic
static void init_vaapi_pic(VAPictureH264 *va_pic)
Initialize an empty VA API picture.
Definition: vaapi_h264.c:39
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:182
DPB::va_pics
VAPictureH264 * va_pics
Pointer to VAPictureParameterBufferH264.ReferenceFrames array.
Definition: vaapi_h264.c:85
ff_h264_get_slice_type
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2180
h
h
Definition: vp9dsp_template.c:2070
fill_vaapi_ReferenceFrames
static int fill_vaapi_ReferenceFrames(VAPictureParameterBufferH264 *pic_param, const H264Context *h)
Fill in VA API reference frames array.
Definition: vaapi_h264.c:133
H264SliceContext::cabac_init_idc
int cabac_init_idc
Definition: h264dec.h:322
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:74
dpb_add
static int dpb_add(DPB *dpb, const H264Picture *pic)
Append picture to the decoded picture buffer, in a VA API form that merges the second field picture a...
Definition: vaapi_h264.c:94
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:141