FFmpeg
vaapi_hevc.c
Go to the documentation of this file.
1 /*
2  * HEVC HW decode acceleration through VA API
3  *
4  * Copyright (C) 2015 Timo Rothenpieler <timo@rothenpieler.org>
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 <va/va.h>
24 #include <va/va_dec_hevc.h>
25 
26 #include "avcodec.h"
27 #include "hevcdec.h"
28 #include "hwconfig.h"
29 #include "vaapi_decode.h"
30 #include "vaapi_hevc.h"
31 #include "h265_profile_level.h"
32 
33 typedef struct VAAPIDecodePictureHEVC {
34 #if VA_CHECK_VERSION(1, 2, 0)
35  VAPictureParameterBufferHEVCExtension pic_param;
36  VASliceParameterBufferHEVCExtension last_slice_param;
37 #else
38  VAPictureParameterBufferHEVC pic_param;
39  VASliceParameterBufferHEVC last_slice_param;
40 #endif
41  const uint8_t *last_buffer;
42  size_t last_size;
43 
46 
47 static void init_vaapi_pic(VAPictureHEVC *va_pic)
48 {
49  va_pic->picture_id = VA_INVALID_ID;
50  va_pic->flags = VA_PICTURE_HEVC_INVALID;
51  va_pic->pic_order_cnt = 0;
52 }
53 
54 static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)
55 {
56  va_pic->picture_id = ff_vaapi_get_surface_id(pic->frame);
57  va_pic->pic_order_cnt = pic->poc;
58  va_pic->flags = rps_type;
59 
61  va_pic->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
62 
63  if (pic->frame->interlaced_frame) {
64  va_pic->flags |= VA_PICTURE_HEVC_FIELD_PIC;
65 
66  if (!pic->frame->top_field_first)
67  va_pic->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD;
68  }
69 }
70 
71 static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
72 {
73  VASurfaceID pic_surf = ff_vaapi_get_surface_id(pic->frame);
74  int i;
75 
76  for (i = 0; i < h->rps[ST_CURR_BEF].nb_refs; i++) {
77  if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_BEF].ref[i]->frame))
78  return VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
79  }
80 
81  for (i = 0; i < h->rps[ST_CURR_AFT].nb_refs; i++) {
82  if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_AFT].ref[i]->frame))
83  return VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;
84  }
85 
86  for (i = 0; i < h->rps[LT_CURR].nb_refs; i++) {
87  if (pic_surf == ff_vaapi_get_surface_id(h->rps[LT_CURR].ref[i]->frame))
88  return VA_PICTURE_HEVC_RPS_LT_CURR;
89  }
90 
91  return 0;
92 }
93 
94 static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
95 {
96  const HEVCFrame *current_picture = h->ref;
97  int i, j, rps_type;
98 
99  for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {
100  const HEVCFrame *frame = NULL;
101 
102  while (!frame && j < FF_ARRAY_ELEMS(h->DPB)) {
103  if (&h->DPB[j] != current_picture && (h->DPB[j].flags & (HEVC_FRAME_FLAG_LONG_REF | HEVC_FRAME_FLAG_SHORT_REF)))
104  frame = &h->DPB[j];
105  j++;
106  }
107 
108  init_vaapi_pic(&pp->ReferenceFrames[i]);
109 
110  if (frame) {
111  rps_type = find_frame_rps_type(h, frame);
112  fill_vaapi_pic(&pp->ReferenceFrames[i], frame, rps_type);
113  }
114  }
115 }
116 
118  av_unused const uint8_t *buffer,
119  av_unused uint32_t size)
120 {
121  const HEVCContext *h = avctx->priv_data;
122  VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
123  const HEVCSPS *sps = h->ps.sps;
124  const HEVCPPS *pps = h->ps.pps;
125 
126  const ScalingList *scaling_list = NULL;
127  int pic_param_size, err, i;
128 
129  VAPictureParameterBufferHEVC *pic_param = (VAPictureParameterBufferHEVC *)&pic->pic_param;
130 
131  pic->pic.output_surface = ff_vaapi_get_surface_id(h->ref->frame);
132 
133  *pic_param = (VAPictureParameterBufferHEVC) {
134  .pic_width_in_luma_samples = sps->width,
135  .pic_height_in_luma_samples = sps->height,
136  .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3,
137  .sps_max_dec_pic_buffering_minus1 = sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering - 1,
138  .log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,
139  .log2_min_transform_block_size_minus2 = sps->log2_min_tb_size - 2,
140  .log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size,
141  .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
142  .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
143  .num_short_term_ref_pic_sets = sps->nb_st_rps,
144  .num_long_term_ref_pic_sps = sps->num_long_term_ref_pics_sps,
145  .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1,
146  .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1,
147  .init_qp_minus26 = pps->pic_init_qp_minus26,
148  .pps_cb_qp_offset = pps->cb_qp_offset,
149  .pps_cr_qp_offset = pps->cr_qp_offset,
150  .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1,
151  .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1,
152  .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3,
153  .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
154  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
155  .pps_beta_offset_div2 = pps->beta_offset / 2,
156  .pps_tc_offset_div2 = pps->tc_offset / 2,
157  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2,
158  .bit_depth_luma_minus8 = sps->bit_depth - 8,
159  .bit_depth_chroma_minus8 = sps->bit_depth - 8,
160  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
161  .num_extra_slice_header_bits = pps->num_extra_slice_header_bits,
162  .pic_fields.bits = {
163  .chroma_format_idc = sps->chroma_format_idc,
164  .tiles_enabled_flag = pps->tiles_enabled_flag,
165  .separate_colour_plane_flag = sps->separate_colour_plane_flag,
166  .pcm_enabled_flag = sps->pcm_enabled_flag,
167  .scaling_list_enabled_flag = sps->scaling_list_enable_flag,
168  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
169  .amp_enabled_flag = sps->amp_enabled_flag,
170  .strong_intra_smoothing_enabled_flag = sps->sps_strong_intra_smoothing_enable_flag,
171  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,
172  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
173  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
174  .weighted_pred_flag = pps->weighted_pred_flag,
175  .weighted_bipred_flag = pps->weighted_bipred_flag,
176  .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag,
177  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
178  .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
179  .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
180  .pcm_loop_filter_disabled_flag = sps->pcm.loop_filter_disable_flag,
181  },
182  .slice_parsing_fields.bits = {
183  .lists_modification_present_flag = pps->lists_modification_present_flag,
184  .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present_flag,
185  .sps_temporal_mvp_enabled_flag = sps->sps_temporal_mvp_enabled_flag,
186  .cabac_init_present_flag = pps->cabac_init_present_flag,
187  .output_flag_present_flag = pps->output_flag_present_flag,
188  .dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
189  .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag,
190  .sample_adaptive_offset_enabled_flag = sps->sao_enabled,
191  .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,
192  .pps_disable_deblocking_filter_flag = pps->disable_dbf,
193  .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,
194  .RapPicFlag = IS_IRAP(h),
195  .IdrPicFlag = IS_IDR(h),
196  .IntraPicFlag = IS_IRAP(h),
197  },
198  };
199 
200  fill_vaapi_pic(&pic_param->CurrPic, h->ref, 0);
201  fill_vaapi_reference_frames(h, pic_param);
202 
203  if (pps->tiles_enabled_flag) {
204  pic_param->num_tile_columns_minus1 = pps->num_tile_columns - 1;
205  pic_param->num_tile_rows_minus1 = pps->num_tile_rows - 1;
206 
207  for (i = 0; i < pps->num_tile_columns; i++)
208  pic_param->column_width_minus1[i] = pps->column_width[i] - 1;
209 
210  for (i = 0; i < pps->num_tile_rows; i++)
211  pic_param->row_height_minus1[i] = pps->row_height[i] - 1;
212  }
213 
214  if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) {
215  pic_param->st_rps_bits = h->sh.short_term_ref_pic_set_size;
216  } else {
217  pic_param->st_rps_bits = 0;
218  }
219 
220 #if VA_CHECK_VERSION(1, 2, 0)
221  if (avctx->profile == FF_PROFILE_HEVC_REXT) {
222  pic->pic_param.rext = (VAPictureParameterBufferHEVCRext) {
223  .range_extension_pic_fields.bits = {
224  .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled_flag,
225  .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled_flag,
226  .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled_flag,
227  .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled_flag,
228  .extended_precision_processing_flag = sps->extended_precision_processing_flag,
229  .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled_flag,
230  .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled_flag,
231  .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled_flag,
232  .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled_flag,
233  .cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,
234  .chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,
235  },
236  .diff_cu_chroma_qp_offset_depth = pps->diff_cu_chroma_qp_offset_depth,
237  .chroma_qp_offset_list_len_minus1 = pps->chroma_qp_offset_list_len_minus1,
238  .log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,
239  .log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,
240  .log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,
241  };
242 
243  for (i = 0; i < 6; i++)
244  pic->pic_param.rext.cb_qp_offset_list[i] = pps->cb_qp_offset_list[i];
245  for (i = 0; i < 6; i++)
246  pic->pic_param.rext.cr_qp_offset_list[i] = pps->cr_qp_offset_list[i];
247  }
248 #endif
249  pic_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?
250  sizeof(pic->pic_param) : sizeof(VAPictureParameterBufferHEVC);
251 
252  err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
253  VAPictureParameterBufferType,
254  &pic->pic_param, pic_param_size);
255  if (err < 0)
256  goto fail;
257 
258  if (pps->scaling_list_data_present_flag)
259  scaling_list = &pps->scaling_list;
260  else if (sps->scaling_list_enable_flag)
261  scaling_list = &sps->scaling_list;
262 
263  if (scaling_list) {
264  VAIQMatrixBufferHEVC iq_matrix;
265  int j;
266 
267  for (i = 0; i < 6; i++) {
268  for (j = 0; j < 16; j++)
269  iq_matrix.ScalingList4x4[i][j] = scaling_list->sl[0][i][j];
270  for (j = 0; j < 64; j++) {
271  iq_matrix.ScalingList8x8[i][j] = scaling_list->sl[1][i][j];
272  iq_matrix.ScalingList16x16[i][j] = scaling_list->sl[2][i][j];
273  if (i < 2)
274  iq_matrix.ScalingList32x32[i][j] = scaling_list->sl[3][i * 3][j];
275  }
276  iq_matrix.ScalingListDC16x16[i] = scaling_list->sl_dc[0][i];
277  if (i < 2)
278  iq_matrix.ScalingListDC32x32[i] = scaling_list->sl_dc[1][i * 3];
279  }
280 
281  err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
282  VAIQMatrixBufferType,
283  &iq_matrix, sizeof(iq_matrix));
284  if (err < 0)
285  goto fail;
286  }
287 
288  return 0;
289 
290 fail:
291  ff_vaapi_decode_cancel(avctx, &pic->pic);
292  return err;
293 }
294 
296 {
297  const HEVCContext *h = avctx->priv_data;
298  VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
299  VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
300  int ret;
301 
302  int slice_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?
303  sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
304 
305  if (pic->last_size) {
306  last_slice_param->LongSliceFlags.fields.LastSliceOfPic = 1;
308  &pic->last_slice_param, slice_param_size,
309  pic->last_buffer, pic->last_size);
310  if (ret < 0)
311  goto fail;
312  }
313 
314 
315  ret = ff_vaapi_decode_issue(avctx, &pic->pic);
316  if (ret < 0)
317  goto fail;
318 
319  return 0;
320 fail:
321  ff_vaapi_decode_cancel(avctx, &pic->pic);
322  return ret;
323 }
324 
326  const HEVCContext *h,
327  const SliceHeader *sh,
328  VASliceParameterBufferHEVC *slice_param)
329 {
330  int i;
331 #if VA_CHECK_VERSION(1, 2, 0)
332  int is_rext = avctx->profile >= FF_PROFILE_HEVC_REXT;
333 #else
334  int is_rext = 0;
335  if (avctx->profile >= FF_PROFILE_HEVC_REXT)
336  av_log(avctx, AV_LOG_WARNING, "Please consider to update to VAAPI 1.2.0 "
337  "or above, which can support REXT related setting correctly.\n");
338 #endif
339 
340  memset(slice_param->delta_luma_weight_l0, 0, sizeof(slice_param->delta_luma_weight_l0));
341  memset(slice_param->delta_luma_weight_l1, 0, sizeof(slice_param->delta_luma_weight_l1));
342  memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
343  memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
344  memset(slice_param->delta_chroma_weight_l0, 0, sizeof(slice_param->delta_chroma_weight_l0));
345  memset(slice_param->delta_chroma_weight_l1, 0, sizeof(slice_param->delta_chroma_weight_l1));
346  memset(slice_param->ChromaOffsetL0, 0, sizeof(slice_param->ChromaOffsetL0));
347  memset(slice_param->ChromaOffsetL1, 0, sizeof(slice_param->ChromaOffsetL1));
348 
349  slice_param->delta_chroma_log2_weight_denom = 0;
350  slice_param->luma_log2_weight_denom = 0;
351 
352  if (sh->slice_type == HEVC_SLICE_I ||
353  (sh->slice_type == HEVC_SLICE_P && !h->ps.pps->weighted_pred_flag) ||
354  (sh->slice_type == HEVC_SLICE_B && !h->ps.pps->weighted_bipred_flag))
355  return;
356 
357  slice_param->luma_log2_weight_denom = sh->luma_log2_weight_denom;
358 
359  if (h->ps.sps->chroma_format_idc) {
360  slice_param->delta_chroma_log2_weight_denom = sh->chroma_log2_weight_denom - sh->luma_log2_weight_denom;
361  }
362 
363  for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
364  slice_param->delta_luma_weight_l0[i] = sh->luma_weight_l0[i] - (1 << sh->luma_log2_weight_denom);
365  slice_param->delta_chroma_weight_l0[i][0] = sh->chroma_weight_l0[i][0] - (1 << sh->chroma_log2_weight_denom);
366  slice_param->delta_chroma_weight_l0[i][1] = sh->chroma_weight_l0[i][1] - (1 << sh->chroma_log2_weight_denom);
367  if (!is_rext) {
368  slice_param->luma_offset_l0[i] = sh->luma_offset_l0[i];
369  slice_param->ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];
370  slice_param->ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
371  }
372  }
373 
374  if (sh->slice_type == HEVC_SLICE_B) {
375  for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {
376  slice_param->delta_luma_weight_l1[i] = sh->luma_weight_l1[i] - (1 << sh->luma_log2_weight_denom);
377  slice_param->delta_chroma_weight_l1[i][0] = sh->chroma_weight_l1[i][0] - (1 << sh->chroma_log2_weight_denom);
378  slice_param->delta_chroma_weight_l1[i][1] = sh->chroma_weight_l1[i][1] - (1 << sh->chroma_log2_weight_denom);
379  if (!is_rext) {
380  slice_param->luma_offset_l1[i] = sh->luma_offset_l1[i];
381  slice_param->ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];
382  slice_param->ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];
383  }
384  }
385  }
386 }
387 
388 static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)
389 {
390  VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
391  VAPictureParameterBufferHEVC *pp = (VAPictureParameterBufferHEVC *)&pic->pic_param;
392  uint8_t i;
393 
394  if (!frame)
395  return 0xff;
396 
397  for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {
398  VASurfaceID pid = pp->ReferenceFrames[i].picture_id;
399  int poc = pp->ReferenceFrames[i].pic_order_cnt;
400  if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->frame) && poc == frame->poc)
401  return i;
402  }
403 
404  return 0xff;
405 }
406 
408  const uint8_t *buffer,
409  uint32_t size)
410 {
411  const HEVCContext *h = avctx->priv_data;
412  const SliceHeader *sh = &h->sh;
413  VAAPIDecodePictureHEVC *pic = h->ref->hwaccel_picture_private;
414  VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
415 
416  int slice_param_size = avctx->profile == FF_PROFILE_HEVC_REXT ?
417  sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
418 
419  int nb_list = (sh->slice_type == HEVC_SLICE_B) ?
420  2 : (sh->slice_type == HEVC_SLICE_I ? 0 : 1);
421 
422  int err, i, list_idx;
423 
424  if (!sh->first_slice_in_pic_flag) {
425  err = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,
426  &pic->last_slice_param, slice_param_size,
427  pic->last_buffer, pic->last_size);
428  pic->last_buffer = NULL;
429  pic->last_size = 0;
430  if (err) {
431  ff_vaapi_decode_cancel(avctx, &pic->pic);
432  return err;
433  }
434  }
435 
436  *last_slice_param = (VASliceParameterBufferHEVC) {
437  .slice_data_size = size,
438  .slice_data_offset = 0,
439  .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
440  /* Add 1 to the bits count here to account for the byte_alignment bit, which
441  * always is at least one bit and not accounted for otherwise. */
442  .slice_data_byte_offset = (get_bits_count(&h->HEVClc->gb) + 1 + 7) / 8,
443  .slice_segment_address = sh->slice_segment_addr,
444  .slice_qp_delta = sh->slice_qp_delta,
445  .slice_cb_qp_offset = sh->slice_cb_qp_offset,
446  .slice_cr_qp_offset = sh->slice_cr_qp_offset,
447  .slice_beta_offset_div2 = sh->beta_offset / 2,
448  .slice_tc_offset_div2 = sh->tc_offset / 2,
449  .collocated_ref_idx = sh->slice_temporal_mvp_enabled_flag ? sh->collocated_ref_idx : 0xFF,
450  .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? 0 : 5 - sh->max_num_merge_cand,
451  .num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0,
452  .num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0,
453 
454  .LongSliceFlags.fields = {
455  .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
456  .slice_type = sh->slice_type,
457  .color_plane_id = sh->colour_plane_id,
458  .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
459  .cabac_init_flag = sh->cabac_init_flag,
460  .slice_temporal_mvp_enabled_flag = sh->slice_temporal_mvp_enabled_flag,
461  .slice_deblocking_filter_disabled_flag = sh->disable_deblocking_filter_flag,
462  .collocated_from_l0_flag = sh->collocated_list == L0 ? 1 : 0,
463  .slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag,
464  .slice_sao_luma_flag = sh->slice_sample_adaptive_offset_flag[0],
465  .slice_sao_chroma_flag = sh->slice_sample_adaptive_offset_flag[1],
466  },
467  };
468 
469  memset(last_slice_param->RefPicList, 0xFF, sizeof(last_slice_param->RefPicList));
470 
471  for (list_idx = 0; list_idx < nb_list; list_idx++) {
472  RefPicList *rpl = &h->ref->refPicList[list_idx];
473 
474  for (i = 0; i < rpl->nb_refs; i++)
475  last_slice_param->RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->ref[i]);
476  }
477 
478  fill_pred_weight_table(avctx, h, sh, last_slice_param);
479 
480 #if VA_CHECK_VERSION(1, 2, 0)
481  if (avctx->profile == FF_PROFILE_HEVC_REXT) {
482  pic->last_slice_param.rext = (VASliceParameterBufferHEVCRext) {
483  .slice_ext_flags.bits = {
484  .cu_chroma_qp_offset_enabled_flag = sh->cu_chroma_qp_offset_enabled_flag,
485  },
486  };
487  for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
488  pic->last_slice_param.rext.luma_offset_l0[i] = sh->luma_offset_l0[i];
489  pic->last_slice_param.rext.ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];
490  pic->last_slice_param.rext.ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
491  }
492 
493  for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
494  pic->last_slice_param.rext.luma_offset_l0[i] = sh->luma_offset_l0[i];
495  pic->last_slice_param.rext.ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];
496  pic->last_slice_param.rext.ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
497  }
498 
499  if (sh->slice_type == HEVC_SLICE_B) {
500  for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {
501  pic->last_slice_param.rext.luma_offset_l1[i] = sh->luma_offset_l1[i];
502  pic->last_slice_param.rext.ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];
503  pic->last_slice_param.rext.ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];
504  }
505  }
506  }
507 #endif
508 
509  pic->last_buffer = buffer;
510  pic->last_size = size;
511 
512  return 0;
513 }
514 
515 static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)
516 {
517  h265_raw_ptl->general_profile_space = general_ptl->profile_space;
518  h265_raw_ptl->general_tier_flag = general_ptl->tier_flag;
519  h265_raw_ptl->general_profile_idc = general_ptl->profile_idc;
520 
521  memcpy(h265_raw_ptl->general_profile_compatibility_flag,
522  general_ptl->profile_compatibility_flag, 32 * sizeof(uint8_t));
523 
524 #define copy_field(name) h265_raw_ptl->general_ ## name = general_ptl->name
525  copy_field(progressive_source_flag);
526  copy_field(interlaced_source_flag);
527  copy_field(non_packed_constraint_flag);
528  copy_field(frame_only_constraint_flag);
529  copy_field(max_12bit_constraint_flag);
530  copy_field(max_10bit_constraint_flag);
531  copy_field(max_8bit_constraint_flag);
532  copy_field(max_422chroma_constraint_flag);
533  copy_field(max_420chroma_constraint_flag);
534  copy_field(max_monochrome_constraint_flag);
535  copy_field(intra_constraint_flag);
536  copy_field(one_picture_only_constraint_flag);
537  copy_field(lower_bit_rate_constraint_flag);
538  copy_field(max_14bit_constraint_flag);
539  copy_field(inbld_flag);
541 #undef copy_field
542 
543  return 0;
544 }
545 
546 /*
547  * Find exact va_profile for HEVC Range Extension
548  */
550 {
551  const HEVCContext *h = avctx->priv_data;
552  const HEVCSPS *sps = h->ps.sps;
553  const PTL *ptl = &sps->ptl;
554  const PTLCommon *general_ptl = &ptl->general_ptl;
556  H265RawProfileTierLevel h265_raw_ptl = {0};
557 
558  /* convert PTLCommon to H265RawProfileTierLevel */
559  ptl_convert(general_ptl, &h265_raw_ptl);
560 
561  profile = ff_h265_get_profile(&h265_raw_ptl);
562  if (!profile) {
563  av_log(avctx, AV_LOG_WARNING, "HEVC profile is not found.\n");
564  goto end;
565  } else {
566  av_log(avctx, AV_LOG_VERBOSE, "HEVC profile %s is found.\n", profile->name);
567  }
568 
569 #if VA_CHECK_VERSION(1, 2, 0)
570  if (!strcmp(profile->name, "Main 12") ||
571  !strcmp(profile->name, "Main 12 Intra"))
572  return VAProfileHEVCMain12;
573  else if (!strcmp(profile->name, "Main 4:2:2 10") ||
574  !strcmp(profile->name, "Main 4:2:2 10 Intra"))
575  return VAProfileHEVCMain422_10;
576  else if (!strcmp(profile->name, "Main 4:2:2 12") ||
577  !strcmp(profile->name, "Main 4:2:2 12 Intra"))
578  return VAProfileHEVCMain422_12;
579  else if (!strcmp(profile->name, "Main 4:4:4") ||
580  !strcmp(profile->name, "Main 4:4:4 Intra"))
581  return VAProfileHEVCMain444;
582  else if (!strcmp(profile->name, "Main 4:4:4 10") ||
583  !strcmp(profile->name, "Main 4:4:4 10 Intra"))
584  return VAProfileHEVCMain444_10;
585  else if (!strcmp(profile->name, "Main 4:4:4 12") ||
586  !strcmp(profile->name, "Main 4:4:4 12 Intra"))
587  return VAProfileHEVCMain444_12;
588 #else
589  av_log(avctx, AV_LOG_WARNING, "HEVC profile %s is "
590  "not supported with this VA version.\n", profile->name);
591 #endif
592 
593 end:
595  // Default to selecting Main profile if profile mismatch is allowed
596  return VAProfileHEVCMain;
597  } else
598  return VAProfileNone;
599 }
600 
602  .name = "hevc_vaapi",
603  .type = AVMEDIA_TYPE_VIDEO,
604  .id = AV_CODEC_ID_HEVC,
605  .pix_fmt = AV_PIX_FMT_VAAPI,
606  .start_frame = vaapi_hevc_start_frame,
607  .end_frame = vaapi_hevc_end_frame,
608  .decode_slice = vaapi_hevc_decode_slice,
609  .frame_priv_data_size = sizeof(VAAPIDecodePictureHEVC),
612  .frame_params = ff_vaapi_common_frame_params,
613  .priv_data_size = sizeof(VAAPIDecodeContext),
614  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
615 };
hwconfig.h
FF_PROFILE_HEVC_REXT
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:1641
SliceHeader::beta_offset
int beta_offset
beta_offset_div2 * 2
Definition: hevcdec.h:300
L1
F H1 F F H1 F F F F H1<-F-------F-------F v v v H2 H3 H2 ^ ^ ^ F-------F-------F-> H1<-F-------F-------F|||||||||F H1 F|||||||||F H1 Funavailable fullpel samples(outside the picture for example) shall be equalto the closest available fullpel sampleSmaller pel interpolation:--------------------------if diag_mc is set then points which lie on a line between 2 vertically, horizontally or diagonally adjacent halfpel points shall be interpolatedlinearly with rounding to nearest and halfway values rounded up.points which lie on 2 diagonals at the same time should only use the onediagonal not containing the fullpel point F--> O q O<--h1-> O q O<--F v \/v \/v O O O O O O O|/|\|q q q q q|/|\|O O O O O O O ^/\ ^/\ ^ h2--> O q O<--h3-> O q O<--h2 v \/v \/v O O O O O O O|\|/|q q q q q|\|/|O O O O O O O ^/\ ^/\ ^ F--> O q O<--h1-> O q O<--Fthe remaining points shall be bilinearly interpolated from theup to 4 surrounding halfpel and fullpel points, again rounding should be tonearest and halfway values rounded upcompliant Snow decoders MUST support 1-1/8 pel luma and 1/2-1/16 pel chromainterpolation at leastOverlapped block motion compensation:-------------------------------------FIXMELL band prediction:===================Each sample in the LL0 subband is predicted by the median of the left, top andleft+top-topleft samples, samples outside the subband shall be considered tobe 0. To reverse this prediction in the decoder apply the following.for(y=0;y< height;y++){ for(x=0;x< width;x++){ sample[y][x]+=median(sample[y-1][x], sample[y][x-1], sample[y-1][x]+sample[y][x-1]-sample[y-1][x-1]);}}sample[-1][ *]=sample[ *][-1]=0;width, height here are the width and height of the LL0 subband not of the finalvideoDequantization:===============FIXMEWavelet Transform:==================Snow supports 2 wavelet transforms, the symmetric biorthogonal 5/3 integertransform and an integer approximation of the symmetric biorthogonal 9/7daubechies wavelet.2D IDWT(inverse discrete wavelet transform) --------------------------------------------The 2D IDWT applies a 2D filter recursively, each time combining the4 lowest frequency subbands into a single subband until only 1 subbandremains.The 2D filter is done by first applying a 1D filter in the vertical directionand then applying it in the horizontal one. --------------- --------------- --------------- ---------------|LL0|HL0|||||||||||||---+---|HL1||L0|H0|HL1||LL1|HL1|||||LH0|HH0|||||||||||||-------+-------|-> L1 H1 LH1 HH1 LH1 HH1 LH1 HH1 L1
Definition: snow.txt:554
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
HEVCFrame::flags
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:429
SliceHeader::chroma_offset_l1
int16_t chroma_offset_l1[16][2]
Definition: hevcdec.h:324
ff_vaapi_get_surface_id
static VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
Definition: vaapi_decode.h:30
vaapi_hevc_end_frame
static int vaapi_hevc_end_frame(AVCodecContext *avctx)
Definition: vaapi_hevc.c:295
VAAPIDecodeContext
Definition: vaapi_decode.h:50
vaapi_decode.h
ff_h265_get_profile
const H265ProfileDescriptor * ff_h265_get_profile(const H265RawProfileTierLevel *ptl)
Definition: h265_profile_level.c:123
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
ff_hevc_vaapi_hwaccel
const AVHWAccel ff_hevc_vaapi_hwaccel
Definition: vaapi_hevc.c:601
av_unused
#define av_unused
Definition: attributes.h:131
VAAPIDecodePicture
Definition: vaapi_decode.h:39
ff_vaapi_decode_make_slice_buffer
int ff_vaapi_decode_make_slice_buffer(AVCodecContext *avctx, VAAPIDecodePicture *pic, const void *params_data, size_t params_size, const void *slice_data, size_t slice_size)
Definition: vaapi_decode.c:61
level_idc
int level_idc
Definition: h264_levels.c:25
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:482
SliceHeader::slice_temporal_mvp_enabled_flag
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevcdec.h:280
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
PTLCommon::profile_space
uint8_t profile_space
Definition: hevc_ps.h:93
SliceHeader::slice_loop_filter_across_slices_enabled_flag
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: hevcdec.h:289
RefPicList
Definition: hevcdec.h:241
H265ProfileDescriptor
Definition: h265_profile_level.h:47
PTLCommon::profile_compatibility_flag
uint8_t profile_compatibility_flag[32]
Definition: hevc_ps.h:96
ptl_convert
static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)
Definition: vaapi_hevc.c:515
AVHWAccel
Definition: avcodec.h:2070
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:32
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:395
fail
#define fail()
Definition: checkasm.h:134
SliceHeader::luma_log2_weight_denom
uint8_t luma_log2_weight_denom
Definition: hevcdec.h:312
fill_vaapi_pic
static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)
Definition: vaapi_hevc.c:54
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:245
SliceHeader::slice_segment_addr
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevcdec.h:256
VAAPIDecodePicture::output_surface
VASurfaceID output_surface
Definition: vaapi_decode.h:40
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
SliceHeader::cabac_init_flag
uint8_t cabac_init_flag
Definition: hevcdec.h:287
PTLCommon
Definition: hevc_ps.h:92
ff_vaapi_decode_init
int ff_vaapi_decode_init(AVCodecContext *avctx)
Definition: vaapi_decode.c:655
SliceHeader::luma_offset_l1
int16_t luma_offset_l1[16]
Definition: hevcdec.h:323
H265RawProfileTierLevel::general_profile_idc
uint8_t general_profile_idc
Definition: cbs_h265.h:38
ff_vaapi_common_frame_params
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: vaapi_decode.c:631
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
vaapi_hevc_decode_slice
static int vaapi_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: vaapi_hevc.c:407
fill_vaapi_reference_frames
static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
Definition: vaapi_hevc.c:94
find_frame_rps_type
static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
Definition: vaapi_hevc.c:71
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:75
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:394
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:242
vaapi_hevc_start_frame
static int vaapi_hevc_start_frame(AVCodecContext *avctx, av_unused const uint8_t *buffer, av_unused uint32_t size)
Definition: vaapi_hevc.c:117
ff_vaapi_decode_uninit
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
Definition: vaapi_decode.c:701
HEVC_SLICE_I
@ HEVC_SLICE_I
Definition: hevc.h:98
PTLCommon::profile_idc
uint8_t profile_idc
Definition: hevc_ps.h:95
ScalingList
Definition: hevc_ps.h:146
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:290
SliceHeader::luma_offset_l0
int16_t luma_offset_l0[16]
Definition: hevcdec.h:320
SliceHeader::chroma_weight_l1
int16_t chroma_weight_l1[16][2]
Definition: hevcdec.h:317
PTLCommon::tier_flag
uint8_t tier_flag
Definition: hevc_ps.h:94
ff_vaapi_decode_issue
int ff_vaapi_decode_issue(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:153
if
if(ret)
Definition: filter_design.txt:179
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
NULL
#define NULL
Definition: coverity.c:32
get_ref_pic_index
static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)
Definition: vaapi_hevc.c:388
AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH
#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH
Hardware acceleration should still be attempted for decoding when the codec profile does not match th...
Definition: avcodec.h:2254
L0
#define L0
Definition: hevcdec.h:57
VAAPIDecodePictureHEVC
Definition: vaapi_hevc.c:33
PTL
Definition: hevc_ps.h:115
init_vaapi_pic
static void init_vaapi_pic(VAPictureHEVC *va_pic)
Definition: vaapi_hevc.c:47
VAAPIDecodePictureHEVC::last_size
size_t last_size
Definition: vaapi_hevc.c:42
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:282
H265RawProfileTierLevel::general_tier_flag
uint8_t general_tier_flag
Definition: cbs_h265.h:37
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:78
SliceHeader::colour_plane_id
uint8_t colour_plane_id
RPS coded in the slice header itself is stored here.
Definition: hevcdec.h:267
SliceHeader::dependent_slice_segment_flag
uint8_t dependent_slice_segment_flag
Definition: hevcdec.h:265
SliceHeader::first_slice_in_pic_flag
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:264
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
hevcdec.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
size
int size
Definition: twinvq_data.h:10344
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:292
h265_profile_level.h
vaapi_hevc.h
SliceHeader::max_num_merge_cand
unsigned int max_num_merge_cand
5 - 5_minus_max_num_merge_cand
Definition: hevcdec.h:303
ff_vaapi_decode_cancel
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:227
SliceHeader::chroma_weight_l0
int16_t chroma_weight_l0[16][2]
Definition: hevcdec.h:316
VAAPIDecodePictureHEVC::last_slice_param
VASliceParameterBufferHEVC last_slice_param
Definition: vaapi_hevc.c:39
SliceHeader::chroma_log2_weight_denom
int16_t chroma_log2_weight_denom
Definition: hevcdec.h:313
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:119
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2076
SliceHeader::slice_cb_qp_offset
int slice_cb_qp_offset
Definition: hevcdec.h:295
SliceHeader
Definition: hevcdec.h:252
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:477
HEVCFrame::frame
AVFrame * frame
Definition: hevcdec.h:402
SliceHeader::slice_sample_adaptive_offset_flag
uint8_t slice_sample_adaptive_offset_flag[3]
Definition: hevcdec.h:284
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
HEVCFrame
Definition: hevcdec.h:401
VAAPIDecodePictureHEVC::last_buffer
const uint8_t * last_buffer
Definition: vaapi_hevc.c:41
AVCodecContext::hwaccel_flags
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition: avcodec.h:1942
SliceHeader::mvd_l1_zero_flag
uint8_t mvd_l1_zero_flag
Definition: hevcdec.h:285
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
VAAPIDecodePictureHEVC::pic_param
VAPictureParameterBufferHEVC pic_param
Definition: vaapi_hevc.c:38
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Definition: hwconfig.h:26
copy_field
#define copy_field(name)
SliceHeader::chroma_offset_l0
int16_t chroma_offset_l0[16][2]
Definition: hevcdec.h:321
profile
int profile
Definition: mxfenc.c:2006
H265RawProfileTierLevel
Definition: cbs_h265.h:35
HEVCFrame::poc
int poc
Definition: hevcdec.h:410
H265RawProfileTierLevel::general_profile_space
uint8_t general_profile_space
Definition: cbs_h265.h:36
avcodec.h
H265RawProfileTierLevel::general_profile_compatibility_flag
uint8_t general_profile_compatibility_flag[32]
Definition: cbs_h265.h:40
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ST_CURR_BEF
@ ST_CURR_BEF
Definition: hevcdec.h:81
SliceHeader::disable_deblocking_filter_flag
uint8_t disable_deblocking_filter_flag
slice_header_disable_deblocking_filter_flag
Definition: hevcdec.h:288
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
SliceHeader::luma_weight_l0
int16_t luma_weight_l0[16]
Definition: hevcdec.h:315
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:260
LT_CURR
@ LT_CURR
Definition: hevcdec.h:84
AVCodecContext
main external API structure.
Definition: avcodec.h:398
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
fill_pred_weight_table
static void fill_pred_weight_table(AVCodecContext *avctx, const HEVCContext *h, const SliceHeader *sh, VASliceParameterBufferHEVC *slice_param)
Definition: vaapi_hevc.c:325
SliceHeader::slice_cr_qp_offset
int slice_cr_qp_offset
Definition: hevcdec.h:296
HEVCContext
Definition: hevcdec.h:490
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1550
ff_vaapi_parse_hevc_rext_profile
VAProfile ff_vaapi_parse_hevc_rext_profile(AVCodecContext *avctx)
Definition: vaapi_hevc.c:549
scaling_list
static int FUNC() scaling_list(CodedBitstreamContext *ctx, RWContext *rw, H264RawScalingList *current, int size_of_scaling_list)
Definition: cbs_h264_syntax_template.c:71
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
HEVCSPS
Definition: hevc_ps.h:153
HEVCPPS
Definition: hevc_ps.h:249
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:82
SliceHeader::tc_offset
int tc_offset
tc_offset_div2 * 2
Definition: hevcdec.h:301
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
VAAPIDecodePictureHEVC::pic
VAAPIDecodePicture pic
Definition: vaapi_hevc.c:44
SliceHeader::luma_weight_l1
int16_t luma_weight_l1[16]
Definition: hevcdec.h:318
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
uninit
static av_cold int uninit(AVCodecContext *avctx)
Definition: crystalhd.c:285
h
h
Definition: vp9dsp_template.c:2038
SliceHeader::slice_qp_delta
int slice_qp_delta
Definition: hevcdec.h:294