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 "hwaccel_internal.h"
28 #include "vaapi_decode.h"
29 #include "vaapi_hevc.h"
30 #include "h265_profile_level.h"
31 
32 #include "hevc/hevcdec.h"
33 
34 typedef struct VAAPIDecodePictureHEVC {
35 #if VA_CHECK_VERSION(1, 2, 0)
36  VAPictureParameterBufferHEVCExtension pic_param;
37  VASliceParameterBufferHEVCExtension last_slice_param;
38 #else
39  VAPictureParameterBufferHEVC pic_param;
40  VASliceParameterBufferHEVC last_slice_param;
41 #endif
42  const uint8_t *last_buffer;
43  size_t last_size;
44 
47 
48 static void init_vaapi_pic(VAPictureHEVC *va_pic)
49 {
50  va_pic->picture_id = VA_INVALID_ID;
51  va_pic->flags = VA_PICTURE_HEVC_INVALID;
52  va_pic->pic_order_cnt = 0;
53 }
54 
55 static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)
56 {
57  va_pic->picture_id = ff_vaapi_get_surface_id(pic->f);
58  va_pic->pic_order_cnt = pic->poc;
59  va_pic->flags = rps_type;
60 
62  va_pic->flags |= VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
63 
64  if (pic->f->flags & AV_FRAME_FLAG_INTERLACED) {
65  va_pic->flags |= VA_PICTURE_HEVC_FIELD_PIC;
66 
67  if (!(pic->f->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST))
68  va_pic->flags |= VA_PICTURE_HEVC_BOTTOM_FIELD;
69  }
70 }
71 
72 static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
73 {
74  VASurfaceID pic_surf = ff_vaapi_get_surface_id(pic->f);
75  const HEVCFrame *current_picture = h->cur_frame;
76  int i;
77 
78  for (i = 0; i < h->rps[ST_CURR_BEF].nb_refs; i++) {
79  if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_BEF].ref[i]->f))
80  return VA_PICTURE_HEVC_RPS_ST_CURR_BEFORE;
81  }
82 
83  for (i = 0; i < h->rps[ST_CURR_AFT].nb_refs; i++) {
84  if (pic_surf == ff_vaapi_get_surface_id(h->rps[ST_CURR_AFT].ref[i]->f))
85  return VA_PICTURE_HEVC_RPS_ST_CURR_AFTER;
86  }
87 
88  for (i = 0; i < h->rps[LT_CURR].nb_refs; i++) {
89  if (pic_surf == ff_vaapi_get_surface_id(h->rps[LT_CURR].ref[i]->f))
90  return VA_PICTURE_HEVC_RPS_LT_CURR;
91  }
92 
93  if (h->pps->pps_curr_pic_ref_enabled_flag && current_picture->poc == pic->poc)
94  return VA_PICTURE_HEVC_LONG_TERM_REFERENCE;
95 
96  return 0;
97 }
98 
99 static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
100 {
101  const HEVCFrame *current_picture = h->cur_frame;
102  int i, j, rps_type;
103 
104  for (i = 0, j = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {
105  const HEVCFrame *frame = NULL;
106 
107  while (!frame && j < FF_ARRAY_ELEMS(h->DPB)) {
108  if ((&h->DPB[j] != current_picture || h->pps->pps_curr_pic_ref_enabled_flag) &&
110  frame = &h->DPB[j];
111  j++;
112  }
113 
114  init_vaapi_pic(&pp->ReferenceFrames[i]);
115 
116  if (frame) {
117  rps_type = find_frame_rps_type(h, frame);
118  fill_vaapi_pic(&pp->ReferenceFrames[i], frame, rps_type);
119  }
120  }
121 }
122 
124  av_unused const uint8_t *buffer,
125  av_unused uint32_t size)
126 {
127  const HEVCContext *h = avctx->priv_data;
128  VAAPIDecodePictureHEVC *pic = h->cur_frame->hwaccel_picture_private;
129  const HEVCPPS *pps = h->pps;
130  const HEVCSPS *sps = pps->sps;
131 
132  const ScalingList *scaling_list = NULL;
133  int pic_param_size, err, i;
134 
135 #if VA_CHECK_VERSION(1, 2, 0)
136  int num_comps, pre_palette_size;
137 #endif
138 
139  VAPictureParameterBufferHEVC *pic_param = (VAPictureParameterBufferHEVC *)&pic->pic_param;
140 
141  pic->pic.output_surface = ff_vaapi_get_surface_id(h->cur_frame->f);
142 
143  *pic_param = (VAPictureParameterBufferHEVC) {
144  .pic_width_in_luma_samples = sps->width,
145  .pic_height_in_luma_samples = sps->height,
146  .log2_min_luma_coding_block_size_minus3 = sps->log2_min_cb_size - 3,
147  .sps_max_dec_pic_buffering_minus1 = sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering - 1,
148  .log2_diff_max_min_luma_coding_block_size = sps->log2_diff_max_min_coding_block_size,
149  .log2_min_transform_block_size_minus2 = sps->log2_min_tb_size - 2,
150  .log2_diff_max_min_transform_block_size = sps->log2_max_trafo_size - sps->log2_min_tb_size,
151  .max_transform_hierarchy_depth_inter = sps->max_transform_hierarchy_depth_inter,
152  .max_transform_hierarchy_depth_intra = sps->max_transform_hierarchy_depth_intra,
153  .num_short_term_ref_pic_sets = sps->nb_st_rps,
154  .num_long_term_ref_pic_sps = sps->num_long_term_ref_pics_sps,
155  .num_ref_idx_l0_default_active_minus1 = pps->num_ref_idx_l0_default_active - 1,
156  .num_ref_idx_l1_default_active_minus1 = pps->num_ref_idx_l1_default_active - 1,
157  .init_qp_minus26 = pps->pic_init_qp_minus26,
158  .pps_cb_qp_offset = pps->cb_qp_offset,
159  .pps_cr_qp_offset = pps->cr_qp_offset,
160  .pcm_sample_bit_depth_luma_minus1 = sps->pcm.bit_depth - 1,
161  .pcm_sample_bit_depth_chroma_minus1 = sps->pcm.bit_depth_chroma - 1,
162  .log2_min_pcm_luma_coding_block_size_minus3 = sps->pcm.log2_min_pcm_cb_size - 3,
163  .log2_diff_max_min_pcm_luma_coding_block_size = sps->pcm.log2_max_pcm_cb_size - sps->pcm.log2_min_pcm_cb_size,
164  .diff_cu_qp_delta_depth = pps->diff_cu_qp_delta_depth,
165  .pps_beta_offset_div2 = pps->beta_offset / 2,
166  .pps_tc_offset_div2 = pps->tc_offset / 2,
167  .log2_parallel_merge_level_minus2 = pps->log2_parallel_merge_level - 2,
168  .bit_depth_luma_minus8 = sps->bit_depth - 8,
169  .bit_depth_chroma_minus8 = sps->bit_depth - 8,
170  .log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4,
171  .num_extra_slice_header_bits = pps->num_extra_slice_header_bits,
172  .pic_fields.bits = {
173  .chroma_format_idc = sps->chroma_format_idc,
174  .tiles_enabled_flag = pps->tiles_enabled_flag,
175  .separate_colour_plane_flag = sps->separate_colour_plane,
176  .pcm_enabled_flag = sps->pcm_enabled,
177  .scaling_list_enabled_flag = sps->scaling_list_enabled,
178  .transform_skip_enabled_flag = pps->transform_skip_enabled_flag,
179  .amp_enabled_flag = sps->amp_enabled,
180  .strong_intra_smoothing_enabled_flag = sps->strong_intra_smoothing_enabled,
181  .sign_data_hiding_enabled_flag = pps->sign_data_hiding_flag,
182  .constrained_intra_pred_flag = pps->constrained_intra_pred_flag,
183  .cu_qp_delta_enabled_flag = pps->cu_qp_delta_enabled_flag,
184  .weighted_pred_flag = pps->weighted_pred_flag,
185  .weighted_bipred_flag = pps->weighted_bipred_flag,
186  .transquant_bypass_enabled_flag = pps->transquant_bypass_enable_flag,
187  .entropy_coding_sync_enabled_flag = pps->entropy_coding_sync_enabled_flag,
188  .pps_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag,
189  .loop_filter_across_tiles_enabled_flag = pps->loop_filter_across_tiles_enabled_flag,
190  .pcm_loop_filter_disabled_flag = sps->pcm_loop_filter_disabled,
191  },
192  .slice_parsing_fields.bits = {
193  .lists_modification_present_flag = pps->lists_modification_present_flag,
194  .long_term_ref_pics_present_flag = sps->long_term_ref_pics_present,
195  .sps_temporal_mvp_enabled_flag = sps->temporal_mvp_enabled,
196  .cabac_init_present_flag = pps->cabac_init_present_flag,
197  .output_flag_present_flag = pps->output_flag_present_flag,
198  .dependent_slice_segments_enabled_flag = pps->dependent_slice_segments_enabled_flag,
199  .pps_slice_chroma_qp_offsets_present_flag = pps->pic_slice_level_chroma_qp_offsets_present_flag,
200  .sample_adaptive_offset_enabled_flag = sps->sao_enabled,
201  .deblocking_filter_override_enabled_flag = pps->deblocking_filter_override_enabled_flag,
202  .pps_disable_deblocking_filter_flag = pps->disable_dbf,
203  .slice_segment_header_extension_present_flag = pps->slice_header_extension_present_flag,
204  .RapPicFlag = IS_IRAP(h),
205  .IdrPicFlag = IS_IDR(h),
206  .IntraPicFlag = IS_IRAP(h),
207  },
208  };
209 
210  fill_vaapi_pic(&pic_param->CurrPic, h->cur_frame, 0);
211  fill_vaapi_reference_frames(h, pic_param);
212 
213  if (pps->tiles_enabled_flag) {
214  pic_param->num_tile_columns_minus1 = pps->num_tile_columns - 1;
215  pic_param->num_tile_rows_minus1 = pps->num_tile_rows - 1;
216 
217  for (i = 0; i < pps->num_tile_columns; i++)
218  pic_param->column_width_minus1[i] = pps->column_width[i] - 1;
219 
220  for (i = 0; i < pps->num_tile_rows; i++)
221  pic_param->row_height_minus1[i] = pps->row_height[i] - 1;
222  }
223 
224  if (h->sh.short_term_ref_pic_set_sps_flag == 0 && h->sh.short_term_rps) {
225  pic_param->st_rps_bits = h->sh.short_term_ref_pic_set_size;
226  } else {
227  pic_param->st_rps_bits = 0;
228  }
229 
230 #if VA_CHECK_VERSION(1, 2, 0)
231  if (avctx->profile == AV_PROFILE_HEVC_REXT ||
232  avctx->profile == AV_PROFILE_HEVC_SCC) {
233  pic->pic_param.rext = (VAPictureParameterBufferHEVCRext) {
234  .range_extension_pic_fields.bits = {
235  .transform_skip_rotation_enabled_flag = sps->transform_skip_rotation_enabled,
236  .transform_skip_context_enabled_flag = sps->transform_skip_context_enabled,
237  .implicit_rdpcm_enabled_flag = sps->implicit_rdpcm_enabled,
238  .explicit_rdpcm_enabled_flag = sps->explicit_rdpcm_enabled,
239  .extended_precision_processing_flag = sps->extended_precision_processing,
240  .intra_smoothing_disabled_flag = sps->intra_smoothing_disabled,
241  .high_precision_offsets_enabled_flag = sps->high_precision_offsets_enabled,
242  .persistent_rice_adaptation_enabled_flag = sps->persistent_rice_adaptation_enabled,
243  .cabac_bypass_alignment_enabled_flag = sps->cabac_bypass_alignment_enabled,
244  .cross_component_prediction_enabled_flag = pps->cross_component_prediction_enabled_flag,
245  .chroma_qp_offset_list_enabled_flag = pps->chroma_qp_offset_list_enabled_flag,
246  },
247  .diff_cu_chroma_qp_offset_depth = pps->diff_cu_chroma_qp_offset_depth,
248  .chroma_qp_offset_list_len_minus1 = pps->chroma_qp_offset_list_len_minus1,
249  .log2_sao_offset_scale_luma = pps->log2_sao_offset_scale_luma,
250  .log2_sao_offset_scale_chroma = pps->log2_sao_offset_scale_chroma,
251  .log2_max_transform_skip_block_size_minus2 = pps->log2_max_transform_skip_block_size - 2,
252  };
253 
254  for (i = 0; i < 6; i++)
255  pic->pic_param.rext.cb_qp_offset_list[i] = pps->cb_qp_offset_list[i];
256  for (i = 0; i < 6; i++)
257  pic->pic_param.rext.cr_qp_offset_list[i] = pps->cr_qp_offset_list[i];
258  }
259 
260  pre_palette_size = pps->pps_palette_predictor_initializers_present_flag ?
261  pps->pps_num_palette_predictor_initializers :
262  (sps->palette_predictor_initializers_present ?
263  sps->sps_num_palette_predictor_initializers :
264  0);
265 
266  if (avctx->profile == AV_PROFILE_HEVC_SCC) {
267  pic->pic_param.scc = (VAPictureParameterBufferHEVCScc) {
268  .screen_content_pic_fields.bits = {
269  .pps_curr_pic_ref_enabled_flag = pps->pps_curr_pic_ref_enabled_flag,
270  .palette_mode_enabled_flag = sps->palette_mode_enabled,
271  .motion_vector_resolution_control_idc = sps->motion_vector_resolution_control_idc,
272  .intra_boundary_filtering_disabled_flag = sps->intra_boundary_filtering_disabled,
273  .residual_adaptive_colour_transform_enabled_flag
274  = pps->residual_adaptive_colour_transform_enabled_flag,
275  .pps_slice_act_qp_offsets_present_flag = pps->pps_slice_act_qp_offsets_present_flag,
276  },
277  .palette_max_size = sps->palette_max_size,
278  .delta_palette_max_predictor_size = sps->delta_palette_max_predictor_size,
279  .predictor_palette_size = pre_palette_size,
280  .pps_act_y_qp_offset_plus5 = pps->residual_adaptive_colour_transform_enabled_flag ?
281  pps->pps_act_y_qp_offset + 5 : 0,
282  .pps_act_cb_qp_offset_plus5 = pps->residual_adaptive_colour_transform_enabled_flag ?
283  pps->pps_act_cb_qp_offset + 5 : 0,
284  .pps_act_cr_qp_offset_plus3 = pps->residual_adaptive_colour_transform_enabled_flag ?
285  pps->pps_act_cr_qp_offset + 3 : 0,
286  };
287 
288  num_comps = pps->monochrome_palette_flag ? 1 : 3;
289  for (int comp = 0; comp < num_comps; comp++)
290  for (int j = 0; j < pre_palette_size; j++)
291  pic->pic_param.scc.predictor_palette_entries[comp][j] =
292  pps->pps_palette_predictor_initializers_present_flag ?
293  pps->pps_palette_predictor_initializer[comp][j]:
294  sps->sps_palette_predictor_initializer[comp][j];
295  }
296 
297 #endif
298  pic_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
299  sizeof(pic->pic_param) : sizeof(VAPictureParameterBufferHEVC);
300 
301  err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
302  VAPictureParameterBufferType,
303  &pic->pic_param, pic_param_size);
304  if (err < 0)
305  goto fail;
306 
307  if (pps->scaling_list_data_present_flag)
308  scaling_list = &pps->scaling_list;
309  else if (sps->scaling_list_enabled)
310  scaling_list = &sps->scaling_list;
311 
312  if (scaling_list) {
313  VAIQMatrixBufferHEVC iq_matrix;
314  int j;
315 
316  for (i = 0; i < 6; i++) {
317  for (j = 0; j < 16; j++)
318  iq_matrix.ScalingList4x4[i][j] = scaling_list->sl[0][i][j];
319  for (j = 0; j < 64; j++) {
320  iq_matrix.ScalingList8x8[i][j] = scaling_list->sl[1][i][j];
321  iq_matrix.ScalingList16x16[i][j] = scaling_list->sl[2][i][j];
322  if (i < 2)
323  iq_matrix.ScalingList32x32[i][j] = scaling_list->sl[3][i * 3][j];
324  }
325  iq_matrix.ScalingListDC16x16[i] = scaling_list->sl_dc[0][i];
326  if (i < 2)
327  iq_matrix.ScalingListDC32x32[i] = scaling_list->sl_dc[1][i * 3];
328  }
329 
330  err = ff_vaapi_decode_make_param_buffer(avctx, &pic->pic,
331  VAIQMatrixBufferType,
332  &iq_matrix, sizeof(iq_matrix));
333  if (err < 0)
334  goto fail;
335  }
336 
337  return 0;
338 
339 fail:
340  ff_vaapi_decode_cancel(avctx, &pic->pic);
341  return err;
342 }
343 
345 {
346  const HEVCContext *h = avctx->priv_data;
347  VAAPIDecodePictureHEVC *pic = h->cur_frame->hwaccel_picture_private;
348  VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
349  int ret;
350 
351  int slice_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
352  sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
353 
354  if (pic->last_size) {
355  last_slice_param->LongSliceFlags.fields.LastSliceOfPic = 1;
357  &pic->last_slice_param, 1, slice_param_size,
358  pic->last_buffer, pic->last_size);
359  if (ret < 0)
360  goto fail;
361  }
362 
363 
364  ret = ff_vaapi_decode_issue(avctx, &pic->pic);
365  if (ret < 0)
366  goto fail;
367 
368  return 0;
369 fail:
370  ff_vaapi_decode_cancel(avctx, &pic->pic);
371  return ret;
372 }
373 
375  const HEVCContext *h,
376  const SliceHeader *sh,
377  VASliceParameterBufferHEVC *slice_param)
378 {
379  int i;
380 #if VA_CHECK_VERSION(1, 2, 0)
381  int is_rext = avctx->profile >= AV_PROFILE_HEVC_REXT;
382 #else
383  int is_rext = 0;
384  if (avctx->profile >= AV_PROFILE_HEVC_REXT)
385  av_log(avctx, AV_LOG_WARNING, "Please consider to update to VAAPI 1.2.0 "
386  "or above, which can support REXT related setting correctly.\n");
387 #endif
388 
389  memset(slice_param->delta_luma_weight_l0, 0, sizeof(slice_param->delta_luma_weight_l0));
390  memset(slice_param->delta_luma_weight_l1, 0, sizeof(slice_param->delta_luma_weight_l1));
391  memset(slice_param->luma_offset_l0, 0, sizeof(slice_param->luma_offset_l0));
392  memset(slice_param->luma_offset_l1, 0, sizeof(slice_param->luma_offset_l1));
393  memset(slice_param->delta_chroma_weight_l0, 0, sizeof(slice_param->delta_chroma_weight_l0));
394  memset(slice_param->delta_chroma_weight_l1, 0, sizeof(slice_param->delta_chroma_weight_l1));
395  memset(slice_param->ChromaOffsetL0, 0, sizeof(slice_param->ChromaOffsetL0));
396  memset(slice_param->ChromaOffsetL1, 0, sizeof(slice_param->ChromaOffsetL1));
397 
398  slice_param->delta_chroma_log2_weight_denom = 0;
399  slice_param->luma_log2_weight_denom = 0;
400 
401  if (sh->slice_type == HEVC_SLICE_I ||
402  (sh->slice_type == HEVC_SLICE_P && !h->pps->weighted_pred_flag) ||
403  (sh->slice_type == HEVC_SLICE_B && !h->pps->weighted_bipred_flag))
404  return;
405 
406  slice_param->luma_log2_weight_denom = sh->luma_log2_weight_denom;
407 
408  if (h->ps.sps->chroma_format_idc) {
409  slice_param->delta_chroma_log2_weight_denom = sh->chroma_log2_weight_denom - sh->luma_log2_weight_denom;
410  }
411 
412  for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
413  slice_param->delta_luma_weight_l0[i] = sh->luma_weight_l0[i] - (1 << sh->luma_log2_weight_denom);
414  slice_param->delta_chroma_weight_l0[i][0] = sh->chroma_weight_l0[i][0] - (1 << sh->chroma_log2_weight_denom);
415  slice_param->delta_chroma_weight_l0[i][1] = sh->chroma_weight_l0[i][1] - (1 << sh->chroma_log2_weight_denom);
416  if (!is_rext) {
417  slice_param->luma_offset_l0[i] = sh->luma_offset_l0[i];
418  slice_param->ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];
419  slice_param->ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
420  }
421  }
422 
423  if (sh->slice_type == HEVC_SLICE_B) {
424  for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {
425  slice_param->delta_luma_weight_l1[i] = sh->luma_weight_l1[i] - (1 << sh->luma_log2_weight_denom);
426  slice_param->delta_chroma_weight_l1[i][0] = sh->chroma_weight_l1[i][0] - (1 << sh->chroma_log2_weight_denom);
427  slice_param->delta_chroma_weight_l1[i][1] = sh->chroma_weight_l1[i][1] - (1 << sh->chroma_log2_weight_denom);
428  if (!is_rext) {
429  slice_param->luma_offset_l1[i] = sh->luma_offset_l1[i];
430  slice_param->ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];
431  slice_param->ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];
432  }
433  }
434  }
435 }
436 
437 static uint8_t get_ref_pic_index(const HEVCContext *h, const HEVCFrame *frame)
438 {
439  VAAPIDecodePictureHEVC *pic = h->cur_frame->hwaccel_picture_private;
440  VAPictureParameterBufferHEVC *pp = (VAPictureParameterBufferHEVC *)&pic->pic_param;
441  uint8_t i;
442 
443  if (!frame)
444  return 0xff;
445 
446  for (i = 0; i < FF_ARRAY_ELEMS(pp->ReferenceFrames); i++) {
447  VASurfaceID pid = pp->ReferenceFrames[i].picture_id;
448  int poc = pp->ReferenceFrames[i].pic_order_cnt;
449  if (pid != VA_INVALID_ID && pid == ff_vaapi_get_surface_id(frame->f) && poc == frame->poc)
450  return i;
451  }
452 
453  return 0xff;
454 }
455 
457  const uint8_t *buffer,
458  uint32_t size)
459 {
460  const HEVCContext *h = avctx->priv_data;
461  const SliceHeader *sh = &h->sh;
462  VAAPIDecodePictureHEVC *pic = h->cur_frame->hwaccel_picture_private;
463  VASliceParameterBufferHEVC *last_slice_param = (VASliceParameterBufferHEVC *)&pic->last_slice_param;
464 
465  int slice_param_size = avctx->profile >= AV_PROFILE_HEVC_REXT ?
466  sizeof(pic->last_slice_param) : sizeof(VASliceParameterBufferHEVC);
467 
468  int nb_list = (sh->slice_type == HEVC_SLICE_B) ?
469  2 : (sh->slice_type == HEVC_SLICE_I ? 0 : 1);
470 
471  int err, i, list_idx;
472 
473  if (!sh->first_slice_in_pic_flag) {
474  err = ff_vaapi_decode_make_slice_buffer(avctx, &pic->pic,
475  &pic->last_slice_param, 1, slice_param_size,
476  pic->last_buffer, pic->last_size);
477  pic->last_buffer = NULL;
478  pic->last_size = 0;
479  if (err) {
480  ff_vaapi_decode_cancel(avctx, &pic->pic);
481  return err;
482  }
483  }
484 
485  *last_slice_param = (VASliceParameterBufferHEVC) {
486  .slice_data_size = size,
487  .slice_data_offset = 0,
488  .slice_data_flag = VA_SLICE_DATA_FLAG_ALL,
489  .slice_data_byte_offset = sh->data_offset,
490  .slice_segment_address = sh->slice_segment_addr,
491  .slice_qp_delta = sh->slice_qp_delta,
492  .slice_cb_qp_offset = sh->slice_cb_qp_offset,
493  .slice_cr_qp_offset = sh->slice_cr_qp_offset,
494  .slice_beta_offset_div2 = sh->beta_offset / 2,
495  .slice_tc_offset_div2 = sh->tc_offset / 2,
496  .collocated_ref_idx = sh->slice_temporal_mvp_enabled_flag ? sh->collocated_ref_idx : 0xFF,
497  .five_minus_max_num_merge_cand = sh->slice_type == HEVC_SLICE_I ? 0 : 5 - sh->max_num_merge_cand,
498  .num_ref_idx_l0_active_minus1 = sh->nb_refs[L0] ? sh->nb_refs[L0] - 1 : 0,
499  .num_ref_idx_l1_active_minus1 = sh->nb_refs[L1] ? sh->nb_refs[L1] - 1 : 0,
500 
501  .LongSliceFlags.fields = {
502  .dependent_slice_segment_flag = sh->dependent_slice_segment_flag,
503  .slice_type = sh->slice_type,
504  .color_plane_id = sh->colour_plane_id,
505  .mvd_l1_zero_flag = sh->mvd_l1_zero_flag,
506  .cabac_init_flag = sh->cabac_init_flag,
507  .slice_temporal_mvp_enabled_flag = sh->slice_temporal_mvp_enabled_flag,
508  .slice_deblocking_filter_disabled_flag = sh->disable_deblocking_filter_flag,
509  .collocated_from_l0_flag = sh->collocated_list == L0 ? 1 : 0,
510  .slice_loop_filter_across_slices_enabled_flag = sh->slice_loop_filter_across_slices_enabled_flag,
511  .slice_sao_luma_flag = sh->slice_sample_adaptive_offset_flag[0],
512  .slice_sao_chroma_flag = sh->slice_sample_adaptive_offset_flag[1],
513  },
514  };
515 
516  memset(last_slice_param->RefPicList, 0xFF, sizeof(last_slice_param->RefPicList));
517 
518  for (list_idx = 0; list_idx < nb_list; list_idx++) {
519  RefPicList *rpl = &h->cur_frame->refPicList[list_idx];
520 
521  for (i = 0; i < rpl->nb_refs; i++)
522  last_slice_param->RefPicList[list_idx][i] = get_ref_pic_index(h, rpl->ref[i]);
523  }
524 
525  fill_pred_weight_table(avctx, h, sh, last_slice_param);
526 
527 #if VA_CHECK_VERSION(1, 2, 0)
528  if (avctx->profile >= AV_PROFILE_HEVC_REXT) {
529  pic->last_slice_param.rext = (VASliceParameterBufferHEVCRext) {
530  .slice_ext_flags.bits = {
531  .cu_chroma_qp_offset_enabled_flag = sh->cu_chroma_qp_offset_enabled_flag,
532  .use_integer_mv_flag = sh->use_integer_mv_flag,
533  },
534  .slice_act_y_qp_offset = sh->slice_act_y_qp_offset,
535  .slice_act_cb_qp_offset = sh->slice_act_cb_qp_offset,
536  .slice_act_cr_qp_offset = sh->slice_act_cr_qp_offset,
537  };
538  for (i = 0; i < 15 && i < sh->nb_refs[L0]; i++) {
539  pic->last_slice_param.rext.luma_offset_l0[i] = sh->luma_offset_l0[i];
540  pic->last_slice_param.rext.ChromaOffsetL0[i][0] = sh->chroma_offset_l0[i][0];
541  pic->last_slice_param.rext.ChromaOffsetL0[i][1] = sh->chroma_offset_l0[i][1];
542  }
543 
544  if (sh->slice_type == HEVC_SLICE_B) {
545  for (i = 0; i < 15 && i < sh->nb_refs[L1]; i++) {
546  pic->last_slice_param.rext.luma_offset_l1[i] = sh->luma_offset_l1[i];
547  pic->last_slice_param.rext.ChromaOffsetL1[i][0] = sh->chroma_offset_l1[i][0];
548  pic->last_slice_param.rext.ChromaOffsetL1[i][1] = sh->chroma_offset_l1[i][1];
549  }
550  }
551  }
552 #endif
553 
554  pic->last_buffer = buffer;
555  pic->last_size = size;
556 
557  return 0;
558 }
559 
560 static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)
561 {
562  h265_raw_ptl->general_profile_space = general_ptl->profile_space;
563  h265_raw_ptl->general_tier_flag = general_ptl->tier_flag;
564  h265_raw_ptl->general_profile_idc = general_ptl->profile_idc;
565 
566  memcpy(h265_raw_ptl->general_profile_compatibility_flag,
567  general_ptl->profile_compatibility_flag, 32 * sizeof(uint8_t));
568 
569 #define copy_field(name) h265_raw_ptl->general_ ## name = general_ptl->name
570  copy_field(progressive_source_flag);
571  copy_field(interlaced_source_flag);
572  copy_field(non_packed_constraint_flag);
573  copy_field(frame_only_constraint_flag);
574  copy_field(max_12bit_constraint_flag);
575  copy_field(max_10bit_constraint_flag);
576  copy_field(max_8bit_constraint_flag);
577  copy_field(max_422chroma_constraint_flag);
578  copy_field(max_420chroma_constraint_flag);
579  copy_field(max_monochrome_constraint_flag);
580  copy_field(intra_constraint_flag);
581  copy_field(one_picture_only_constraint_flag);
582  copy_field(lower_bit_rate_constraint_flag);
583  copy_field(max_14bit_constraint_flag);
584  copy_field(inbld_flag);
586 #undef copy_field
587 
588  return 0;
589 }
590 
591 /*
592  * Find exact va_profile for HEVC Range Extension and Screen Content Coding Extension
593  */
595 {
596  const HEVCContext *h = avctx->priv_data;
597  const HEVCSPS *sps = h->ps.sps;
598  const PTL *ptl = &sps->ptl;
599  const PTLCommon *general_ptl = &ptl->general_ptl;
601  H265RawProfileTierLevel h265_raw_ptl = {0};
602 
603  /* convert PTLCommon to H265RawProfileTierLevel */
604  ptl_convert(general_ptl, &h265_raw_ptl);
605 
606  profile = ff_h265_get_profile(&h265_raw_ptl);
607  if (!profile) {
608  av_log(avctx, AV_LOG_WARNING, "HEVC profile is not found.\n");
609  goto end;
610  } else {
611  av_log(avctx, AV_LOG_VERBOSE, "HEVC profile %s is found.\n", profile->name);
612  }
613 
614 #if VA_CHECK_VERSION(1, 2, 0)
615  if (!strcmp(profile->name, "Main 12") ||
616  !strcmp(profile->name, "Main 12 Intra"))
617  return VAProfileHEVCMain12;
618  else if (!strcmp(profile->name, "Main 4:2:2 10") ||
619  !strcmp(profile->name, "Main 4:2:2 10 Intra"))
620  return VAProfileHEVCMain422_10;
621  else if (!strcmp(profile->name, "Main 4:2:2 12") ||
622  !strcmp(profile->name, "Main 4:2:2 12 Intra"))
623  return VAProfileHEVCMain422_12;
624  else if (!strcmp(profile->name, "Main 4:4:4") ||
625  !strcmp(profile->name, "Main 4:4:4 Intra"))
626  return VAProfileHEVCMain444;
627  else if (!strcmp(profile->name, "Main 4:4:4 10") ||
628  !strcmp(profile->name, "Main 4:4:4 10 Intra"))
629  return VAProfileHEVCMain444_10;
630  else if (!strcmp(profile->name, "Main 4:4:4 12") ||
631  !strcmp(profile->name, "Main 4:4:4 12 Intra"))
632  return VAProfileHEVCMain444_12;
633  else if (!strcmp(profile->name, "Screen-Extended Main"))
634  return VAProfileHEVCSccMain;
635  else if (!strcmp(profile->name, "Screen-Extended Main 10"))
636  return VAProfileHEVCSccMain10;
637  else if (!strcmp(profile->name, "Screen-Extended Main 4:4:4"))
638  return VAProfileHEVCSccMain444;
639 #if VA_CHECK_VERSION(1, 8, 0)
640  else if (!strcmp(profile->name, "Screen-Extended Main 4:4:4 10"))
641  return VAProfileHEVCSccMain444_10;
642 #endif
643 #else
644  av_log(avctx, AV_LOG_WARNING, "HEVC profile %s is "
645  "not supported with this VA version.\n", profile->name);
646 #endif
647 
648 end:
650  // Default to selecting Main profile if profile mismatch is allowed
651  return VAProfileHEVCMain;
652  } else
653  return VAProfileNone;
654 }
655 
657  .p.name = "hevc_vaapi",
658  .p.type = AVMEDIA_TYPE_VIDEO,
659  .p.id = AV_CODEC_ID_HEVC,
660  .p.pix_fmt = AV_PIX_FMT_VAAPI,
661  .start_frame = vaapi_hevc_start_frame,
662  .end_frame = vaapi_hevc_end_frame,
663  .decode_slice = vaapi_hevc_decode_slice,
664  .frame_priv_data_size = sizeof(VAAPIDecodePictureHEVC),
667  .frame_params = ff_vaapi_common_frame_params,
668  .priv_data_size = sizeof(VAAPIDecodeContext),
669  .caps_internal = HWACCEL_CAP_ASYNC_SAFE,
670 };
SliceHeader::beta_offset
int beta_offset
beta_offset_div2 * 2
Definition: hevcdec.h:254
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:386
SliceHeader::slice_act_cr_qp_offset
int slice_act_cr_qp_offset
Definition: hevcdec.h:250
SliceHeader::chroma_offset_l1
int16_t chroma_offset_l1[16][2]
Definition: hevcdec.h:279
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:344
SliceHeader::slice_act_y_qp_offset
int slice_act_y_qp_offset
Definition: hevcdec.h:248
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:81
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
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:39
level_idc
int level_idc
Definition: h264_levels.c:29
SliceHeader::slice_temporal_mvp_enabled_flag
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevcdec.h:230
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
PTLCommon::profile_space
uint8_t profile_space
Definition: ps.h:126
SliceHeader::slice_loop_filter_across_slices_enabled_flag
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: hevcdec.h:239
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:646
RefPicList
Definition: hevcdec.h:190
H265ProfileDescriptor
Definition: h265_profile_level.h:47
PTLCommon::profile_compatibility_flag
uint8_t profile_compatibility_flag[32]
Definition: ps.h:129
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
ptl_convert
static int ptl_convert(const PTLCommon *general_ptl, H265RawProfileTierLevel *h265_raw_ptl)
Definition: vaapi_hevc.c:560
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
HEVC_FRAME_FLAG_LONG_REF
#define HEVC_FRAME_FLAG_LONG_REF
Definition: hevcdec.h:351
FFHWAccel
Definition: hwaccel_internal.h:34
fail
#define fail()
Definition: checkasm.h:185
SliceHeader::luma_log2_weight_denom
uint8_t luma_log2_weight_denom
Definition: hevcdec.h:267
fill_vaapi_pic
static void fill_vaapi_pic(VAPictureHEVC *va_pic, const HEVCFrame *pic, int rps_type)
Definition: vaapi_hevc.c:55
RefPicList::nb_refs
int nb_refs
Definition: hevcdec.h:194
SliceHeader::slice_segment_addr
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevcdec.h:205
VAAPIDecodePicture::output_surface
VASurfaceID output_surface
Definition: vaapi_decode.h:40
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
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:237
PTLCommon
Definition: ps.h:125
ff_vaapi_decode_init
int ff_vaapi_decode_init(AVCodecContext *avctx)
Definition: vaapi_decode.c:671
AV_PROFILE_HEVC_SCC
#define AV_PROFILE_HEVC_SCC
Definition: defs.h:163
SliceHeader::luma_offset_l1
int16_t luma_offset_l1[16]
Definition: hevcdec.h:278
H265RawProfileTierLevel::general_profile_idc
uint8_t general_profile_idc
Definition: cbs_h265.h:39
ff_vaapi_common_frame_params
int ff_vaapi_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Definition: vaapi_decode.c:647
vaapi_hevc_decode_slice
static int vaapi_hevc_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)
Definition: vaapi_hevc.c:456
fill_vaapi_reference_frames
static void fill_vaapi_reference_frames(const HEVCContext *h, VAPictureParameterBufferHEVC *pp)
Definition: vaapi_hevc.c:99
find_frame_rps_type
static int find_frame_rps_type(const HEVCContext *h, const HEVCFrame *pic)
Definition: vaapi_hevc.c:72
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:76
HEVC_FRAME_FLAG_SHORT_REF
#define HEVC_FRAME_FLAG_SHORT_REF
Definition: hevcdec.h:350
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:191
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:123
ff_vaapi_decode_uninit
int ff_vaapi_decode_uninit(AVCodecContext *avctx)
Definition: vaapi_decode.c:717
PTLCommon::profile_idc
uint8_t profile_idc
Definition: ps.h:128
ScalingList
Definition: ps.h:183
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:240
SliceHeader::luma_offset_l0
int16_t luma_offset_l0[16]
Definition: hevcdec.h:275
SliceHeader::chroma_weight_l1
int16_t chroma_weight_l1[16][2]
Definition: hevcdec.h:272
PTLCommon::tier_flag
uint8_t tier_flag
Definition: ps.h:127
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
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
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:437
hwaccel_internal.h
HEVC_SLICE_I
@ HEVC_SLICE_I
Definition: hevc.h:98
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:2159
L0
#define L0
Definition: hevcdec.h:58
VAAPIDecodePictureHEVC
Definition: vaapi_hevc.c:34
PTL
Definition: ps.h:148
init_vaapi_pic
static void init_vaapi_pic(VAPictureHEVC *va_pic)
Definition: vaapi_hevc.c:48
VAAPIDecodePictureHEVC::last_size
size_t last_size
Definition: vaapi_hevc.c:43
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:232
H265RawProfileTierLevel::general_tier_flag
uint8_t general_tier_flag
Definition: cbs_h265.h:38
AV_PROFILE_HEVC_REXT
#define AV_PROFILE_HEVC_REXT
Definition: defs.h:162
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:79
SliceHeader::colour_plane_id
uint8_t colour_plane_id
RPS coded in the slice header itself is stored here.
Definition: hevcdec.h:217
ff_vaapi_parse_hevc_rext_scc_profile
VAProfile ff_vaapi_parse_hevc_rext_scc_profile(AVCodecContext *avctx)
Definition: vaapi_hevc.c:594
SliceHeader::dependent_slice_segment_flag
uint8_t dependent_slice_segment_flag
Definition: hevcdec.h:215
SliceHeader::slice_act_cb_qp_offset
int slice_act_cb_qp_offset
Definition: hevcdec.h:249
SliceHeader::first_slice_in_pic_flag
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:214
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:242
h265_profile_level.h
vaapi_hevc.h
ff_vaapi_decode_cancel
int ff_vaapi_decode_cancel(AVCodecContext *avctx, VAAPIDecodePicture *pic)
Definition: vaapi_decode.c:232
SliceHeader::chroma_weight_l0
int16_t chroma_weight_l0[16][2]
Definition: hevcdec.h:271
VAAPIDecodePictureHEVC::last_slice_param
VASliceParameterBufferHEVC last_slice_param
Definition: vaapi_hevc.c:40
SliceHeader::chroma_log2_weight_denom
int16_t chroma_log2_weight_denom
Definition: hevcdec.h:268
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
ff_hevc_vaapi_hwaccel
const FFHWAccel ff_hevc_vaapi_hwaccel
Definition: vaapi_hevc.c:656
AVHWAccel::name
const char * name
Name of the hardware accelerated codec.
Definition: avcodec.h:2095
SliceHeader::slice_cb_qp_offset
int slice_cb_qp_offset
Definition: hevcdec.h:245
SliceHeader
Definition: hevcdec.h:201
uninit
static void uninit(AVBSFContext *ctx)
Definition: pcm_rechunk.c:68
SliceHeader::slice_sample_adaptive_offset_flag
uint8_t slice_sample_adaptive_offset_flag[3]
Definition: hevcdec.h:234
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
HEVCFrame
Definition: hevcdec.h:357
VAAPIDecodePictureHEVC::last_buffer
const uint8_t * last_buffer
Definition: vaapi_hevc.c:42
AVCodecContext::hwaccel_flags
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition: avcodec.h:1506
SliceHeader::mvd_l1_zero_flag
uint8_t mvd_l1_zero_flag
Definition: hevcdec.h:235
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
VAAPIDecodePictureHEVC::pic_param
VAPictureParameterBufferHEVC pic_param
Definition: vaapi_hevc.c:39
SliceHeader::data_offset
unsigned data_offset
Definition: hevcdec.h:282
copy_field
#define copy_field(name)
SliceHeader::chroma_offset_l0
int16_t chroma_offset_l0[16][2]
Definition: hevcdec.h:276
profile
int profile
Definition: mxfenc.c:2228
H265RawProfileTierLevel
Definition: cbs_h265.h:36
HEVCFrame::poc
int poc
Definition: hevcdec.h:370
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
HEVCFrame::f
AVFrame * f
Definition: hevcdec.h:360
H265RawProfileTierLevel::general_profile_space
uint8_t general_profile_space
Definition: cbs_h265.h:37
avcodec.h
SliceHeader::cu_chroma_qp_offset_enabled_flag
uint8_t cu_chroma_qp_offset_enabled_flag
Definition: hevcdec.h:252
H265RawProfileTierLevel::general_profile_compatibility_flag
uint8_t general_profile_compatibility_flag[32]
Definition: cbs_h265.h:41
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:82
SliceHeader::disable_deblocking_filter_flag
uint8_t disable_deblocking_filter_flag
slice_header_disable_deblocking_filter_flag
Definition: hevcdec.h:238
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
SliceHeader::max_num_merge_cand
uint8_t max_num_merge_cand
5 - 5_minus_max_num_merge_cand
Definition: hevcdec.h:257
SliceHeader::luma_weight_l0
int16_t luma_weight_l0[16]
Definition: hevcdec.h:270
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:209
LT_CURR
@ LT_CURR
Definition: hevcdec.h:85
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:374
SliceHeader::slice_cr_qp_offset
int slice_cr_qp_offset
Definition: hevcdec.h:246
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:63
HEVCContext
Definition: hevcdec.h:450
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
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: ps.h:190
HEVCPPS
Definition: ps.h:309
ST_CURR_AFT
@ ST_CURR_AFT
Definition: hevcdec.h:83
SliceHeader::tc_offset
int tc_offset
tc_offset_div2 * 2
Definition: hevcdec.h:255
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
VAAPIDecodePictureHEVC::pic
VAAPIDecodePicture pic
Definition: vaapi_hevc.c:45
SliceHeader::luma_weight_l1
int16_t luma_weight_l1[16]
Definition: hevcdec.h:273
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
SliceHeader::slice_qp_delta
int slice_qp_delta
Definition: hevcdec.h:244
SliceHeader::use_integer_mv_flag
uint8_t use_integer_mv_flag
Definition: hevcdec.h:258
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97