FFmpeg
hevcdec.c
Go to the documentation of this file.
1 /*
2  * HEVC video Decoder
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2012 - 2013 Wassim Hamidouche
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "config_components.h"
27 
28 #include "libavutil/attributes.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/common.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/md5.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavutil/stereo3d.h"
39 #include "libavutil/tdrdi.h"
40 #include "libavutil/timecode.h"
41 #include "libavutil/refstruct.h"
42 
44 #include "libavcodec/bswapdsp.h"
47 #include "libavcodec/decode.h"
48 #include "libavcodec/golomb.h"
49 #include "libavcodec/h274.h"
51 #include "libavcodec/hwconfig.h"
52 #include "libavcodec/internal.h"
53 #include "libavcodec/profiles.h"
55 #include "libavcodec/thread.h"
57 
58 #include "hevc.h"
59 #include "parse.h"
60 #include "hevcdec.h"
61 
62 static const uint8_t hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
63 
64 /**
65  * NOTE: Each function hls_foo correspond to the function foo in the
66  * specification (HLS stands for High Level Syntax).
67  */
68 
69 /**
70  * Section 5.7
71  */
72 
73 /* free everything allocated by pic_arrays_init() */
75 {
76  av_freep(&l->sao);
77  av_freep(&l->deblock);
78 
79  av_freep(&l->skip_flag);
81 
82  av_freep(&l->tab_ipm);
83  av_freep(&l->cbf_luma);
84  av_freep(&l->is_pcm);
85 
86  av_freep(&l->qp_y_tab);
89 
91  av_freep(&l->vertical_bs);
92 
93  for (int i = 0; i < 3; i++) {
96  }
97 
100 }
101 
102 /* allocate arrays that depend on frame dimensions */
104 {
105  int log2_min_cb_size = sps->log2_min_cb_size;
106  int width = sps->width;
107  int height = sps->height;
108  int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
109  ((height >> log2_min_cb_size) + 1);
110  int ctb_count = sps->ctb_width * sps->ctb_height;
111  int min_pu_size = sps->min_pu_width * sps->min_pu_height;
112 
113  l->bs_width = (width >> 2) + 1;
114  l->bs_height = (height >> 2) + 1;
115 
116  l->sao = av_calloc(ctb_count, sizeof(*l->sao));
117  l->deblock = av_calloc(ctb_count, sizeof(*l->deblock));
118  if (!l->sao || !l->deblock)
119  goto fail;
120 
121  l->skip_flag = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
122  l->tab_ct_depth = av_malloc_array(sps->min_cb_height, sps->min_cb_width);
123  if (!l->skip_flag || !l->tab_ct_depth)
124  goto fail;
125 
126  l->cbf_luma = av_malloc_array(sps->min_tb_width, sps->min_tb_height);
127  l->tab_ipm = av_mallocz(min_pu_size);
128  l->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
129  if (!l->tab_ipm || !l->cbf_luma || !l->is_pcm)
130  goto fail;
131 
132  l->filter_slice_edges = av_mallocz(ctb_count);
133  l->tab_slice_address = av_malloc_array(pic_size_in_ctb,
134  sizeof(*l->tab_slice_address));
135  l->qp_y_tab = av_calloc(pic_size_in_ctb,
136  sizeof(*l->qp_y_tab));
137  if (!l->qp_y_tab || !l->filter_slice_edges || !l->tab_slice_address)
138  goto fail;
139 
142  if (!l->horizontal_bs || !l->vertical_bs)
143  goto fail;
144 
145  l->tab_mvf_pool = av_refstruct_pool_alloc(min_pu_size * sizeof(MvField), 0);
146  l->rpl_tab_pool = av_refstruct_pool_alloc(ctb_count * sizeof(RefPicListTab), 0);
147  if (!l->tab_mvf_pool || !l->rpl_tab_pool)
148  goto fail;
149 
150  if (sps->sao_enabled) {
151  int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
152 
153  for (int c_idx = 0; c_idx < c_count; c_idx++) {
154  int w = sps->width >> sps->hshift[c_idx];
155  int h = sps->height >> sps->vshift[c_idx];
156  l->sao_pixel_buffer_h[c_idx] =
157  av_mallocz((w * 2 * sps->ctb_height) <<
158  sps->pixel_shift);
159  l->sao_pixel_buffer_v[c_idx] =
160  av_mallocz((h * 2 * sps->ctb_width) <<
161  sps->pixel_shift);
162  if (!l->sao_pixel_buffer_h[c_idx] ||
163  !l->sao_pixel_buffer_v[c_idx])
164  goto fail;
165  }
166  }
167 
168  return 0;
169 
170 fail:
171  pic_arrays_free(l);
172  return AVERROR(ENOMEM);
173 }
174 
175 static int pred_weight_table(SliceHeader *sh, void *logctx,
176  const HEVCSPS *sps, GetBitContext *gb)
177 {
178  int i = 0;
179  int j = 0;
180  int luma_log2_weight_denom;
181  unsigned luma_weight_flags, chroma_weight_flags;
182 
183  luma_log2_weight_denom = get_ue_golomb_long(gb);
184  if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
185  av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
186  return AVERROR_INVALIDDATA;
187  }
188  sh->luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
189  if (sps->chroma_format_idc != 0) {
190  int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
191  if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
192  av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
193  return AVERROR_INVALIDDATA;
194  }
195  sh->chroma_log2_weight_denom = chroma_log2_weight_denom;
196  }
197 
198  luma_weight_flags = get_bits(gb, sh->nb_refs[L0]);
199  chroma_weight_flags = sps->chroma_format_idc != 0 ? get_bits(gb, sh->nb_refs[L0]) : 0;
200  for (i = 0; i < sh->nb_refs[L0]; i++) {
201  unsigned flag_bit = 1 << (sh->nb_refs[L0] - 1 - i);
202 
203  if (luma_weight_flags & flag_bit) {
204  int delta_luma_weight_l0 = get_se_golomb(gb);
205  if ((int8_t)delta_luma_weight_l0 != delta_luma_weight_l0)
206  return AVERROR_INVALIDDATA;
207  sh->luma_weight_l0[i] = (1 << sh->luma_log2_weight_denom) + delta_luma_weight_l0;
208  sh->luma_offset_l0[i] = get_se_golomb(gb);
209  } else {
210  sh->luma_weight_l0[i] = 1 << sh->luma_log2_weight_denom;
211  sh->luma_offset_l0[i] = 0;
212  }
213  if (chroma_weight_flags & flag_bit) {
214  for (j = 0; j < 2; j++) {
215  int delta_chroma_weight_l0 = get_se_golomb(gb);
216  int delta_chroma_offset_l0 = get_se_golomb(gb);
217 
218  if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
219  || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
220  return AVERROR_INVALIDDATA;
221  }
222 
223  sh->chroma_weight_l0[i][j] = (1 << sh->chroma_log2_weight_denom) + delta_chroma_weight_l0;
224  sh->chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * sh->chroma_weight_l0[i][j])
225  >> sh->chroma_log2_weight_denom) + 128), -128, 127);
226  }
227  } else {
228  sh->chroma_weight_l0[i][0] = 1 << sh->chroma_log2_weight_denom;
229  sh->chroma_offset_l0[i][0] = 0;
230  sh->chroma_weight_l0[i][1] = 1 << sh->chroma_log2_weight_denom;
231  sh->chroma_offset_l0[i][1] = 0;
232  }
233  }
234  if (sh->slice_type == HEVC_SLICE_B) {
235  luma_weight_flags = get_bits(gb, sh->nb_refs[L1]);
236  chroma_weight_flags = sps->chroma_format_idc != 0 ? get_bits(gb, sh->nb_refs[L1]) : 0;
237  for (i = 0; i < sh->nb_refs[L1]; i++) {
238  unsigned flag_bit = 1 << (sh->nb_refs[L1] - 1 - i);
239 
240  if (luma_weight_flags & flag_bit) {
241  int delta_luma_weight_l1 = get_se_golomb(gb);
242  if ((int8_t)delta_luma_weight_l1 != delta_luma_weight_l1)
243  return AVERROR_INVALIDDATA;
244  sh->luma_weight_l1[i] = (1 << sh->luma_log2_weight_denom) + delta_luma_weight_l1;
245  sh->luma_offset_l1[i] = get_se_golomb(gb);
246  } else {
247  sh->luma_weight_l1[i] = 1 << sh->luma_log2_weight_denom;
248  sh->luma_offset_l1[i] = 0;
249  }
250  if (chroma_weight_flags & flag_bit) {
251  for (j = 0; j < 2; j++) {
252  int delta_chroma_weight_l1 = get_se_golomb(gb);
253  int delta_chroma_offset_l1 = get_se_golomb(gb);
254 
255  if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
256  || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
257  return AVERROR_INVALIDDATA;
258  }
259 
260  sh->chroma_weight_l1[i][j] = (1 << sh->chroma_log2_weight_denom) + delta_chroma_weight_l1;
261  sh->chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * sh->chroma_weight_l1[i][j])
262  >> sh->chroma_log2_weight_denom) + 128), -128, 127);
263  }
264  } else {
265  sh->chroma_weight_l1[i][0] = 1 << sh->chroma_log2_weight_denom;
266  sh->chroma_offset_l1[i][0] = 0;
267  sh->chroma_weight_l1[i][1] = 1 << sh->chroma_log2_weight_denom;
268  sh->chroma_offset_l1[i][1] = 0;
269  }
270  }
271  }
272  return 0;
273 }
274 
275 static int decode_lt_rps(const HEVCSPS *sps, LongTermRPS *rps,
276  GetBitContext *gb, int cur_poc, int poc_lsb)
277 {
278  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
279  int prev_delta_msb = 0;
280  unsigned int nb_sps = 0, nb_sh;
281  int i;
282 
283  rps->nb_refs = 0;
284  if (!sps->long_term_ref_pics_present)
285  return 0;
286 
287  if (sps->num_long_term_ref_pics_sps > 0)
288  nb_sps = get_ue_golomb_long(gb);
289  nb_sh = get_ue_golomb_long(gb);
290 
291  if (nb_sps > sps->num_long_term_ref_pics_sps)
292  return AVERROR_INVALIDDATA;
293  if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
294  return AVERROR_INVALIDDATA;
295 
296  rps->nb_refs = nb_sh + nb_sps;
297 
298  for (i = 0; i < rps->nb_refs; i++) {
299 
300  if (i < nb_sps) {
301  uint8_t lt_idx_sps = 0;
302 
303  if (sps->num_long_term_ref_pics_sps > 1)
304  lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
305 
306  rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
307  rps->used[i] = !!(sps->used_by_curr_pic_lt & (1U << lt_idx_sps));
308  } else {
309  rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
310  rps->used[i] = get_bits1(gb);
311  }
312 
313  rps->poc_msb_present[i] = get_bits1(gb);
314  if (rps->poc_msb_present[i]) {
316  int64_t poc;
317 
318  if (i && i != nb_sps)
319  delta += prev_delta_msb;
320 
321  poc = rps->poc[i] + cur_poc - delta * max_poc_lsb - poc_lsb;
322  if (poc != (int32_t)poc)
323  return AVERROR_INVALIDDATA;
324  rps->poc[i] = poc;
325  prev_delta_msb = delta;
326  }
327  }
328 
329  return 0;
330 }
331 
333 {
334  AVCodecContext *avctx = s->avctx;
335  const HEVCVPS *vps = sps->vps;
336  const HEVCWindow *ow = &sps->output_window;
337  unsigned int num = 0, den = 0;
338 
339  avctx->pix_fmt = sps->pix_fmt;
340  avctx->coded_width = sps->width;
341  avctx->coded_height = sps->height;
342  avctx->width = sps->width - ow->left_offset - ow->right_offset;
343  avctx->height = sps->height - ow->top_offset - ow->bottom_offset;
344  avctx->has_b_frames = sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics;
345  avctx->profile = sps->ptl.general_ptl.profile_idc;
346  avctx->level = sps->ptl.general_ptl.level_idc;
347 
348  ff_set_sar(avctx, sps->vui.common.sar);
349 
350  if (sps->vui.common.video_signal_type_present_flag)
351  avctx->color_range = sps->vui.common.video_full_range_flag ? AVCOL_RANGE_JPEG
353  else
354  avctx->color_range = AVCOL_RANGE_MPEG;
355 
356  if (sps->vui.common.colour_description_present_flag) {
357  avctx->color_primaries = sps->vui.common.colour_primaries;
358  avctx->color_trc = sps->vui.common.transfer_characteristics;
359  avctx->colorspace = sps->vui.common.matrix_coeffs;
360  } else {
364  }
365 
367  if (sps->chroma_format_idc == 1) {
368  if (sps->vui.common.chroma_loc_info_present_flag) {
369  if (sps->vui.common.chroma_sample_loc_type_top_field <= 5)
370  avctx->chroma_sample_location = sps->vui.common.chroma_sample_loc_type_top_field + 1;
371  } else
373  }
374 
375  if (vps->vps_timing_info_present_flag) {
376  num = vps->vps_num_units_in_tick;
377  den = vps->vps_time_scale;
378  } else if (sps->vui.vui_timing_info_present_flag) {
379  num = sps->vui.vui_num_units_in_tick;
380  den = sps->vui.vui_time_scale;
381  }
382 
383  if (num > 0 && den > 0)
384  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
385  num, den, 1 << 30);
386 }
387 
389 {
390  AVCodecContext *avctx = s->avctx;
391 
392 #if FF_API_CODEC_PROPS
394  if (s->sei.common.itut_t35.a53_cc)
395  s->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
397 #endif
398 
399  if (s->sei.common.alternative_transfer.present &&
400  av_color_transfer_name(s->sei.common.alternative_transfer.preferred_transfer_characteristics) &&
401  s->sei.common.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
402  avctx->color_trc = s->sei.common.alternative_transfer.preferred_transfer_characteristics;
403  }
404 
405 #if FF_API_CODEC_PROPS
407  if ((s->sei.common.film_grain_characteristics && s->sei.common.film_grain_characteristics->present) ||
408  s->sei.common.itut_t35.aom_film_grain.enable)
411 #endif
412 
413  return 0;
414 }
415 
417 {
418  const HEVCSEITDRDI *tdrdi = &s->sei.tdrdi;
419 
420  av_freep(&s->view_ids_available);
421  s->nb_view_ids_available = 0;
422  av_freep(&s->view_pos_available);
423  s->nb_view_pos_available = 0;
424 
425  // don't export anything in the trivial case (1 layer, view id=0)
426  if (vps->nb_layers < 2 && !vps->view_id[0])
427  return 0;
428 
429  s->view_ids_available = av_calloc(vps->nb_layers, sizeof(*s->view_ids_available));
430  if (!s->view_ids_available)
431  return AVERROR(ENOMEM);
432 
433  if (tdrdi->num_ref_displays) {
434  s->view_pos_available = av_calloc(vps->nb_layers, sizeof(*s->view_pos_available));
435  if (!s->view_pos_available)
436  return AVERROR(ENOMEM);
437  }
438 
439  for (int i = 0; i < vps->nb_layers; i++) {
440  s->view_ids_available[i] = vps->view_id[i];
441 
442  if (s->view_pos_available) {
443  s->view_pos_available[i] = vps->view_id[i] == tdrdi->left_view_id[0] ?
445  vps->view_id[i] == tdrdi->right_view_id[0] ?
447  }
448  }
449  s->nb_view_ids_available = vps->nb_layers;
450  s->nb_view_pos_available = s->view_pos_available ? vps->nb_layers : 0;
451 
452  return 0;
453 }
454 
456 {
457  const HEVCVPS *vps = s->vps;
458  int ret = 0;
459 
460  if (vps->nb_layers != 2 || !vps->layer_id_in_nuh[1])
461  return 0;
462 
463  /* decode_vps_ext() guarantees that SCALABILITY_AUXILIARY with AuxId other
464  * than alpha cannot reach here.
465  */
466  ret = (s->vps->scalability_mask_flag & HEVC_SCALABILITY_AUXILIARY);
467 
468  av_log(s->avctx, AV_LOG_DEBUG, "Multi layer video, %s alpha video\n",
469  ret ? "is" : "not");
470 
471  return ret;
472 }
473 
475 {
476  unsigned layers_active_output = 0, highest_layer;
477 
478  s->layers_active_output = 1;
479  s->layers_active_decode = 1;
480 
481  if (ff_hevc_is_alpha_video(s)) {
482  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
483 
484  if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))
485  return 0;
486 
487  s->layers_active_decode = (1 << vps->nb_layers) - 1;
488  s->layers_active_output = 1;
489 
490  return 0;
491  }
492 
493  // nothing requested - decode base layer only
494  if (!s->nb_view_ids)
495  return 0;
496 
497  if (s->nb_view_ids == 1 && s->view_ids[0] == -1) {
498  layers_active_output = (1 << vps->nb_layers) - 1;
499  } else {
500  for (int i = 0; i < s->nb_view_ids; i++) {
501  int view_id = s->view_ids[i];
502  int layer_idx = -1;
503 
504  if (view_id < 0) {
505  av_log(s->avctx, AV_LOG_ERROR,
506  "Invalid view ID requested: %d\n", view_id);
507  return AVERROR(EINVAL);
508  }
509 
510  for (int j = 0; j < vps->nb_layers; j++) {
511  if (vps->view_id[j] == view_id) {
512  layer_idx = j;
513  break;
514  }
515  }
516  if (layer_idx < 0) {
517  av_log(s->avctx, AV_LOG_ERROR,
518  "View ID %d not present in VPS\n", view_id);
519  return AVERROR(EINVAL);
520  }
521  layers_active_output |= 1 << layer_idx;
522  }
523  }
524 
525  if (!layers_active_output) {
526  av_log(s->avctx, AV_LOG_ERROR, "No layers selected\n");
527  return AVERROR_BUG;
528  }
529 
530  highest_layer = ff_log2(layers_active_output);
531  if (highest_layer >= FF_ARRAY_ELEMS(s->layers)) {
532  av_log(s->avctx, AV_LOG_ERROR,
533  "Too many layers requested: %u\n", layers_active_output);
534  return AVERROR(EINVAL);
535  }
536 
537  /* Assume a higher layer depends on all the lower ones.
538  * This is enforced in VPS parsing currently, this logic will need
539  * to be changed if we want to support more complex dependency structures.
540  */
541  s->layers_active_decode = (1 << (highest_layer + 1)) - 1;
542  s->layers_active_output = layers_active_output;
543 
544  av_log(s->avctx, AV_LOG_DEBUG, "decode/output layers: %x/%x\n",
545  s->layers_active_decode, s->layers_active_output);
546 
547  return 0;
548 }
549 
551  enum AVPixelFormat pix_fmt)
552 {
553  switch (pix_fmt) {
554  case AV_PIX_FMT_YUV420P:
555  case AV_PIX_FMT_YUVJ420P:
556  return AV_PIX_FMT_YUVA420P;
558  return AV_PIX_FMT_YUVA420P10;
559  case AV_PIX_FMT_YUV444P:
560  return AV_PIX_FMT_YUVA444P;
561  case AV_PIX_FMT_YUV422P:
562  return AV_PIX_FMT_YUVA422P;
566  return AV_PIX_FMT_YUVA444P10;
568  return AV_PIX_FMT_YUVA444P12;
570  return AV_PIX_FMT_YUVA422P12;
571  default:
572  av_log(s->avctx, AV_LOG_WARNING, "No alpha pixel format map for %s\n",
574  return AV_PIX_FMT_NONE;
575  }
576 }
577 
579 {
580 #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + \
581  CONFIG_HEVC_D3D11VA_HWACCEL * 2 + \
582  CONFIG_HEVC_D3D12VA_HWACCEL + \
583  CONFIG_HEVC_NVDEC_HWACCEL + \
584  CONFIG_HEVC_VAAPI_HWACCEL + \
585  CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL + \
586  CONFIG_HEVC_VDPAU_HWACCEL + \
587  CONFIG_HEVC_VULKAN_HWACCEL)
588  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 3], *fmt = pix_fmts;
589  enum AVPixelFormat alpha_fmt = AV_PIX_FMT_NONE;
590  int ret;
591 
593  alpha_fmt = map_to_alpha_format(s, sps->pix_fmt);
594 
595  switch (sps->pix_fmt) {
596  case AV_PIX_FMT_YUV420P:
597  case AV_PIX_FMT_YUVJ420P:
598 #if CONFIG_HEVC_DXVA2_HWACCEL
599  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
600 #endif
601 #if CONFIG_HEVC_D3D11VA_HWACCEL
602  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
603  *fmt++ = AV_PIX_FMT_D3D11;
604 #endif
605 #if CONFIG_HEVC_D3D12VA_HWACCEL
606  *fmt++ = AV_PIX_FMT_D3D12;
607 #endif
608 #if CONFIG_HEVC_VAAPI_HWACCEL
609  *fmt++ = AV_PIX_FMT_VAAPI;
610 #endif
611 #if CONFIG_HEVC_VDPAU_HWACCEL
612  *fmt++ = AV_PIX_FMT_VDPAU;
613 #endif
614 #if CONFIG_HEVC_NVDEC_HWACCEL
615  *fmt++ = AV_PIX_FMT_CUDA;
616 #endif
617 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
618  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
619 #endif
620 #if CONFIG_HEVC_VULKAN_HWACCEL
621  *fmt++ = AV_PIX_FMT_VULKAN;
622 #endif
623  break;
625 #if CONFIG_HEVC_DXVA2_HWACCEL
626  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
627 #endif
628 #if CONFIG_HEVC_D3D11VA_HWACCEL
629  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
630  *fmt++ = AV_PIX_FMT_D3D11;
631 #endif
632 #if CONFIG_HEVC_D3D12VA_HWACCEL
633  *fmt++ = AV_PIX_FMT_D3D12;
634 #endif
635 #if CONFIG_HEVC_VAAPI_HWACCEL
636  *fmt++ = AV_PIX_FMT_VAAPI;
637 #endif
638 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
639  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
640 #endif
641 #if CONFIG_HEVC_VULKAN_HWACCEL
642  *fmt++ = AV_PIX_FMT_VULKAN;
643 #endif
644 #if CONFIG_HEVC_VDPAU_HWACCEL
645  *fmt++ = AV_PIX_FMT_VDPAU;
646 #endif
647 #if CONFIG_HEVC_NVDEC_HWACCEL
648  *fmt++ = AV_PIX_FMT_CUDA;
649 #endif
650  break;
651  case AV_PIX_FMT_YUV444P:
652 #if CONFIG_HEVC_VAAPI_HWACCEL
653  *fmt++ = AV_PIX_FMT_VAAPI;
654 #endif
655 #if CONFIG_HEVC_VDPAU_HWACCEL
656  *fmt++ = AV_PIX_FMT_VDPAU;
657 #endif
658 #if CONFIG_HEVC_NVDEC_HWACCEL
659  *fmt++ = AV_PIX_FMT_CUDA;
660 #endif
661 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
662  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
663 #endif
664 #if CONFIG_HEVC_VULKAN_HWACCEL
665  *fmt++ = AV_PIX_FMT_VULKAN;
666 #endif
667  break;
668  case AV_PIX_FMT_YUV422P:
670 #if CONFIG_HEVC_VAAPI_HWACCEL
671  *fmt++ = AV_PIX_FMT_VAAPI;
672 #endif
673 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
674  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
675 #endif
676 #if CONFIG_HEVC_VULKAN_HWACCEL
677  *fmt++ = AV_PIX_FMT_VULKAN;
678 #endif
679 #if CONFIG_HEVC_NVDEC_HWACCEL
680  *fmt++ = AV_PIX_FMT_CUDA;
681 #endif
682  break;
684 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
685  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
686 #endif
690 #if CONFIG_HEVC_VAAPI_HWACCEL
691  *fmt++ = AV_PIX_FMT_VAAPI;
692 #endif
693 #if CONFIG_HEVC_VDPAU_HWACCEL
694  *fmt++ = AV_PIX_FMT_VDPAU;
695 #endif
696 #if CONFIG_HEVC_VULKAN_HWACCEL
697  *fmt++ = AV_PIX_FMT_VULKAN;
698 #endif
699 #if CONFIG_HEVC_NVDEC_HWACCEL
700  *fmt++ = AV_PIX_FMT_CUDA;
701 #endif
702  break;
704 #if CONFIG_HEVC_VAAPI_HWACCEL
705  *fmt++ = AV_PIX_FMT_VAAPI;
706 #endif
707 #if CONFIG_HEVC_VULKAN_HWACCEL
708  *fmt++ = AV_PIX_FMT_VULKAN;
709 #endif
710 #if CONFIG_HEVC_NVDEC_HWACCEL
711  *fmt++ = AV_PIX_FMT_CUDA;
712 #endif
713  break;
714  }
715 
716  if (alpha_fmt != AV_PIX_FMT_NONE)
717  *fmt++ = alpha_fmt;
718  *fmt++ = sps->pix_fmt;
719  *fmt = AV_PIX_FMT_NONE;
720 
721  // export multilayer information from active VPS to the caller,
722  // so it is available in get_format()
723  ret = export_multilayer(s, sps->vps);
724  if (ret < 0)
725  return ret;
726 
727  ret = ff_get_format(s->avctx, pix_fmts);
728  if (ret < 0)
729  return ret;
730  s->avctx->pix_fmt = ret;
731 
732  // set up multilayer decoding, if requested by caller
733  ret = setup_multilayer(s, sps->vps);
734  if (ret < 0)
735  return ret;
736 
737  return 0;
738 }
739 
741 {
742  int ret;
743 
744  pic_arrays_free(l);
745  av_refstruct_unref(&l->sps);
746  av_refstruct_unref(&s->vps);
747 
748  if (!sps)
749  return 0;
750 
751  ret = pic_arrays_init(l, sps);
752  if (ret < 0)
753  goto fail;
754 
755  ff_hevc_pred_init(&s->hpc, sps->bit_depth);
756  ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
757  ff_videodsp_init (&s->vdsp, sps->bit_depth);
758 
759  l->sps = av_refstruct_ref_c(sps);
760  s->vps = av_refstruct_ref_c(sps->vps);
761 
762  return 0;
763 
764 fail:
765  pic_arrays_free(l);
766  av_refstruct_unref(&l->sps);
767  return ret;
768 }
769 
771 {
772  const HEVCPPS *pps;
773  const HEVCSPS *sps;
774  const HEVCVPS *vps;
775  unsigned pps_id, layer_idx;
776  int i, ret;
777 
778  // Coded parameters
780 
782  if (IS_IRAP(s))
784 
785  pps_id = get_ue_golomb_long(gb);
786  if (pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[pps_id]) {
787  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
788  return AVERROR_INVALIDDATA;
789  }
790  if (!sh->first_slice_in_pic_flag && s->ps.pps_list[pps_id] != s->pps) {
791  av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
792  return AVERROR_INVALIDDATA;
793  }
794  sh->pps_id = pps_id;
795 
796  pps = s->ps.pps_list[pps_id];
797  sps = pps->sps;
798  vps = sps->vps;
799  layer_idx = vps->layer_idx[s->nuh_layer_id];
800 
801  if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
803 
805  if (!sh->first_slice_in_pic_flag) {
806  int slice_address_length;
807 
808  if (pps->dependent_slice_segments_enabled_flag)
810  if (sh->dependent_slice_segment_flag && !s->slice_initialized) {
811  av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
812  return AVERROR_INVALIDDATA;
813  }
814 
815  slice_address_length = av_ceil_log2(sps->ctb_width *
816  sps->ctb_height);
817  sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
818  if (sh->slice_segment_addr >= sps->ctb_width * sps->ctb_height) {
819  av_log(s->avctx, AV_LOG_ERROR,
820  "Invalid slice segment address: %u.\n",
821  sh->slice_segment_addr);
822  return AVERROR_INVALIDDATA;
823  }
824 
825  if (!sh->dependent_slice_segment_flag) {
826  sh->slice_addr = sh->slice_segment_addr;
827  }
828  } else {
829  sh->slice_segment_addr = sh->slice_addr = 0;
830  }
831 
832  if (!sh->dependent_slice_segment_flag) {
833  for (i = 0; i < pps->num_extra_slice_header_bits; i++)
834  skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
835 
836  sh->slice_type = get_ue_golomb_long(gb);
837  if (!(sh->slice_type == HEVC_SLICE_I ||
838  sh->slice_type == HEVC_SLICE_P ||
839  sh->slice_type == HEVC_SLICE_B)) {
840  av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
841  sh->slice_type);
842  return AVERROR_INVALIDDATA;
843  }
844  if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I &&
845  !pps->pps_curr_pic_ref_enabled_flag &&
846  s->nuh_layer_id == 0) {
847  av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
848  return AVERROR_INVALIDDATA;
849  }
850 
851  // when flag is not present, picture is inferred to be output
852  sh->pic_output_flag = 1;
853  if (pps->output_flag_present_flag)
854  sh->pic_output_flag = get_bits1(gb);
855 
856  if (sps->separate_colour_plane)
857  sh->colour_plane_id = get_bits(gb, 2);
858 
859  if (!IS_IDR(s) ||
860  (s->nuh_layer_id > 0 &&
861  !(vps->poc_lsb_not_present & (1 << layer_idx)))) {
862  int poc;
863 
864  sh->pic_order_cnt_lsb = get_bits(gb, sps->log2_max_poc_lsb);
865  poc = ff_hevc_compute_poc(sps, s->poc_tid0, sh->pic_order_cnt_lsb, s->nal_unit_type);
866  if (!sh->first_slice_in_pic_flag && poc != sh->poc) {
867  av_log(s->avctx, AV_LOG_WARNING,
868  "Ignoring POC change between slices: %d -> %d\n", poc, sh->poc);
869  if (s->avctx->err_recognition & AV_EF_EXPLODE)
870  return AVERROR_INVALIDDATA;
871  poc = sh->poc;
872  }
873  sh->poc = poc;
874  }
875 
876  if (!IS_IDR(s)) {
877  int pos;
878 
880  pos = get_bits_left(gb);
882  ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, sps, 1);
883  if (ret < 0)
884  return ret;
885 
886  sh->short_term_rps = &sh->slice_rps;
887  } else {
888  int numbits, rps_idx;
889 
890  if (!sps->nb_st_rps) {
891  av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
892  return AVERROR_INVALIDDATA;
893  }
894 
895  numbits = av_ceil_log2(sps->nb_st_rps);
896  rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
897  sh->short_term_rps = &sps->st_rps[rps_idx];
898  }
900 
901  pos = get_bits_left(gb);
902  ret = decode_lt_rps(sps, &sh->long_term_rps, gb, sh->poc, sh->pic_order_cnt_lsb);
903  if (ret < 0) {
904  av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
905  if (s->avctx->err_recognition & AV_EF_EXPLODE)
906  return AVERROR_INVALIDDATA;
907  }
909 
910  if (sps->temporal_mvp_enabled)
912  else
914  } else {
915  sh->poc = 0;
916  sh->pic_order_cnt_lsb = 0;
919  sh->short_term_rps = NULL;
921  sh->long_term_rps.nb_refs = 0;
923  }
924 
925  sh->inter_layer_pred = 0;
926  if (s->nuh_layer_id > 0) {
927  int num_direct_ref_layers = vps->num_direct_ref_layers[layer_idx];
928 
929  if (vps->default_ref_layers_active)
930  sh->inter_layer_pred = !!num_direct_ref_layers;
931  else if (num_direct_ref_layers) {
932  sh->inter_layer_pred = get_bits1(gb);
933 
934  if (sh->inter_layer_pred && num_direct_ref_layers > 1) {
935  av_log(s->avctx, AV_LOG_ERROR,
936  "NumDirectRefLayers>1 not supported\n");
937  return AVERROR_PATCHWELCOME;
938  }
939  }
940  }
941 
942  if (sps->sao_enabled) {
944  if (sps->chroma_format_idc) {
947  }
948  } else {
952  }
953 
954  sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
955  if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
956  int nb_refs;
957 
958  sh->nb_refs[L0] = pps->num_ref_idx_l0_default_active;
959  if (sh->slice_type == HEVC_SLICE_B)
960  sh->nb_refs[L1] = pps->num_ref_idx_l1_default_active;
961 
962  if (get_bits1(gb)) { // num_ref_idx_active_override_flag
963  sh->nb_refs[L0] = get_ue_golomb_31(gb) + 1;
964  if (sh->slice_type == HEVC_SLICE_B)
965  sh->nb_refs[L1] = get_ue_golomb_31(gb) + 1;
966  }
967  if (sh->nb_refs[L0] >= HEVC_MAX_REFS || sh->nb_refs[L1] >= HEVC_MAX_REFS) {
968  av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
969  sh->nb_refs[L0], sh->nb_refs[L1]);
970  return AVERROR_INVALIDDATA;
971  }
972 
973  sh->rpl_modification_flag[0] = 0;
974  sh->rpl_modification_flag[1] = 0;
975  nb_refs = ff_hevc_frame_nb_refs(sh, pps, layer_idx);
976  if (!nb_refs) {
977  av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
978  return AVERROR_INVALIDDATA;
979  }
980 
981  if (pps->lists_modification_present_flag && nb_refs > 1) {
982  sh->rpl_modification_flag[0] = get_bits1(gb);
983  if (sh->rpl_modification_flag[0]) {
984  for (i = 0; i < sh->nb_refs[L0]; i++)
985  sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
986  }
987 
988  if (sh->slice_type == HEVC_SLICE_B) {
989  sh->rpl_modification_flag[1] = get_bits1(gb);
990  if (sh->rpl_modification_flag[1] == 1)
991  for (i = 0; i < sh->nb_refs[L1]; i++)
992  sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
993  }
994  }
995 
996  if (sh->slice_type == HEVC_SLICE_B)
997  sh->mvd_l1_zero_flag = get_bits1(gb);
998 
999  if (pps->cabac_init_present_flag)
1000  sh->cabac_init_flag = get_bits1(gb);
1001  else
1002  sh->cabac_init_flag = 0;
1003 
1004  sh->collocated_ref_idx = 0;
1006  sh->collocated_list = L0;
1007  if (sh->slice_type == HEVC_SLICE_B)
1008  sh->collocated_list = !get_bits1(gb);
1009 
1010  if (sh->nb_refs[sh->collocated_list] > 1) {
1012  if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
1013  av_log(s->avctx, AV_LOG_ERROR,
1014  "Invalid collocated_ref_idx: %d.\n",
1015  sh->collocated_ref_idx);
1016  return AVERROR_INVALIDDATA;
1017  }
1018  }
1019  }
1020 
1021  if ((pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
1022  (pps->weighted_bipred_flag && sh->slice_type == HEVC_SLICE_B)) {
1023  ret = pred_weight_table(sh, s->avctx, sps, gb);
1024  if (ret < 0)
1025  return ret;
1026  }
1027 
1028  sh->max_num_merge_cand = 5 - get_ue_golomb_long(gb);
1029  if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
1030  av_log(s->avctx, AV_LOG_ERROR,
1031  "Invalid number of merging MVP candidates: %d.\n",
1032  sh->max_num_merge_cand);
1033  return AVERROR_INVALIDDATA;
1034  }
1035 
1036  // Syntax in 7.3.6.1
1037  if (sps->motion_vector_resolution_control_idc == 2)
1038  sh->use_integer_mv_flag = get_bits1(gb);
1039  else
1040  // Inferred to be equal to motion_vector_resolution_control_idc if not present
1041  sh->use_integer_mv_flag = sps->motion_vector_resolution_control_idc;
1042 
1043  }
1044 
1045  sh->slice_qp_delta = get_se_golomb(gb);
1046 
1047  if (pps->pic_slice_level_chroma_qp_offsets_present_flag) {
1050  if (sh->slice_cb_qp_offset < -12 || sh->slice_cb_qp_offset > 12 ||
1051  sh->slice_cr_qp_offset < -12 || sh->slice_cr_qp_offset > 12) {
1052  av_log(s->avctx, AV_LOG_ERROR, "Invalid slice cx qp offset.\n");
1053  return AVERROR_INVALIDDATA;
1054  }
1055  } else {
1056  sh->slice_cb_qp_offset = 0;
1057  sh->slice_cr_qp_offset = 0;
1058  }
1059 
1060  if (pps->pps_slice_act_qp_offsets_present_flag) {
1064  }
1065 
1066  if (pps->chroma_qp_offset_list_enabled_flag)
1068  else
1070 
1071  if (pps->deblocking_filter_control_present_flag) {
1072  int deblocking_filter_override_flag = 0;
1073 
1074  if (pps->deblocking_filter_override_enabled_flag)
1075  deblocking_filter_override_flag = get_bits1(gb);
1076 
1077  if (deblocking_filter_override_flag) {
1079  if (!sh->disable_deblocking_filter_flag) {
1080  int beta_offset_div2 = get_se_golomb(gb);
1081  int tc_offset_div2 = get_se_golomb(gb) ;
1082  if (beta_offset_div2 < -6 || beta_offset_div2 > 6 ||
1083  tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1084  av_log(s->avctx, AV_LOG_ERROR,
1085  "Invalid deblock filter offsets: %d, %d\n",
1086  beta_offset_div2, tc_offset_div2);
1087  return AVERROR_INVALIDDATA;
1088  }
1089  sh->beta_offset = beta_offset_div2 * 2;
1090  sh->tc_offset = tc_offset_div2 * 2;
1091  }
1092  } else {
1093  sh->disable_deblocking_filter_flag = pps->disable_dbf;
1094  sh->beta_offset = pps->beta_offset;
1095  sh->tc_offset = pps->tc_offset;
1096  }
1097  } else {
1099  sh->beta_offset = 0;
1100  sh->tc_offset = 0;
1101  }
1102 
1103  if (pps->seq_loop_filter_across_slices_enabled_flag &&
1108  } else {
1109  sh->slice_loop_filter_across_slices_enabled_flag = pps->seq_loop_filter_across_slices_enabled_flag;
1110  }
1111  }
1112 
1113  sh->num_entry_point_offsets = 0;
1114  if (pps->tiles_enabled_flag || pps->entropy_coding_sync_enabled_flag) {
1115  unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
1116  // It would be possible to bound this tighter but this here is simpler
1117  if (num_entry_point_offsets > get_bits_left(gb) || num_entry_point_offsets > UINT16_MAX) {
1118  av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
1119  return AVERROR_INVALIDDATA;
1120  }
1121 
1122  sh->num_entry_point_offsets = num_entry_point_offsets;
1123  if (sh->num_entry_point_offsets > 0) {
1124  int offset_len = get_ue_golomb_long(gb) + 1;
1125 
1126  if (offset_len < 1 || offset_len > 32) {
1127  sh->num_entry_point_offsets = 0;
1128  av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
1129  return AVERROR_INVALIDDATA;
1130  }
1131 
1133  av_freep(&sh->offset);
1134  av_freep(&sh->size);
1135  sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
1136  sh->offset = av_malloc_array(sh->num_entry_point_offsets + 1, sizeof(int));
1137  sh->size = av_malloc_array(sh->num_entry_point_offsets + 1, sizeof(int));
1138  if (!sh->entry_point_offset || !sh->offset || !sh->size) {
1139  sh->num_entry_point_offsets = 0;
1140  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
1141  return AVERROR(ENOMEM);
1142  }
1143  for (i = 0; i < sh->num_entry_point_offsets; i++) {
1144  unsigned val = get_bits_long(gb, offset_len);
1145  sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
1146  }
1147  }
1148  }
1149 
1150  if (pps->slice_header_extension_present_flag) {
1151  unsigned int length = get_ue_golomb_long(gb);
1152  if (length*8LL > get_bits_left(gb)) {
1153  av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
1154  return AVERROR_INVALIDDATA;
1155  }
1156  for (i = 0; i < length; i++)
1157  skip_bits(gb, 8); // slice_header_extension_data_byte
1158  }
1159 
1160  ret = get_bits1(gb);
1161  if (!ret && get_bits_left(gb) >= 0) {
1162  av_log(s->avctx, AV_LOG_ERROR, "alignment_bit_equal_to_one=0\n");
1163  return AVERROR_INVALIDDATA;
1164  }
1165  sh->data_offset = align_get_bits(gb) - gb->buffer;
1166 
1167  if (get_bits_left(gb) < 0) {
1168  av_log(s->avctx, AV_LOG_ERROR,
1169  "Overread slice header by %d bits\n", -get_bits_left(gb));
1170  return AVERROR_INVALIDDATA;
1171  }
1172 
1173  // Inferred parameters
1174  sh->slice_qp = 26U + pps->pic_init_qp_minus26 + sh->slice_qp_delta;
1175  if (sh->slice_qp > 51 ||
1176  sh->slice_qp < -sps->qp_bd_offset) {
1177  av_log(s->avctx, AV_LOG_ERROR,
1178  "The slice_qp %d is outside the valid range "
1179  "[%d, 51].\n",
1180  sh->slice_qp,
1181  -sps->qp_bd_offset);
1182  return AVERROR_INVALIDDATA;
1183  }
1184 
1186 
1187  if (sh->dependent_slice_segment_flag &&
1188  (!sh->slice_ctb_addr_rs || !pps->ctb_addr_rs_to_ts[sh->slice_ctb_addr_rs])) {
1189  av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
1190  return AVERROR_INVALIDDATA;
1191  }
1192 
1193  return 0;
1194 }
1195 
1196 #define CTB(tab, x, y) ((tab)[(y) * sps->ctb_width + (x)])
1197 
1198 #define SET_SAO(elem, value) \
1199 do { \
1200  if (!sao_merge_up_flag && !sao_merge_left_flag) \
1201  sao->elem = value; \
1202  else if (sao_merge_left_flag) \
1203  sao->elem = CTB(l->sao, rx-1, ry).elem; \
1204  else if (sao_merge_up_flag) \
1205  sao->elem = CTB(l->sao, rx, ry-1).elem; \
1206  else \
1207  sao->elem = 0; \
1208 } while (0)
1209 
1211  const HEVCPPS *pps, const HEVCSPS *sps,
1212  int rx, int ry)
1213 {
1214  const HEVCContext *const s = lc->parent;
1215  int sao_merge_left_flag = 0;
1216  int sao_merge_up_flag = 0;
1217  SAOParams *sao = &CTB(l->sao, rx, ry);
1218  int c_idx, i;
1219 
1220  if (s->sh.slice_sample_adaptive_offset_flag[0] ||
1221  s->sh.slice_sample_adaptive_offset_flag[1]) {
1222  if (rx > 0) {
1223  if (lc->ctb_left_flag)
1224  sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(lc);
1225  }
1226  if (ry > 0 && !sao_merge_left_flag) {
1227  if (lc->ctb_up_flag)
1228  sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(lc);
1229  }
1230  }
1231 
1232  for (c_idx = 0; c_idx < (sps->chroma_format_idc ? 3 : 1); c_idx++) {
1233  int log2_sao_offset_scale = c_idx == 0 ? pps->log2_sao_offset_scale_luma :
1234  pps->log2_sao_offset_scale_chroma;
1235 
1236  if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
1237  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
1238  continue;
1239  }
1240 
1241  if (c_idx == 2) {
1242  sao->type_idx[2] = sao->type_idx[1];
1243  sao->eo_class[2] = sao->eo_class[1];
1244  } else {
1245  SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(lc));
1246  }
1247 
1248  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
1249  continue;
1250 
1251  for (i = 0; i < 4; i++)
1252  SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(lc, sps->bit_depth));
1253 
1254  if (sao->type_idx[c_idx] == SAO_BAND) {
1255  for (i = 0; i < 4; i++) {
1256  if (sao->offset_abs[c_idx][i]) {
1257  SET_SAO(offset_sign[c_idx][i],
1259  } else {
1260  sao->offset_sign[c_idx][i] = 0;
1261  }
1262  }
1263  SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(lc));
1264  } else if (c_idx != 2) {
1265  SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(lc));
1266  }
1267 
1268  // Inferred parameters
1269  sao->offset_val[c_idx][0] = 0;
1270  for (i = 0; i < 4; i++) {
1271  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
1272  if (sao->type_idx[c_idx] == SAO_EDGE) {
1273  if (i > 1)
1274  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1275  } else if (sao->offset_sign[c_idx][i]) {
1276  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
1277  }
1278  sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
1279  }
1280  }
1281 }
1282 
1283 #undef SET_SAO
1284 #undef CTB
1285 
1287 {
1288  int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(lc, idx);
1289 
1290  if (log2_res_scale_abs_plus1 != 0) {
1291  int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(lc, idx);
1292  lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
1293  (1 - 2 * res_scale_sign_flag);
1294  } else {
1295  lc->tu.res_scale_val = 0;
1296  }
1297 
1298 
1299  return 0;
1300 }
1301 
1303  const HEVCLayerContext *l,
1304  const HEVCPPS *pps, const HEVCSPS *sps,
1305  int x0, int y0,
1306  int xBase, int yBase, int cb_xBase, int cb_yBase,
1307  int log2_cb_size, int log2_trafo_size,
1308  int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
1309 {
1310  const HEVCContext *const s = lc->parent;
1311  const int log2_trafo_size_c = log2_trafo_size - sps->hshift[1];
1312  int i;
1313 
1314  if (lc->cu.pred_mode == MODE_INTRA) {
1315  int trafo_size = 1 << log2_trafo_size;
1316  ff_hevc_set_neighbour_available(lc, x0, y0, trafo_size, trafo_size, sps->log2_ctb_size);
1317 
1318  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, x0, y0, 0);
1319  }
1320 
1321  if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
1322  (sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1323  int scan_idx = SCAN_DIAG;
1324  int scan_idx_c = SCAN_DIAG;
1325  int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
1326  (sps->chroma_format_idc == 2 &&
1327  (cbf_cb[1] || cbf_cr[1]));
1328 
1329  if (pps->cu_qp_delta_enabled_flag && !lc->tu.is_cu_qp_delta_coded) {
1331  if (lc->tu.cu_qp_delta != 0)
1332  if (ff_hevc_cu_qp_delta_sign_flag(lc) == 1)
1333  lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1334  lc->tu.is_cu_qp_delta_coded = 1;
1335 
1336  if (lc->tu.cu_qp_delta < -(26 + sps->qp_bd_offset / 2) ||
1337  lc->tu.cu_qp_delta > (25 + sps->qp_bd_offset / 2)) {
1338  av_log(s->avctx, AV_LOG_ERROR,
1339  "The cu_qp_delta %d is outside the valid range "
1340  "[%d, %d].\n",
1341  lc->tu.cu_qp_delta,
1342  -(26 + sps->qp_bd_offset / 2),
1343  (25 + sps->qp_bd_offset / 2));
1344  return AVERROR_INVALIDDATA;
1345  }
1346 
1347  ff_hevc_set_qPy(lc, l, pps, cb_xBase, cb_yBase, log2_cb_size);
1348  }
1349 
1350  if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1352  int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(lc);
1353  if (cu_chroma_qp_offset_flag) {
1354  int cu_chroma_qp_offset_idx = 0;
1355  if (pps->chroma_qp_offset_list_len_minus1 > 0) {
1356  cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(lc, pps->chroma_qp_offset_list_len_minus1);
1357  av_log(s->avctx, AV_LOG_ERROR,
1358  "cu_chroma_qp_offset_idx not yet tested.\n");
1359  }
1360  lc->tu.cu_qp_offset_cb = pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1361  lc->tu.cu_qp_offset_cr = pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1362  } else {
1363  lc->tu.cu_qp_offset_cb = 0;
1364  lc->tu.cu_qp_offset_cr = 0;
1365  }
1367  }
1368 
1369  if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1370  if (lc->tu.intra_pred_mode >= 6 &&
1371  lc->tu.intra_pred_mode <= 14) {
1372  scan_idx = SCAN_VERT;
1373  } else if (lc->tu.intra_pred_mode >= 22 &&
1374  lc->tu.intra_pred_mode <= 30) {
1375  scan_idx = SCAN_HORIZ;
1376  }
1377 
1378  if (lc->tu.intra_pred_mode_c >= 6 &&
1379  lc->tu.intra_pred_mode_c <= 14) {
1380  scan_idx_c = SCAN_VERT;
1381  } else if (lc->tu.intra_pred_mode_c >= 22 &&
1382  lc->tu.intra_pred_mode_c <= 30) {
1383  scan_idx_c = SCAN_HORIZ;
1384  }
1385  }
1386 
1387  lc->tu.cross_pf = 0;
1388 
1389  if (cbf_luma)
1390  ff_hevc_hls_residual_coding(lc, pps, x0, y0, log2_trafo_size, scan_idx, 0);
1391  if (sps->chroma_format_idc && (log2_trafo_size > 2 || sps->chroma_format_idc == 3)) {
1392  int trafo_size_h = 1 << (log2_trafo_size_c + sps->hshift[1]);
1393  int trafo_size_v = 1 << (log2_trafo_size_c + sps->vshift[1]);
1394  lc->tu.cross_pf = (pps->cross_component_prediction_enabled_flag && cbf_luma &&
1395  (lc->cu.pred_mode == MODE_INTER ||
1396  (lc->tu.chroma_mode_c == 4)));
1397 
1398  if (lc->tu.cross_pf) {
1399  hls_cross_component_pred(lc, 0);
1400  }
1401  for (i = 0; i < (sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1402  if (lc->cu.pred_mode == MODE_INTRA) {
1403  ff_hevc_set_neighbour_available(lc, x0, y0 + (i << log2_trafo_size_c),
1404  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1405  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0 + (i << log2_trafo_size_c), 1);
1406  }
1407  if (cbf_cb[i])
1408  ff_hevc_hls_residual_coding(lc, pps, x0, y0 + (i << log2_trafo_size_c),
1409  log2_trafo_size_c, scan_idx_c, 1);
1410  else
1411  if (lc->tu.cross_pf) {
1412  ptrdiff_t stride = s->cur_frame->f->linesize[1];
1413  int hshift = sps->hshift[1];
1414  int vshift = sps->vshift[1];
1415  const int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1416  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1417  int size = 1 << log2_trafo_size_c;
1418 
1419  uint8_t *dst = &s->cur_frame->f->data[1][(y0 >> vshift) * stride +
1420  ((x0 >> hshift) << sps->pixel_shift)];
1421  for (i = 0; i < (size * size); i++) {
1422  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1423  }
1424  s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1425  }
1426  }
1427 
1428  if (lc->tu.cross_pf) {
1429  hls_cross_component_pred(lc, 1);
1430  }
1431  for (i = 0; i < (sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1432  if (lc->cu.pred_mode == MODE_INTRA) {
1433  ff_hevc_set_neighbour_available(lc, x0, y0 + (i << log2_trafo_size_c),
1434  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1435  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0 + (i << log2_trafo_size_c), 2);
1436  }
1437  if (cbf_cr[i])
1438  ff_hevc_hls_residual_coding(lc, pps, x0, y0 + (i << log2_trafo_size_c),
1439  log2_trafo_size_c, scan_idx_c, 2);
1440  else
1441  if (lc->tu.cross_pf) {
1442  ptrdiff_t stride = s->cur_frame->f->linesize[2];
1443  int hshift = sps->hshift[2];
1444  int vshift = sps->vshift[2];
1445  const int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1446  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1447  int size = 1 << log2_trafo_size_c;
1448 
1449  uint8_t *dst = &s->cur_frame->f->data[2][(y0 >> vshift) * stride +
1450  ((x0 >> hshift) << sps->pixel_shift)];
1451  for (i = 0; i < (size * size); i++) {
1452  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1453  }
1454  s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1455  }
1456  }
1457  } else if (sps->chroma_format_idc && blk_idx == 3) {
1458  int trafo_size_h = 1 << (log2_trafo_size + 1);
1459  int trafo_size_v = 1 << (log2_trafo_size + sps->vshift[1]);
1460  for (i = 0; i < (sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1461  if (lc->cu.pred_mode == MODE_INTRA) {
1462  ff_hevc_set_neighbour_available(lc, xBase, yBase + (i << log2_trafo_size),
1463  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1464  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase + (i << log2_trafo_size), 1);
1465  }
1466  if (cbf_cb[i])
1467  ff_hevc_hls_residual_coding(lc, pps, xBase, yBase + (i << log2_trafo_size),
1468  log2_trafo_size, scan_idx_c, 1);
1469  }
1470  for (i = 0; i < (sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1471  if (lc->cu.pred_mode == MODE_INTRA) {
1472  ff_hevc_set_neighbour_available(lc, xBase, yBase + (i << log2_trafo_size),
1473  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1474  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase + (i << log2_trafo_size), 2);
1475  }
1476  if (cbf_cr[i])
1477  ff_hevc_hls_residual_coding(lc, pps, xBase, yBase + (i << log2_trafo_size),
1478  log2_trafo_size, scan_idx_c, 2);
1479  }
1480  }
1481  } else if (sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1482  if (log2_trafo_size > 2 || sps->chroma_format_idc == 3) {
1483  int trafo_size_h = 1 << (log2_trafo_size_c + sps->hshift[1]);
1484  int trafo_size_v = 1 << (log2_trafo_size_c + sps->vshift[1]);
1485  ff_hevc_set_neighbour_available(lc, x0, y0, trafo_size_h, trafo_size_v,
1486  sps->log2_ctb_size);
1487  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0, 1);
1488  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0, 2);
1489  if (sps->chroma_format_idc == 2) {
1490  ff_hevc_set_neighbour_available(lc, x0, y0 + (1 << log2_trafo_size_c),
1491  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1492  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0 + (1 << log2_trafo_size_c), 1);
1493  s->hpc.intra_pred[log2_trafo_size_c - 2](lc, pps, x0, y0 + (1 << log2_trafo_size_c), 2);
1494  }
1495  } else if (blk_idx == 3) {
1496  int trafo_size_h = 1 << (log2_trafo_size + 1);
1497  int trafo_size_v = 1 << (log2_trafo_size + sps->vshift[1]);
1498  ff_hevc_set_neighbour_available(lc, xBase, yBase,
1499  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1500  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase, 1);
1501  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase, 2);
1502  if (sps->chroma_format_idc == 2) {
1503  ff_hevc_set_neighbour_available(lc, xBase, yBase + (1 << log2_trafo_size),
1504  trafo_size_h, trafo_size_v, sps->log2_ctb_size);
1505  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase + (1 << log2_trafo_size), 1);
1506  s->hpc.intra_pred[log2_trafo_size - 2](lc, pps, xBase, yBase + (1 << log2_trafo_size), 2);
1507  }
1508  }
1509  }
1510 
1511  return 0;
1512 }
1513 
1514 static void set_deblocking_bypass(uint8_t *is_pcm, const HEVCSPS *sps,
1515  int x0, int y0, int log2_cb_size)
1516 {
1517  int cb_size = 1 << log2_cb_size;
1518  int log2_min_pu_size = sps->log2_min_pu_size;
1519 
1520  int min_pu_width = sps->min_pu_width;
1521  int x_end = FFMIN(x0 + cb_size, sps->width);
1522  int y_end = FFMIN(y0 + cb_size, sps->height);
1523  int i, j;
1524 
1525  for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1526  for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1527  is_pcm[i + j * min_pu_width] = 2;
1528 }
1529 
1531  const HEVCLayerContext *l,
1532  const HEVCPPS *pps, const HEVCSPS *sps,
1533  int x0, int y0,
1534  int xBase, int yBase, int cb_xBase, int cb_yBase,
1535  int log2_cb_size, int log2_trafo_size,
1536  int trafo_depth, int blk_idx,
1537  const int *base_cbf_cb, const int *base_cbf_cr)
1538 {
1539  const HEVCContext *const s = lc->parent;
1540  uint8_t split_transform_flag;
1541  int cbf_cb[2];
1542  int cbf_cr[2];
1543  int ret;
1544 
1545  cbf_cb[0] = base_cbf_cb[0];
1546  cbf_cb[1] = base_cbf_cb[1];
1547  cbf_cr[0] = base_cbf_cr[0];
1548  cbf_cr[1] = base_cbf_cr[1];
1549 
1550  if (lc->cu.intra_split_flag) {
1551  if (trafo_depth == 1) {
1552  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1553  if (sps->chroma_format_idc == 3) {
1554  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1555  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1556  } else {
1558  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1559  }
1560  }
1561  } else {
1562  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1564  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1565  }
1566 
1567  if (log2_trafo_size <= sps->log2_max_trafo_size &&
1568  log2_trafo_size > sps->log2_min_tb_size &&
1569  trafo_depth < lc->cu.max_trafo_depth &&
1570  !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1571  split_transform_flag = ff_hevc_split_transform_flag_decode(lc, log2_trafo_size);
1572  } else {
1573  int inter_split = sps->max_transform_hierarchy_depth_inter == 0 &&
1574  lc->cu.pred_mode == MODE_INTER &&
1575  lc->cu.part_mode != PART_2Nx2N &&
1576  trafo_depth == 0;
1577 
1578  split_transform_flag = log2_trafo_size > sps->log2_max_trafo_size ||
1579  (lc->cu.intra_split_flag && trafo_depth == 0) ||
1580  inter_split;
1581  }
1582 
1583  if (sps->chroma_format_idc && (log2_trafo_size > 2 || sps->chroma_format_idc == 3)) {
1584  if (trafo_depth == 0 || cbf_cb[0]) {
1585  cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
1586  if (sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1587  cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
1588  }
1589  }
1590 
1591  if (trafo_depth == 0 || cbf_cr[0]) {
1592  cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
1593  if (sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1594  cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(lc, trafo_depth);
1595  }
1596  }
1597  }
1598 
1599  if (split_transform_flag) {
1600  const int trafo_size_split = 1 << (log2_trafo_size - 1);
1601  const int x1 = x0 + trafo_size_split;
1602  const int y1 = y0 + trafo_size_split;
1603 
1604 #define SUBDIVIDE(x, y, idx) \
1605 do { \
1606  ret = hls_transform_tree(lc, l, pps, sps, \
1607  x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1608  log2_trafo_size - 1, trafo_depth + 1, idx, \
1609  cbf_cb, cbf_cr); \
1610  if (ret < 0) \
1611  return ret; \
1612 } while (0)
1613 
1614  SUBDIVIDE(x0, y0, 0);
1615  SUBDIVIDE(x1, y0, 1);
1616  SUBDIVIDE(x0, y1, 2);
1617  SUBDIVIDE(x1, y1, 3);
1618 
1619 #undef SUBDIVIDE
1620  } else {
1621  int min_tu_size = 1 << sps->log2_min_tb_size;
1622  int log2_min_tu_size = sps->log2_min_tb_size;
1623  int min_tu_width = sps->min_tb_width;
1624  int cbf_luma = 1;
1625 
1626  if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1627  cbf_cb[0] || cbf_cr[0] ||
1628  (sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1629  cbf_luma = ff_hevc_cbf_luma_decode(lc, trafo_depth);
1630  }
1631 
1632  ret = hls_transform_unit(lc, l, pps, sps,
1633  x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1634  log2_cb_size, log2_trafo_size,
1635  blk_idx, cbf_luma, cbf_cb, cbf_cr);
1636  if (ret < 0)
1637  return ret;
1638  // TODO: store cbf_luma somewhere else
1639  if (cbf_luma) {
1640  int i, j;
1641  for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1642  for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1643  int x_tu = (x0 + j) >> log2_min_tu_size;
1644  int y_tu = (y0 + i) >> log2_min_tu_size;
1645  l->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1646  }
1647  }
1648  if (!s->sh.disable_deblocking_filter_flag) {
1649  ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_trafo_size);
1650  if (pps->transquant_bypass_enable_flag &&
1652  set_deblocking_bypass(l->is_pcm, sps, x0, y0, log2_trafo_size);
1653  }
1654  }
1655  return 0;
1656 }
1657 
1659  const HEVCPPS *pps, int x0, int y0, int log2_cb_size)
1660 {
1661  const HEVCContext *const s = lc->parent;
1662  const HEVCSPS *const sps = pps->sps;
1663  GetBitContext gb;
1664  int cb_size = 1 << log2_cb_size;
1665  ptrdiff_t stride0 = s->cur_frame->f->linesize[0];
1666  uint8_t *dst0 = &s->cur_frame->f->data[0][y0 * stride0 + (x0 << sps->pixel_shift)];
1667 
1668  int length = cb_size * cb_size * sps->pcm.bit_depth + (sps->chroma_format_idc != 0 ?
1669  (((cb_size >> sps->hshift[1]) * (cb_size >> sps->vshift[1])) +
1670  ((cb_size >> sps->hshift[2]) * (cb_size >> sps->vshift[2]))) *
1671  sps->pcm.bit_depth_chroma : 0);
1672  const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1673  int ret;
1674 
1675  if (!s->sh.disable_deblocking_filter_flag)
1676  ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size);
1677 
1678  ret = init_get_bits(&gb, pcm, length);
1679  if (ret < 0)
1680  return ret;
1681 
1682  s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, sps->pcm.bit_depth);
1683  if (sps->chroma_format_idc) {
1684  ptrdiff_t stride1 = s->cur_frame->f->linesize[1];
1685  ptrdiff_t stride2 = s->cur_frame->f->linesize[2];
1686  uint8_t *dst1 = &s->cur_frame->f->data[1][(y0 >> sps->vshift[1]) * stride1 + ((x0 >> sps->hshift[1]) << sps->pixel_shift)];
1687  uint8_t *dst2 = &s->cur_frame->f->data[2][(y0 >> sps->vshift[2]) * stride2 + ((x0 >> sps->hshift[2]) << sps->pixel_shift)];
1688 
1689  s->hevcdsp.put_pcm(dst1, stride1,
1690  cb_size >> sps->hshift[1],
1691  cb_size >> sps->vshift[1],
1692  &gb, sps->pcm.bit_depth_chroma);
1693  s->hevcdsp.put_pcm(dst2, stride2,
1694  cb_size >> sps->hshift[2],
1695  cb_size >> sps->vshift[2],
1696  &gb, sps->pcm.bit_depth_chroma);
1697  }
1698 
1699  return 0;
1700 }
1701 
1702 /**
1703  * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1704  *
1705  * @param s HEVC decoding context
1706  * @param dst target buffer for block data at block position
1707  * @param dststride stride of the dst buffer
1708  * @param ref reference picture buffer at origin (0, 0)
1709  * @param mv motion vector (relative to block position) to get pixel data from
1710  * @param x_off horizontal position of block from origin (0, 0)
1711  * @param y_off vertical position of block from origin (0, 0)
1712  * @param block_w width of block
1713  * @param block_h height of block
1714  * @param luma_weight weighting factor applied to the luma prediction
1715  * @param luma_offset additive offset applied to the luma prediction value
1716  */
1717 
1719  const HEVCPPS *pps, const HEVCSPS *sps,
1720  uint8_t *dst, ptrdiff_t dststride,
1721  const AVFrame *ref, const Mv *mv, int x_off, int y_off,
1722  int block_w, int block_h, int luma_weight, int luma_offset)
1723 {
1724  const HEVCContext *const s = lc->parent;
1725  const uint8_t *src = ref->data[0];
1726  ptrdiff_t srcstride = ref->linesize[0];
1727  int pic_width = sps->width;
1728  int pic_height = sps->height;
1729  int mx = mv->x & 3;
1730  int my = mv->y & 3;
1731  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) ||
1732  (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag);
1733  int idx = hevc_pel_weight[block_w];
1734 
1735  x_off += mv->x >> 2;
1736  y_off += mv->y >> 2;
1737  src += y_off * srcstride + (x_off * (1 << sps->pixel_shift));
1738 
1739  if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1740  x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1741  y_off >= pic_height - block_h - QPEL_EXTRA_AFTER ||
1742  ref == s->cur_frame->f) {
1743  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
1744  int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1745  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1746 
1747  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1748  edge_emu_stride, srcstride,
1749  block_w + QPEL_EXTRA,
1750  block_h + QPEL_EXTRA,
1751  x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1752  pic_width, pic_height);
1753  src = lc->edge_emu_buffer + buf_offset;
1754  srcstride = edge_emu_stride;
1755  }
1756 
1757  if (!weight_flag)
1758  s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1759  block_h, mx, my, block_w);
1760  else
1761  s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1762  block_h, s->sh.luma_log2_weight_denom,
1763  luma_weight, luma_offset, mx, my, block_w);
1764 }
1765 
1766 /**
1767  * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1768  *
1769  * @param s HEVC decoding context
1770  * @param dst target buffer for block data at block position
1771  * @param dststride stride of the dst buffer
1772  * @param ref0 reference picture0 buffer at origin (0, 0)
1773  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1774  * @param x_off horizontal position of block from origin (0, 0)
1775  * @param y_off vertical position of block from origin (0, 0)
1776  * @param block_w width of block
1777  * @param block_h height of block
1778  * @param ref1 reference picture1 buffer at origin (0, 0)
1779  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1780  * @param current_mv current motion vector structure
1781  */
1783  const HEVCPPS *pps, const HEVCSPS *sps,
1784  uint8_t *dst, ptrdiff_t dststride,
1785  const AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1786  int block_w, int block_h, const AVFrame *ref1,
1787  const Mv *mv1, struct MvField *current_mv)
1788 {
1789  const HEVCContext *const s = lc->parent;
1790  ptrdiff_t src0stride = ref0->linesize[0];
1791  ptrdiff_t src1stride = ref1->linesize[0];
1792  int pic_width = sps->width;
1793  int pic_height = sps->height;
1794  int mx0 = mv0->x & 3;
1795  int my0 = mv0->y & 3;
1796  int mx1 = mv1->x & 3;
1797  int my1 = mv1->y & 3;
1798  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) ||
1799  (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag);
1800  int x_off0 = x_off + (mv0->x >> 2);
1801  int y_off0 = y_off + (mv0->y >> 2);
1802  int x_off1 = x_off + (mv1->x >> 2);
1803  int y_off1 = y_off + (mv1->y >> 2);
1804  int idx = hevc_pel_weight[block_w];
1805 
1806  const uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << sps->pixel_shift);
1807  const uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << sps->pixel_shift);
1808 
1809  if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1810  x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1811  y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1812  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
1813  int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1814  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1815 
1816  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1817  edge_emu_stride, src0stride,
1818  block_w + QPEL_EXTRA,
1819  block_h + QPEL_EXTRA,
1820  x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1821  pic_width, pic_height);
1822  src0 = lc->edge_emu_buffer + buf_offset;
1823  src0stride = edge_emu_stride;
1824  }
1825 
1826  if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1827  x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1828  y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1829  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
1830  int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1831  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << sps->pixel_shift);
1832 
1833  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1834  edge_emu_stride, src1stride,
1835  block_w + QPEL_EXTRA,
1836  block_h + QPEL_EXTRA,
1837  x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1838  pic_width, pic_height);
1839  src1 = lc->edge_emu_buffer2 + buf_offset;
1840  src1stride = edge_emu_stride;
1841  }
1842 
1843  s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1844  block_h, mx0, my0, block_w);
1845  if (!weight_flag)
1846  s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1847  block_h, mx1, my1, block_w);
1848  else
1849  s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1850  block_h, s->sh.luma_log2_weight_denom,
1851  s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1852  s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1853  s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1854  s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1855  mx1, my1, block_w);
1856 
1857 }
1858 
1859 /**
1860  * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1861  *
1862  * @param s HEVC decoding context
1863  * @param dst1 target buffer for block data at block position (U plane)
1864  * @param dst2 target buffer for block data at block position (V plane)
1865  * @param dststride stride of the dst1 and dst2 buffers
1866  * @param ref reference picture buffer at origin (0, 0)
1867  * @param mv motion vector (relative to block position) to get pixel data from
1868  * @param x_off horizontal position of block from origin (0, 0)
1869  * @param y_off vertical position of block from origin (0, 0)
1870  * @param block_w width of block
1871  * @param block_h height of block
1872  * @param chroma_weight weighting factor applied to the chroma prediction
1873  * @param chroma_offset additive offset applied to the chroma prediction value
1874  */
1875 
1877  const HEVCPPS *pps, const HEVCSPS *sps,
1878  uint8_t *dst0,
1879  ptrdiff_t dststride, const uint8_t *src0, ptrdiff_t srcstride, int reflist,
1880  int x_off, int y_off, int block_w, int block_h,
1881  const struct MvField *current_mv, int chroma_weight, int chroma_offset)
1882 {
1883  const HEVCContext *const s = lc->parent;
1884  int pic_width = sps->width >> sps->hshift[1];
1885  int pic_height = sps->height >> sps->vshift[1];
1886  const Mv *mv = &current_mv->mv[reflist];
1887  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) ||
1888  (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag);
1889  int idx = hevc_pel_weight[block_w];
1890  int hshift = sps->hshift[1];
1891  int vshift = sps->vshift[1];
1892  intptr_t mx = av_zero_extend(mv->x, 2 + hshift);
1893  intptr_t my = av_zero_extend(mv->y, 2 + vshift);
1894  intptr_t _mx = mx << (1 - hshift);
1895  intptr_t _my = my << (1 - vshift);
1896  int emu = src0 == s->cur_frame->f->data[1] || src0 == s->cur_frame->f->data[2];
1897 
1898  x_off += mv->x >> (2 + hshift);
1899  y_off += mv->y >> (2 + vshift);
1900  src0 += y_off * srcstride + (x_off * (1 << sps->pixel_shift));
1901 
1902  if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1903  x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1904  y_off >= pic_height - block_h - EPEL_EXTRA_AFTER ||
1905  emu) {
1906  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
1907  int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << sps->pixel_shift));
1908  int buf_offset0 = EPEL_EXTRA_BEFORE *
1909  (edge_emu_stride + (1 << sps->pixel_shift));
1910  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1911  edge_emu_stride, srcstride,
1912  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1913  x_off - EPEL_EXTRA_BEFORE,
1914  y_off - EPEL_EXTRA_BEFORE,
1915  pic_width, pic_height);
1916 
1917  src0 = lc->edge_emu_buffer + buf_offset0;
1918  srcstride = edge_emu_stride;
1919  }
1920  if (!weight_flag)
1921  s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1922  block_h, _mx, _my, block_w);
1923  else
1924  s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1925  block_h, s->sh.chroma_log2_weight_denom,
1926  chroma_weight, chroma_offset, _mx, _my, block_w);
1927 }
1928 
1929 /**
1930  * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1931  *
1932  * @param s HEVC decoding context
1933  * @param dst target buffer for block data at block position
1934  * @param dststride stride of the dst buffer
1935  * @param ref0 reference picture0 buffer at origin (0, 0)
1936  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1937  * @param x_off horizontal position of block from origin (0, 0)
1938  * @param y_off vertical position of block from origin (0, 0)
1939  * @param block_w width of block
1940  * @param block_h height of block
1941  * @param ref1 reference picture1 buffer at origin (0, 0)
1942  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1943  * @param current_mv current motion vector structure
1944  * @param cidx chroma component(cb, cr)
1945  */
1947  const HEVCPPS *pps, const HEVCSPS *sps,
1948  uint8_t *dst0, ptrdiff_t dststride,
1949  const AVFrame *ref0, const AVFrame *ref1,
1950  int x_off, int y_off, int block_w, int block_h, const MvField *current_mv, int cidx)
1951 {
1952  const HEVCContext *const s = lc->parent;
1953  const uint8_t *src1 = ref0->data[cidx+1];
1954  const uint8_t *src2 = ref1->data[cidx+1];
1955  ptrdiff_t src1stride = ref0->linesize[cidx+1];
1956  ptrdiff_t src2stride = ref1->linesize[cidx+1];
1957  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && pps->weighted_pred_flag) ||
1958  (s->sh.slice_type == HEVC_SLICE_B && pps->weighted_bipred_flag);
1959  int pic_width = sps->width >> sps->hshift[1];
1960  int pic_height = sps->height >> sps->vshift[1];
1961  const Mv *const mv0 = &current_mv->mv[0];
1962  const Mv *const mv1 = &current_mv->mv[1];
1963  int hshift = sps->hshift[1];
1964  int vshift = sps->vshift[1];
1965 
1966  intptr_t mx0 = av_zero_extend(mv0->x, 2 + hshift);
1967  intptr_t my0 = av_zero_extend(mv0->y, 2 + vshift);
1968  intptr_t mx1 = av_zero_extend(mv1->x, 2 + hshift);
1969  intptr_t my1 = av_zero_extend(mv1->y, 2 + vshift);
1970  intptr_t _mx0 = mx0 << (1 - hshift);
1971  intptr_t _my0 = my0 << (1 - vshift);
1972  intptr_t _mx1 = mx1 << (1 - hshift);
1973  intptr_t _my1 = my1 << (1 - vshift);
1974 
1975  int x_off0 = x_off + (mv0->x >> (2 + hshift));
1976  int y_off0 = y_off + (mv0->y >> (2 + vshift));
1977  int x_off1 = x_off + (mv1->x >> (2 + hshift));
1978  int y_off1 = y_off + (mv1->y >> (2 + vshift));
1979  int idx = hevc_pel_weight[block_w];
1980  src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << sps->pixel_shift);
1981  src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << sps->pixel_shift);
1982 
1983  if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1984  x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1985  y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1986  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
1987  int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << sps->pixel_shift));
1988  int buf_offset1 = EPEL_EXTRA_BEFORE *
1989  (edge_emu_stride + (1 << sps->pixel_shift));
1990 
1991  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1992  edge_emu_stride, src1stride,
1993  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1994  x_off0 - EPEL_EXTRA_BEFORE,
1995  y_off0 - EPEL_EXTRA_BEFORE,
1996  pic_width, pic_height);
1997 
1998  src1 = lc->edge_emu_buffer + buf_offset1;
1999  src1stride = edge_emu_stride;
2000  }
2001 
2002  if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
2003  x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
2004  y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
2005  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << sps->pixel_shift;
2006  int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << sps->pixel_shift));
2007  int buf_offset1 = EPEL_EXTRA_BEFORE *
2008  (edge_emu_stride + (1 << sps->pixel_shift));
2009 
2010  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
2011  edge_emu_stride, src2stride,
2012  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
2013  x_off1 - EPEL_EXTRA_BEFORE,
2014  y_off1 - EPEL_EXTRA_BEFORE,
2015  pic_width, pic_height);
2016 
2017  src2 = lc->edge_emu_buffer2 + buf_offset1;
2018  src2stride = edge_emu_stride;
2019  }
2020 
2021  s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
2022  block_h, _mx0, _my0, block_w);
2023  if (!weight_flag)
2024  s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->cur_frame->f->linesize[cidx+1],
2025  src2, src2stride, lc->tmp,
2026  block_h, _mx1, _my1, block_w);
2027  else
2028  s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->cur_frame->f->linesize[cidx+1],
2029  src2, src2stride, lc->tmp,
2030  block_h,
2031  s->sh.chroma_log2_weight_denom,
2032  s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
2033  s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
2034  s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
2035  s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
2036  _mx1, _my1, block_w);
2037 }
2038 
2039 static void hevc_await_progress(const HEVCContext *s, const HEVCFrame *ref,
2040  const Mv *mv, int y0, int height)
2041 {
2042  if (s->avctx->active_thread_type == FF_THREAD_FRAME ) {
2043  int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
2044 
2045  ff_progress_frame_await(&ref->tf, y);
2046  }
2047 }
2048 
2050  const HEVCPPS *pps, const HEVCSPS *sps,
2051  int x0, int y0, int nPbW,
2052  int nPbH, int log2_cb_size, int part_idx,
2053  int merge_idx, MvField *mv)
2054 {
2055  const HEVCContext *const s = lc->parent;
2056  enum InterPredIdc inter_pred_idc = PRED_L0;
2057  int mvp_flag;
2058 
2059  ff_hevc_set_neighbour_available(lc, x0, y0, nPbW, nPbH, sps->log2_ctb_size);
2060  mv->pred_flag = 0;
2061  if (s->sh.slice_type == HEVC_SLICE_B)
2062  inter_pred_idc = ff_hevc_inter_pred_idc_decode(lc, nPbW, nPbH);
2063 
2064  if (inter_pred_idc != PRED_L1) {
2065  if (s->sh.nb_refs[L0])
2066  mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L0]);
2067 
2068  mv->pred_flag = PF_L0;
2069  ff_hevc_hls_mvd_coding(lc, x0, y0, 0);
2070  mvp_flag = ff_hevc_mvp_lx_flag_decode(lc);
2071  ff_hevc_luma_mv_mvp_mode(lc, pps, x0, y0, nPbW, nPbH, log2_cb_size,
2072  part_idx, merge_idx, mv, mvp_flag, 0);
2073  mv->mv[0].x += lc->pu.mvd.x;
2074  mv->mv[0].y += lc->pu.mvd.y;
2075  }
2076 
2077  if (inter_pred_idc != PRED_L0) {
2078  if (s->sh.nb_refs[L1])
2079  mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(lc, s->sh.nb_refs[L1]);
2080 
2081  if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
2082  AV_ZERO32(&lc->pu.mvd);
2083  } else {
2084  ff_hevc_hls_mvd_coding(lc, x0, y0, 1);
2085  }
2086 
2087  mv->pred_flag += PF_L1;
2088  mvp_flag = ff_hevc_mvp_lx_flag_decode(lc);
2089  ff_hevc_luma_mv_mvp_mode(lc, pps, x0, y0, nPbW, nPbH, log2_cb_size,
2090  part_idx, merge_idx, mv, mvp_flag, 1);
2091  mv->mv[1].x += lc->pu.mvd.x;
2092  mv->mv[1].y += lc->pu.mvd.y;
2093  }
2094 }
2095 
2097  const HEVCLayerContext *l,
2098  const HEVCPPS *pps, const HEVCSPS *sps,
2099  int x0, int y0, int nPbW, int nPbH,
2100  int log2_cb_size, int partIdx, int idx)
2101 {
2102 #define POS(c_idx, x, y) \
2103  s->cur_frame->f->data[c_idx] ? \
2104  &s->cur_frame->f->data[c_idx][((y) >> sps->vshift[c_idx]) * linesize[c_idx] + \
2105  (((x) >> sps->hshift[c_idx]) << sps->pixel_shift)] : NULL
2106  const HEVCContext *const s = lc->parent;
2107  int merge_idx = 0;
2108  struct MvField current_mv = {{{ 0 }}};
2109 
2110  int min_pu_width = sps->min_pu_width;
2111 
2112  MvField *tab_mvf = s->cur_frame->tab_mvf;
2113  const RefPicList *refPicList = s->cur_frame->refPicList;
2114  const HEVCFrame *ref0 = NULL, *ref1 = NULL;
2115  const int *linesize = s->cur_frame->f->linesize;
2116  uint8_t *dst0 = s->cur_frame->f->data[0] + y0 * linesize[0] + (x0 << sps->pixel_shift);
2117  uint8_t *dst1 = POS(1, x0, y0);
2118  uint8_t *dst2 = POS(2, x0, y0);
2119  int log2_min_cb_size = sps->log2_min_cb_size;
2120  int min_cb_width = sps->min_cb_width;
2121  int x_cb = x0 >> log2_min_cb_size;
2122  int y_cb = y0 >> log2_min_cb_size;
2123  int x_pu, y_pu;
2124  int i, j;
2125 
2126  int skip_flag = SAMPLE_CTB(l->skip_flag, x_cb, y_cb);
2127 
2128  if (!skip_flag)
2130 
2131  if (skip_flag || lc->pu.merge_flag) {
2132  if (s->sh.max_num_merge_cand > 1)
2133  merge_idx = ff_hevc_merge_idx_decode(lc);
2134  else
2135  merge_idx = 0;
2136 
2137  ff_hevc_luma_mv_merge_mode(lc, pps, x0, y0, nPbW, nPbH, log2_cb_size,
2138  partIdx, merge_idx, &current_mv);
2139  } else {
2140  hevc_luma_mv_mvp_mode(lc, pps, sps, x0, y0, nPbW, nPbH, log2_cb_size,
2141  partIdx, merge_idx, &current_mv);
2142  }
2143 
2144  x_pu = x0 >> sps->log2_min_pu_size;
2145  y_pu = y0 >> sps->log2_min_pu_size;
2146 
2147  for (j = 0; j < nPbH >> sps->log2_min_pu_size; j++)
2148  for (i = 0; i < nPbW >> sps->log2_min_pu_size; i++)
2149  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
2150 
2151  if (current_mv.pred_flag & PF_L0) {
2152  ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
2153  if (!ref0 || !ref0->f)
2154  return;
2155  hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
2156  }
2157  if (current_mv.pred_flag & PF_L1) {
2158  ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
2159  if (!ref1 || !ref1->f)
2160  return;
2161  hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
2162  }
2163 
2164  if (current_mv.pred_flag == PF_L0) {
2165  int x0_c = x0 >> sps->hshift[1];
2166  int y0_c = y0 >> sps->vshift[1];
2167  int nPbW_c = nPbW >> sps->hshift[1];
2168  int nPbH_c = nPbH >> sps->vshift[1];
2169 
2170  luma_mc_uni(lc, pps, sps, dst0, linesize[0], ref0->f,
2171  &current_mv.mv[0], x0, y0, nPbW, nPbH,
2172  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
2173  s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
2174 
2175  if (sps->chroma_format_idc) {
2176  chroma_mc_uni(lc, pps, sps, dst1, linesize[1], ref0->f->data[1], ref0->f->linesize[1],
2177  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
2178  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
2179  chroma_mc_uni(lc, pps, sps, dst2, linesize[2], ref0->f->data[2], ref0->f->linesize[2],
2180  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
2181  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
2182  }
2183  } else if (current_mv.pred_flag == PF_L1) {
2184  int x0_c = x0 >> sps->hshift[1];
2185  int y0_c = y0 >> sps->vshift[1];
2186  int nPbW_c = nPbW >> sps->hshift[1];
2187  int nPbH_c = nPbH >> sps->vshift[1];
2188 
2189  luma_mc_uni(lc, pps, sps, dst0, linesize[0], ref1->f,
2190  &current_mv.mv[1], x0, y0, nPbW, nPbH,
2191  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
2192  s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
2193 
2194  if (sps->chroma_format_idc) {
2195  chroma_mc_uni(lc, pps, sps, dst1, linesize[1], ref1->f->data[1], ref1->f->linesize[1],
2196  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
2197  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
2198 
2199  chroma_mc_uni(lc, pps, sps, dst2, linesize[2], ref1->f->data[2], ref1->f->linesize[2],
2200  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
2201  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
2202  }
2203  } else if (current_mv.pred_flag == PF_BI) {
2204  int x0_c = x0 >> sps->hshift[1];
2205  int y0_c = y0 >> sps->vshift[1];
2206  int nPbW_c = nPbW >> sps->hshift[1];
2207  int nPbH_c = nPbH >> sps->vshift[1];
2208 
2209  luma_mc_bi(lc, pps, sps, dst0, linesize[0], ref0->f,
2210  &current_mv.mv[0], x0, y0, nPbW, nPbH,
2211  ref1->f, &current_mv.mv[1], &current_mv);
2212 
2213  if (sps->chroma_format_idc) {
2214  chroma_mc_bi(lc, pps, sps, dst1, linesize[1], ref0->f, ref1->f,
2215  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
2216 
2217  chroma_mc_bi(lc, pps, sps, dst2, linesize[2], ref0->f, ref1->f,
2218  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
2219  }
2220  }
2221 }
2222 
2223 /**
2224  * 8.4.1
2225  */
2227  const HEVCSPS *sps,
2228  int x0, int y0, int pu_size,
2229  int prev_intra_luma_pred_flag)
2230 {
2231  const HEVCContext *const s = lc->parent;
2232  int x_pu = x0 >> sps->log2_min_pu_size;
2233  int y_pu = y0 >> sps->log2_min_pu_size;
2234  int min_pu_width = sps->min_pu_width;
2235  int size_in_pus = pu_size >> sps->log2_min_pu_size;
2236  int x0b = av_zero_extend(x0, sps->log2_ctb_size);
2237  int y0b = av_zero_extend(y0, sps->log2_ctb_size);
2238 
2239  int cand_up = (lc->ctb_up_flag || y0b) ?
2240  l->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
2241  int cand_left = (lc->ctb_left_flag || x0b) ?
2242  l->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
2243 
2244  int y_ctb = (y0 >> (sps->log2_ctb_size)) << (sps->log2_ctb_size);
2245 
2246  MvField *tab_mvf = s->cur_frame->tab_mvf;
2247  int intra_pred_mode;
2248  int candidate[3];
2249  int i, j;
2250 
2251  // intra_pred_mode prediction does not cross vertical CTB boundaries
2252  if ((y0 - 1) < y_ctb)
2253  cand_up = INTRA_DC;
2254 
2255  if (cand_left == cand_up) {
2256  if (cand_left < 2) {
2257  candidate[0] = INTRA_PLANAR;
2258  candidate[1] = INTRA_DC;
2259  candidate[2] = INTRA_ANGULAR_26;
2260  } else {
2261  candidate[0] = cand_left;
2262  candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
2263  candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
2264  }
2265  } else {
2266  candidate[0] = cand_left;
2267  candidate[1] = cand_up;
2268  if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
2269  candidate[2] = INTRA_PLANAR;
2270  } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
2271  candidate[2] = INTRA_DC;
2272  } else {
2273  candidate[2] = INTRA_ANGULAR_26;
2274  }
2275  }
2276 
2277  if (prev_intra_luma_pred_flag) {
2278  intra_pred_mode = candidate[lc->pu.mpm_idx];
2279  } else {
2280  if (candidate[0] > candidate[1])
2281  FFSWAP(uint8_t, candidate[0], candidate[1]);
2282  if (candidate[0] > candidate[2])
2283  FFSWAP(uint8_t, candidate[0], candidate[2]);
2284  if (candidate[1] > candidate[2])
2285  FFSWAP(uint8_t, candidate[1], candidate[2]);
2286 
2287  intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
2288  for (i = 0; i < 3; i++)
2289  if (intra_pred_mode >= candidate[i])
2290  intra_pred_mode++;
2291  }
2292 
2293  /* write the intra prediction units into the mv array */
2294  if (!size_in_pus)
2295  size_in_pus = 1;
2296  for (i = 0; i < size_in_pus; i++) {
2297  memset(&l->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
2298  intra_pred_mode, size_in_pus);
2299 
2300  for (j = 0; j < size_in_pus; j++) {
2301  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
2302  }
2303  }
2304 
2305  return intra_pred_mode;
2306 }
2307 
2308 static av_always_inline void set_ct_depth(const HEVCSPS *sps, uint8_t *tab_ct_depth,
2309  int x0, int y0,
2310  int log2_cb_size, int ct_depth)
2311 {
2312  int length = (1 << log2_cb_size) >> sps->log2_min_cb_size;
2313  int x_cb = x0 >> sps->log2_min_cb_size;
2314  int y_cb = y0 >> sps->log2_min_cb_size;
2315  int y;
2316 
2317  for (y = 0; y < length; y++)
2318  memset(&tab_ct_depth[(y_cb + y) * sps->min_cb_width + x_cb],
2319  ct_depth, length);
2320 }
2321 
2322 static const uint8_t tab_mode_idx[] = {
2323  0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
2324  21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
2325 
2327  const HEVCLayerContext *l, const HEVCSPS *sps,
2328  int x0, int y0,
2329  int log2_cb_size)
2330 {
2331  static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2332  uint8_t prev_intra_luma_pred_flag[4];
2333  int split = lc->cu.part_mode == PART_NxN;
2334  int pb_size = (1 << log2_cb_size) >> split;
2335  int side = split + 1;
2336  int chroma_mode;
2337  int i, j;
2338 
2339  for (i = 0; i < side; i++)
2340  for (j = 0; j < side; j++)
2341  prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(lc);
2342 
2343  for (i = 0; i < side; i++) {
2344  for (j = 0; j < side; j++) {
2345  if (prev_intra_luma_pred_flag[2 * i + j])
2346  lc->pu.mpm_idx = ff_hevc_mpm_idx_decode(lc);
2347  else
2349 
2350  lc->pu.intra_pred_mode[2 * i + j] =
2351  luma_intra_pred_mode(lc, l, sps,
2352  x0 + pb_size * j, y0 + pb_size * i, pb_size,
2353  prev_intra_luma_pred_flag[2 * i + j]);
2354  }
2355  }
2356 
2357  if (sps->chroma_format_idc == 3) {
2358  for (i = 0; i < side; i++) {
2359  for (j = 0; j < side; j++) {
2360  lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc);
2361  if (chroma_mode != 4) {
2362  if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
2363  lc->pu.intra_pred_mode_c[2 * i + j] = 34;
2364  else
2365  lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
2366  } else {
2367  lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
2368  }
2369  }
2370  }
2371  } else if (sps->chroma_format_idc == 2) {
2372  int mode_idx;
2373  lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc);
2374  if (chroma_mode != 4) {
2375  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2376  mode_idx = 34;
2377  else
2378  mode_idx = intra_chroma_table[chroma_mode];
2379  } else {
2380  mode_idx = lc->pu.intra_pred_mode[0];
2381  }
2382  lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2383  } else if (sps->chroma_format_idc != 0) {
2384  chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(lc);
2385  if (chroma_mode != 4) {
2386  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2387  lc->pu.intra_pred_mode_c[0] = 34;
2388  else
2389  lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2390  } else {
2391  lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2392  }
2393  }
2394 }
2395 
2397  const HEVCLayerContext *l,
2398  const HEVCSPS *sps,
2399  int x0, int y0,
2400  int log2_cb_size)
2401 {
2402  const HEVCContext *const s = lc->parent;
2403  int pb_size = 1 << log2_cb_size;
2404  int size_in_pus = pb_size >> sps->log2_min_pu_size;
2405  int min_pu_width = sps->min_pu_width;
2406  MvField *tab_mvf = s->cur_frame->tab_mvf;
2407  int x_pu = x0 >> sps->log2_min_pu_size;
2408  int y_pu = y0 >> sps->log2_min_pu_size;
2409  int j, k;
2410 
2411  if (size_in_pus == 0)
2412  size_in_pus = 1;
2413  for (j = 0; j < size_in_pus; j++)
2414  memset(&l->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2415  if (lc->cu.pred_mode == MODE_INTRA)
2416  for (j = 0; j < size_in_pus; j++)
2417  for (k = 0; k < size_in_pus; k++)
2418  tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2419 }
2420 
2422  const HEVCLayerContext *l,
2423  const HEVCPPS *pps, const HEVCSPS *sps,
2424  int x0, int y0, int log2_cb_size)
2425 {
2426  int cb_size = 1 << log2_cb_size;
2427  int log2_min_cb_size = sps->log2_min_cb_size;
2428  int length = cb_size >> log2_min_cb_size;
2429  int min_cb_width = sps->min_cb_width;
2430  int x_cb = x0 >> log2_min_cb_size;
2431  int y_cb = y0 >> log2_min_cb_size;
2432  int idx = log2_cb_size - 2;
2433  int qp_block_mask = (1 << (sps->log2_ctb_size - pps->diff_cu_qp_delta_depth)) - 1;
2434  int x, y, ret;
2435 
2436  lc->cu.x = x0;
2437  lc->cu.y = y0;
2438  lc->cu.pred_mode = MODE_INTRA;
2439  lc->cu.part_mode = PART_2Nx2N;
2440  lc->cu.intra_split_flag = 0;
2441 
2442  SAMPLE_CTB(l->skip_flag, x_cb, y_cb) = 0;
2443  for (x = 0; x < 4; x++)
2444  lc->pu.intra_pred_mode[x] = 1;
2445  if (pps->transquant_bypass_enable_flag) {
2447  if (lc->cu.cu_transquant_bypass_flag)
2448  set_deblocking_bypass(l->is_pcm, sps, x0, y0, log2_cb_size);
2449  } else
2450  lc->cu.cu_transquant_bypass_flag = 0;
2451 
2452  if (s->sh.slice_type != HEVC_SLICE_I) {
2453  const int x0b = av_zero_extend(x0, sps->log2_ctb_size);
2454  const int y0b = av_zero_extend(y0, sps->log2_ctb_size);
2455  uint8_t skip_flag = ff_hevc_skip_flag_decode(lc, l->skip_flag,
2456  x0b, y0b, x_cb, y_cb,
2457  min_cb_width);
2458 
2459  x = y_cb * min_cb_width + x_cb;
2460  for (y = 0; y < length; y++) {
2461  memset(&l->skip_flag[x], skip_flag, length);
2462  x += min_cb_width;
2463  }
2464  lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2465  } else {
2466  x = y_cb * min_cb_width + x_cb;
2467  for (y = 0; y < length; y++) {
2468  memset(&l->skip_flag[x], 0, length);
2469  x += min_cb_width;
2470  }
2471  }
2472 
2473  if (SAMPLE_CTB(l->skip_flag, x_cb, y_cb)) {
2474  hls_prediction_unit(lc, l, pps, sps,
2475  x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2476  intra_prediction_unit_default_value(lc, l, sps, x0, y0, log2_cb_size);
2477 
2478  if (!s->sh.disable_deblocking_filter_flag)
2479  ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size);
2480  } else {
2481  int pcm_flag = 0;
2482 
2483  if (s->sh.slice_type != HEVC_SLICE_I)
2485  if (lc->cu.pred_mode != MODE_INTRA ||
2486  log2_cb_size == sps->log2_min_cb_size) {
2487  lc->cu.part_mode = ff_hevc_part_mode_decode(lc, sps, log2_cb_size);
2488  lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2489  lc->cu.pred_mode == MODE_INTRA;
2490  }
2491 
2492  if (lc->cu.pred_mode == MODE_INTRA) {
2493  if (lc->cu.part_mode == PART_2Nx2N && sps->pcm_enabled &&
2494  log2_cb_size >= sps->pcm.log2_min_pcm_cb_size &&
2495  log2_cb_size <= sps->pcm.log2_max_pcm_cb_size) {
2496  pcm_flag = ff_hevc_pcm_flag_decode(lc);
2497  }
2498  if (pcm_flag) {
2499  intra_prediction_unit_default_value(lc, l, sps, x0, y0, log2_cb_size);
2500  ret = hls_pcm_sample(lc, l, pps, x0, y0, log2_cb_size);
2501  if (sps->pcm_loop_filter_disabled)
2502  set_deblocking_bypass(l->is_pcm, sps, x0, y0, log2_cb_size);
2503 
2504  if (ret < 0)
2505  return ret;
2506  } else {
2507  intra_prediction_unit(lc, l, sps, x0, y0, log2_cb_size);
2508  }
2509  } else {
2510  intra_prediction_unit_default_value(lc, l, sps, x0, y0, log2_cb_size);
2511  switch (lc->cu.part_mode) {
2512  case PART_2Nx2N:
2513  hls_prediction_unit(lc, l, pps, sps,
2514  x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2515  break;
2516  case PART_2NxN:
2517  hls_prediction_unit(lc, l, pps, sps,
2518  x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2519  hls_prediction_unit(lc, l, pps, sps,
2520  x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2521  break;
2522  case PART_Nx2N:
2523  hls_prediction_unit(lc, l, pps, sps,
2524  x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2525  hls_prediction_unit(lc, l, pps, sps,
2526  x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2527  break;
2528  case PART_2NxnU:
2529  hls_prediction_unit(lc, l, pps, sps,
2530  x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2531  hls_prediction_unit(lc, l, pps, sps,
2532  x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2533  break;
2534  case PART_2NxnD:
2535  hls_prediction_unit(lc, l, pps, sps,
2536  x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2537  hls_prediction_unit(lc, l, pps, sps,
2538  x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2539  break;
2540  case PART_nLx2N:
2541  hls_prediction_unit(lc, l, pps, sps,
2542  x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2543  hls_prediction_unit(lc, l, pps, sps,
2544  x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2545  break;
2546  case PART_nRx2N:
2547  hls_prediction_unit(lc, l, pps, sps,
2548  x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2549  hls_prediction_unit(lc, l, pps, sps,
2550  x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2551  break;
2552  case PART_NxN:
2553  hls_prediction_unit(lc, l, pps, sps,
2554  x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2555  hls_prediction_unit(lc, l, pps, sps,
2556  x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2557  hls_prediction_unit(lc, l, pps, sps,
2558  x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2559  hls_prediction_unit(lc, l, pps, sps,
2560  x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2561  break;
2562  }
2563  }
2564 
2565  if (!pcm_flag) {
2566  int rqt_root_cbf = 1;
2567 
2568  if (lc->cu.pred_mode != MODE_INTRA &&
2569  !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2570  rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(lc);
2571  }
2572  if (rqt_root_cbf) {
2573  const static int cbf[2] = { 0 };
2574  lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2575  sps->max_transform_hierarchy_depth_intra + lc->cu.intra_split_flag :
2576  sps->max_transform_hierarchy_depth_inter;
2577  ret = hls_transform_tree(lc, l, pps, sps, x0, y0, x0, y0, x0, y0,
2578  log2_cb_size,
2579  log2_cb_size, 0, 0, cbf, cbf);
2580  if (ret < 0)
2581  return ret;
2582  } else {
2583  if (!s->sh.disable_deblocking_filter_flag)
2584  ff_hevc_deblocking_boundary_strengths(lc, l, pps, x0, y0, log2_cb_size);
2585  }
2586  }
2587  }
2588 
2589  if (pps->cu_qp_delta_enabled_flag && lc->tu.is_cu_qp_delta_coded == 0)
2590  ff_hevc_set_qPy(lc, l, pps, x0, y0, log2_cb_size);
2591 
2592  x = y_cb * min_cb_width + x_cb;
2593  for (y = 0; y < length; y++) {
2594  memset(&l->qp_y_tab[x], lc->qp_y, length);
2595  x += min_cb_width;
2596  }
2597 
2598  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2599  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2600  lc->qPy_pred = lc->qp_y;
2601  }
2602 
2603  set_ct_depth(sps, l->tab_ct_depth, x0, y0, log2_cb_size, lc->ct_depth);
2604 
2605  return 0;
2606 }
2607 
2609  const HEVCLayerContext *l,
2610  const HEVCPPS *pps, const HEVCSPS *sps,
2611  int x0, int y0,
2612  int log2_cb_size, int cb_depth)
2613 {
2614  const HEVCContext *const s = lc->parent;
2615  const int cb_size = 1 << log2_cb_size;
2616  int ret;
2617  int split_cu;
2618 
2619  lc->ct_depth = cb_depth;
2620  if (x0 + cb_size <= sps->width &&
2621  y0 + cb_size <= sps->height &&
2622  log2_cb_size > sps->log2_min_cb_size) {
2624  sps, cb_depth, x0, y0);
2625  } else {
2626  split_cu = (log2_cb_size > sps->log2_min_cb_size);
2627  }
2628  if (pps->cu_qp_delta_enabled_flag &&
2629  log2_cb_size >= sps->log2_ctb_size - pps->diff_cu_qp_delta_depth) {
2630  lc->tu.is_cu_qp_delta_coded = 0;
2631  lc->tu.cu_qp_delta = 0;
2632  }
2633 
2634  if (s->sh.cu_chroma_qp_offset_enabled_flag &&
2635  log2_cb_size >= sps->log2_ctb_size - pps->diff_cu_chroma_qp_offset_depth) {
2637  }
2638 
2639  if (split_cu) {
2640  int qp_block_mask = (1 << (sps->log2_ctb_size - pps->diff_cu_qp_delta_depth)) - 1;
2641  const int cb_size_split = cb_size >> 1;
2642  const int x1 = x0 + cb_size_split;
2643  const int y1 = y0 + cb_size_split;
2644 
2645  int more_data = 0;
2646 
2647  more_data = hls_coding_quadtree(lc, l, pps, sps,
2648  x0, y0, log2_cb_size - 1, cb_depth + 1);
2649  if (more_data < 0)
2650  return more_data;
2651 
2652  if (more_data && x1 < sps->width) {
2653  more_data = hls_coding_quadtree(lc, l, pps, sps,
2654  x1, y0, log2_cb_size - 1, cb_depth + 1);
2655  if (more_data < 0)
2656  return more_data;
2657  }
2658  if (more_data && y1 < sps->height) {
2659  more_data = hls_coding_quadtree(lc, l, pps, sps,
2660  x0, y1, log2_cb_size - 1, cb_depth + 1);
2661  if (more_data < 0)
2662  return more_data;
2663  }
2664  if (more_data && x1 < sps->width &&
2665  y1 < sps->height) {
2666  more_data = hls_coding_quadtree(lc, l, pps, sps,
2667  x1, y1, log2_cb_size - 1, cb_depth + 1);
2668  if (more_data < 0)
2669  return more_data;
2670  }
2671 
2672  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2673  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2674  lc->qPy_pred = lc->qp_y;
2675 
2676  if (more_data)
2677  return ((x1 + cb_size_split) < sps->width ||
2678  (y1 + cb_size_split) < sps->height);
2679  else
2680  return 0;
2681  } else {
2682  ret = hls_coding_unit(lc, s, l, pps, sps, x0, y0, log2_cb_size);
2683  if (ret < 0)
2684  return ret;
2685  if ((!((x0 + cb_size) %
2686  (1 << (sps->log2_ctb_size))) ||
2687  (x0 + cb_size >= sps->width)) &&
2688  (!((y0 + cb_size) %
2689  (1 << (sps->log2_ctb_size))) ||
2690  (y0 + cb_size >= sps->height))) {
2691  int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(lc);
2692  return !end_of_slice_flag;
2693  } else {
2694  return 1;
2695  }
2696  }
2697 
2698  return 0;
2699 }
2700 
2702  const HEVCLayerContext *l,
2703  const HEVCPPS *pps, const HEVCSPS *sps,
2704  int x_ctb, int y_ctb, int ctb_addr_ts)
2705 {
2706  const HEVCContext *const s = lc->parent;
2707  int ctb_size = 1 << sps->log2_ctb_size;
2708  int ctb_addr_rs = pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2709  int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2710 
2711  l->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2712 
2713  if (pps->entropy_coding_sync_enabled_flag) {
2714  if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2715  lc->first_qp_group = 1;
2716  lc->end_of_tiles_x = sps->width;
2717  } else if (pps->tiles_enabled_flag) {
2718  if (ctb_addr_ts && pps->tile_id[ctb_addr_ts] != pps->tile_id[ctb_addr_ts - 1]) {
2719  int idxX = pps->col_idxX[x_ctb >> sps->log2_ctb_size];
2720  lc->end_of_tiles_x = x_ctb + (pps->column_width[idxX] << sps->log2_ctb_size);
2721  lc->first_qp_group = 1;
2722  }
2723  } else {
2724  lc->end_of_tiles_x = sps->width;
2725  }
2726 
2727  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, sps->height);
2728 
2729  lc->boundary_flags = 0;
2730  if (pps->tiles_enabled_flag) {
2731  if (x_ctb > 0 && pps->tile_id[ctb_addr_ts] != pps->tile_id[pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]])
2733  if (x_ctb > 0 && l->tab_slice_address[ctb_addr_rs] != l->tab_slice_address[ctb_addr_rs - 1])
2735  if (y_ctb > 0 && pps->tile_id[ctb_addr_ts] != pps->tile_id[pps->ctb_addr_rs_to_ts[ctb_addr_rs - sps->ctb_width]])
2737  if (y_ctb > 0 && l->tab_slice_address[ctb_addr_rs] != l->tab_slice_address[ctb_addr_rs - sps->ctb_width])
2739  } else {
2740  if (ctb_addr_in_slice <= 0)
2742  if (ctb_addr_in_slice < sps->ctb_width)
2744  }
2745 
2746  lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2747  lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2748  lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= sps->ctb_width) && (pps->tile_id[ctb_addr_ts] == pps->tile_id[pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - sps->ctb_width]]));
2749  lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= sps->ctb_width) && (pps->tile_id[ctb_addr_ts] == pps->tile_id[pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - sps->ctb_width]]));
2750 }
2751 
2753 {
2754  HEVCLocalContext *const lc = &s->local_ctx[0];
2755  const HEVCLayerContext *const l = &s->layers[s->cur_layer];
2756  const HEVCPPS *const pps = s->pps;
2757  const HEVCSPS *const sps = pps->sps;
2758  const uint8_t *slice_data = gb->buffer + s->sh.data_offset;
2759  const size_t slice_size = get_bits_bytesize(gb, 1) - s->sh.data_offset;
2760  int ctb_size = 1 << sps->log2_ctb_size;
2761  int more_data = 1;
2762  int x_ctb = 0;
2763  int y_ctb = 0;
2764  int ctb_addr_ts = pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2765  int ret;
2766 
2767  while (more_data && ctb_addr_ts < sps->ctb_size) {
2768  int ctb_addr_rs = pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2769 
2770  x_ctb = (ctb_addr_rs % ((sps->width + ctb_size - 1) >> sps->log2_ctb_size)) << sps->log2_ctb_size;
2771  y_ctb = (ctb_addr_rs / ((sps->width + ctb_size - 1) >> sps->log2_ctb_size)) << sps->log2_ctb_size;
2772  hls_decode_neighbour(lc, l, pps, sps, x_ctb, y_ctb, ctb_addr_ts);
2773 
2774  ret = ff_hevc_cabac_init(lc, pps, ctb_addr_ts, slice_data, slice_size, 0);
2775  if (ret < 0) {
2776  l->tab_slice_address[ctb_addr_rs] = -1;
2777  return ret;
2778  }
2779 
2780  hls_sao_param(lc, l, pps, sps,
2781  x_ctb >> sps->log2_ctb_size, y_ctb >> sps->log2_ctb_size);
2782 
2783  l->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2784  l->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2785  l->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2786 
2787  more_data = hls_coding_quadtree(lc, l, pps, sps, x_ctb, y_ctb, sps->log2_ctb_size, 0);
2788  if (more_data < 0) {
2789  l->tab_slice_address[ctb_addr_rs] = -1;
2790  return more_data;
2791  }
2792 
2793 
2794  ctb_addr_ts++;
2795  ff_hevc_save_states(lc, pps, ctb_addr_ts);
2796  ff_hevc_hls_filters(lc, l, pps, x_ctb, y_ctb, ctb_size);
2797  }
2798 
2799  if (x_ctb + ctb_size >= sps->width &&
2800  y_ctb + ctb_size >= sps->height)
2801  ff_hevc_hls_filter(lc, l, pps, x_ctb, y_ctb, ctb_size);
2802 
2803  return ctb_addr_ts;
2804 }
2805 
2806 static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist,
2807  int job, int thread)
2808 {
2809  HEVCLocalContext *lc = &((HEVCLocalContext*)hevc_lclist)[thread];
2810  const HEVCContext *const s = lc->parent;
2811  const HEVCLayerContext *const l = &s->layers[s->cur_layer];
2812  const HEVCPPS *const pps = s->pps;
2813  const HEVCSPS *const sps = pps->sps;
2814  int ctb_size = 1 << sps->log2_ctb_size;
2815  int more_data = 1;
2816  int ctb_row = job;
2817  int ctb_addr_rs = s->sh.slice_ctb_addr_rs + ctb_row * ((sps->width + ctb_size - 1) >> sps->log2_ctb_size);
2818  int ctb_addr_ts = pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2819 
2820  const uint8_t *data = s->data + s->sh.offset[ctb_row];
2821  const size_t data_size = s->sh.size[ctb_row];
2822 
2823  int progress = 0;
2824 
2825  int ret;
2826 
2827  if (ctb_row)
2828  ff_init_cabac_decoder(&lc->cc, data, data_size);
2829 
2830  while(more_data && ctb_addr_ts < sps->ctb_size) {
2831  int x_ctb = (ctb_addr_rs % sps->ctb_width) << sps->log2_ctb_size;
2832  int y_ctb = (ctb_addr_rs / sps->ctb_width) << sps->log2_ctb_size;
2833 
2834  hls_decode_neighbour(lc, l, pps, sps, x_ctb, y_ctb, ctb_addr_ts);
2835 
2836  if (ctb_row)
2837  ff_thread_progress_await(&s->wpp_progress[ctb_row - 1],
2838  progress + SHIFT_CTB_WPP + 1);
2839 
2840  /* atomic_load's prototype requires a pointer to non-const atomic variable
2841  * (due to implementations via mutexes, where reads involve writes).
2842  * Of course, casting const away here is nevertheless safe. */
2843  if (atomic_load((atomic_int*)&s->wpp_err)) {
2844  ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX);
2845  return 0;
2846  }
2847 
2848  ret = ff_hevc_cabac_init(lc, pps, ctb_addr_ts, data, data_size, 1);
2849  if (ret < 0)
2850  goto error;
2851  hls_sao_param(lc, l, pps, sps,
2852  x_ctb >> sps->log2_ctb_size, y_ctb >> sps->log2_ctb_size);
2853 
2854  l->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2855  l->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2856  l->filter_slice_edges[ctb_addr_rs] = s->sh.slice_loop_filter_across_slices_enabled_flag;
2857 
2858  more_data = hls_coding_quadtree(lc, l, pps, sps, x_ctb, y_ctb, sps->log2_ctb_size, 0);
2859 
2860  if (more_data < 0) {
2861  ret = more_data;
2862  goto error;
2863  }
2864 
2865  ctb_addr_ts++;
2866 
2867  ff_hevc_save_states(lc, pps, ctb_addr_ts);
2868  ff_thread_progress_report(&s->wpp_progress[ctb_row], ++progress);
2869  ff_hevc_hls_filters(lc, l, pps, x_ctb, y_ctb, ctb_size);
2870 
2871  if (!more_data && (x_ctb+ctb_size) < sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2872  /* Casting const away here is safe, because it is an atomic operation. */
2873  atomic_store((atomic_int*)&s->wpp_err, 1);
2874  ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX);
2875  return 0;
2876  }
2877 
2878  if ((x_ctb+ctb_size) >= sps->width && (y_ctb+ctb_size) >= sps->height ) {
2879  ff_hevc_hls_filter(lc, l, pps, x_ctb, y_ctb, ctb_size);
2880  ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX);
2881  return ctb_addr_ts;
2882  }
2883  ctb_addr_rs = pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2884  x_ctb+=ctb_size;
2885 
2886  if(x_ctb >= sps->width) {
2887  break;
2888  }
2889  }
2890  ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX);
2891 
2892  return 0;
2893 error:
2894  l->tab_slice_address[ctb_addr_rs] = -1;
2895  /* Casting const away here is safe, because it is an atomic operation. */
2896  atomic_store((atomic_int*)&s->wpp_err, 1);
2897  ff_thread_progress_report(&s->wpp_progress[ctb_row], INT_MAX);
2898  return ret;
2899 }
2900 
2901 static int wpp_progress_init(HEVCContext *s, unsigned count)
2902 {
2903  if (s->nb_wpp_progress < count) {
2904  void *tmp = av_realloc_array(s->wpp_progress, count,
2905  sizeof(*s->wpp_progress));
2906  if (!tmp)
2907  return AVERROR(ENOMEM);
2908 
2909  s->wpp_progress = tmp;
2910  memset(s->wpp_progress + s->nb_wpp_progress, 0,
2911  (count - s->nb_wpp_progress) * sizeof(*s->wpp_progress));
2912 
2913  for (int i = s->nb_wpp_progress; i < count; i++) {
2914  int ret = ff_thread_progress_init(&s->wpp_progress[i], 1);
2915  if (ret < 0)
2916  return ret;
2917  s->nb_wpp_progress = i + 1;
2918  }
2919  }
2920 
2921  for (int i = 0; i < count; i++)
2922  ff_thread_progress_reset(&s->wpp_progress[i]);
2923 
2924  return 0;
2925 }
2926 
2928 {
2929  const HEVCPPS *const pps = s->pps;
2930  const HEVCSPS *const sps = pps->sps;
2931  const uint8_t *data = nal->data;
2932  int length = nal->size;
2933  int *ret;
2934  int64_t offset;
2935  int64_t startheader, cmpt = 0;
2936  int j, res = 0;
2937 
2938  if (s->sh.slice_ctb_addr_rs + s->sh.num_entry_point_offsets * sps->ctb_width >= sps->ctb_width * sps->ctb_height) {
2939  av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2940  s->sh.slice_ctb_addr_rs, s->sh.num_entry_point_offsets,
2941  sps->ctb_width, sps->ctb_height
2942  );
2943  return AVERROR_INVALIDDATA;
2944  }
2945 
2946  if (s->avctx->thread_count > s->nb_local_ctx) {
2947  HEVCLocalContext *tmp = av_malloc_array(s->avctx->thread_count, sizeof(*s->local_ctx));
2948 
2949  if (!tmp)
2950  return AVERROR(ENOMEM);
2951 
2952  memcpy(tmp, s->local_ctx, sizeof(*s->local_ctx) * s->nb_local_ctx);
2953  av_free(s->local_ctx);
2954  s->local_ctx = tmp;
2955 
2956  for (unsigned i = s->nb_local_ctx; i < s->avctx->thread_count; i++) {
2957  tmp = &s->local_ctx[i];
2958 
2959  memset(tmp, 0, sizeof(*tmp));
2960 
2961  tmp->logctx = s->avctx;
2962  tmp->parent = s;
2963  tmp->common_cabac_state = &s->cabac;
2964  }
2965 
2966  s->nb_local_ctx = s->avctx->thread_count;
2967  }
2968 
2969  offset = s->sh.data_offset;
2970 
2971  for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2972  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2973  startheader--;
2974  cmpt++;
2975  }
2976  }
2977 
2978  for (int i = 1; i < s->sh.num_entry_point_offsets; i++) {
2979  offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2980  for (j = 0, cmpt = 0, startheader = offset
2981  + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2982  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2983  startheader--;
2984  cmpt++;
2985  }
2986  }
2987  s->sh.size[i] = s->sh.entry_point_offset[i] - cmpt;
2988  s->sh.offset[i] = offset;
2989 
2990  }
2991 
2992  offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2993  if (length < offset) {
2994  av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2995  return AVERROR_INVALIDDATA;
2996  }
2997  s->sh.size [s->sh.num_entry_point_offsets] = length - offset;
2998  s->sh.offset[s->sh.num_entry_point_offsets] = offset;
2999 
3000  s->sh.offset[0] = s->sh.data_offset;
3001  s->sh.size[0] = s->sh.offset[1] - s->sh.offset[0];
3002 
3003  s->data = data;
3004 
3005  for (unsigned i = 1; i < s->nb_local_ctx; i++) {
3006  s->local_ctx[i].first_qp_group = 1;
3007  s->local_ctx[i].qp_y = s->local_ctx[0].qp_y;
3008  }
3009 
3010  atomic_store(&s->wpp_err, 0);
3011  res = wpp_progress_init(s, s->sh.num_entry_point_offsets + 1);
3012  if (res < 0)
3013  return res;
3014 
3015  ret = av_calloc(s->sh.num_entry_point_offsets + 1, sizeof(*ret));
3016  if (!ret)
3017  return AVERROR(ENOMEM);
3018 
3019  if (pps->entropy_coding_sync_enabled_flag)
3020  s->avctx->execute2(s->avctx, hls_decode_entry_wpp, s->local_ctx, ret, s->sh.num_entry_point_offsets + 1);
3021 
3022  for (int i = 0; i <= s->sh.num_entry_point_offsets; i++)
3023  res += ret[i];
3024 
3025  av_free(ret);
3026  return res;
3027 }
3028 
3030  const H2645NAL *nal, GetBitContext *gb)
3031 {
3032  const HEVCPPS *pps = s->pps;
3033  int ret;
3034 
3035  if (!s->sh.first_slice_in_pic_flag)
3036  s->slice_idx += !s->sh.dependent_slice_segment_flag;
3037 
3038  if (!s->sh.dependent_slice_segment_flag && s->sh.slice_type != HEVC_SLICE_I) {
3039  ret = ff_hevc_slice_rpl(s);
3040  if (ret < 0) {
3041  av_log(s->avctx, AV_LOG_WARNING,
3042  "Error constructing the reference lists for the current slice.\n");
3043  return ret;
3044  }
3045  }
3046 
3047  s->slice_initialized = 1;
3048 
3049  if (s->avctx->hwaccel)
3050  return FF_HW_CALL(s->avctx, decode_slice, nal->raw_data, nal->raw_size);
3051 
3052  if (s->avctx->profile == AV_PROFILE_HEVC_SCC) {
3053  av_log(s->avctx, AV_LOG_ERROR,
3054  "SCC profile is not yet implemented in hevc native decoder.\n");
3055  return AVERROR_PATCHWELCOME;
3056  }
3057 
3058  if (s->sh.dependent_slice_segment_flag) {
3059  int ctb_addr_ts = pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
3060  int prev_rs = pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
3061  if (l->tab_slice_address[prev_rs] != s->sh.slice_addr) {
3062  av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
3063  return AVERROR_INVALIDDATA;
3064  }
3065  }
3066 
3067  s->local_ctx[0].first_qp_group = !s->sh.dependent_slice_segment_flag;
3068 
3069  if (!pps->cu_qp_delta_enabled_flag)
3070  s->local_ctx[0].qp_y = s->sh.slice_qp;
3071 
3072  s->local_ctx[0].tu.cu_qp_offset_cb = 0;
3073  s->local_ctx[0].tu.cu_qp_offset_cr = 0;
3074 
3075  if (s->avctx->active_thread_type == FF_THREAD_SLICE &&
3076  s->sh.num_entry_point_offsets > 0 &&
3077  pps->num_tile_rows == 1 && pps->num_tile_columns == 1)
3078  return hls_slice_data_wpp(s, nal);
3079 
3080  return hls_decode_entry(s, gb);
3081 }
3082 
3084 {
3085  const HEVCSPS *sps = s->cur_frame->pps->sps;
3086  AVFrame *out = s->cur_frame->f;
3087  int ret;
3088 
3089  // Decrement the mastering display and content light level flag when IRAP
3090  // frame has no_rasl_output_flag=1 so the side data persists for the entire
3091  // coded video sequence.
3092  if (IS_IRAP(s) && s->no_rasl_output_flag) {
3093  if (s->sei.common.mastering_display.present > 0)
3094  s->sei.common.mastering_display.present--;
3095 
3096  if (s->sei.common.content_light.present > 0)
3097  s->sei.common.content_light.present--;
3098  }
3099 
3100  ret = ff_h2645_sei_to_frame(out, &s->sei.common, AV_CODEC_ID_HEVC, s->avctx,
3101  &sps->vui.common,
3102  sps->bit_depth, sps->bit_depth_chroma,
3103  s->cur_frame->poc /* no poc_offset in HEVC */);
3104  if (ret < 0)
3105  return ret;
3106 
3107  if (s->sei.timecode.present) {
3108  uint32_t *tc_sd;
3109  char tcbuf[AV_TIMECODE_STR_SIZE];
3110  AVFrameSideData *tcside;
3112  sizeof(uint32_t) * 4, &tcside);
3113  if (ret < 0)
3114  return ret;
3115 
3116  if (tcside) {
3117  tc_sd = (uint32_t*)tcside->data;
3118  tc_sd[0] = s->sei.timecode.num_clock_ts;
3119 
3120  for (int i = 0; i < tc_sd[0]; i++) {
3121  int drop = s->sei.timecode.cnt_dropped_flag[i];
3122  int hh = s->sei.timecode.hours_value[i];
3123  int mm = s->sei.timecode.minutes_value[i];
3124  int ss = s->sei.timecode.seconds_value[i];
3125  int ff = s->sei.timecode.n_frames[i];
3126 
3127  tc_sd[i + 1] = av_timecode_get_smpte(s->avctx->framerate, drop, hh, mm, ss, ff);
3128  av_timecode_make_smpte_tc_string2(tcbuf, s->avctx->framerate, tc_sd[i + 1], 0, 0);
3129  av_dict_set(&out->metadata, "timecode", tcbuf, 0);
3130  }
3131  }
3132 
3133  s->sei.timecode.num_clock_ts = 0;
3134  }
3135 
3136  if (s->sei.common.itut_t35.hdr_plus) {
3137  AVBufferRef *info_ref = av_buffer_ref(s->sei.common.itut_t35.hdr_plus);
3138  if (!info_ref)
3139  return AVERROR(ENOMEM);
3140 
3142  if (ret < 0)
3143  return ret;
3144  }
3145 
3146  if (s->rpu_buf) {
3148  if (!rpu)
3149  return AVERROR(ENOMEM);
3150 
3151  s->rpu_buf = NULL;
3152  }
3153 
3154  if ((ret = ff_dovi_attach_side_data(&s->dovi_ctx, out)) < 0)
3155  return ret;
3156 
3157  if (s->sei.common.itut_t35.hdr_vivid) {
3158  if (!av_frame_side_data_add(&out->side_data, &out->nb_side_data,
3160  &s->sei.common.itut_t35.hdr_vivid,
3162  return AVERROR(ENOMEM);
3163  }
3164 
3165  return 0;
3166 }
3167 
3169 {
3170  int nal_idx = 0;
3171 
3172  for (int i = nal_idx; i < s->pkt.nb_nals; i++) {
3173  const H2645NAL *nal = &s->pkt.nals[i];
3174  const int layer_id = nal->nuh_layer_id;
3175  GetBitContext gb = nal->gb;
3176 
3177  if (layer_id > HEVC_MAX_NUH_LAYER_ID || s->vps->layer_idx[layer_id] < 0 ||
3178  !(s->layers_active_decode & (1 << s->vps->layer_idx[layer_id])))
3179  continue;
3180 
3181  switch (nal->type) {
3182  case HEVC_NAL_TRAIL_R:
3183  case HEVC_NAL_TRAIL_N:
3184  case HEVC_NAL_TSA_N:
3185  case HEVC_NAL_TSA_R:
3186  case HEVC_NAL_STSA_N:
3187  case HEVC_NAL_STSA_R:
3188  case HEVC_NAL_BLA_W_LP:
3189  case HEVC_NAL_BLA_W_RADL:
3190  case HEVC_NAL_BLA_N_LP:
3191  case HEVC_NAL_IDR_W_RADL:
3192  case HEVC_NAL_IDR_N_LP:
3193  case HEVC_NAL_CRA_NUT:
3194  case HEVC_NAL_RADL_N:
3195  case HEVC_NAL_RADL_R:
3196  case HEVC_NAL_RASL_N:
3197  case HEVC_NAL_RASL_R:
3198  if (!get_bits1(&gb)) // first_slice_segment_in_pic_flag
3199  continue;
3201  case HEVC_NAL_VPS:
3202  case HEVC_NAL_SPS:
3203  case HEVC_NAL_PPS:
3204  nal_idx = i;
3205  break;
3206  }
3207  }
3208 
3209  return nal_idx;
3210 }
3211 
3213  unsigned nal_idx)
3214 {
3215  const HEVCPPS *const pps = s->ps.pps_list[s->sh.pps_id];
3216  const HEVCSPS *const sps = pps->sps;
3217  int pic_size_in_ctb = ((sps->width >> sps->log2_min_cb_size) + 1) *
3218  ((sps->height >> sps->log2_min_cb_size) + 1);
3219  int new_sequence = (l == &s->layers[0]) &&
3220  (IS_IDR(s) || IS_BLA(s) || s->last_eos);
3221  int prev_layers_active_decode = s->layers_active_decode;
3222  int prev_layers_active_output = s->layers_active_output;
3223  int ret;
3224 
3225  if (sps->vps != s->vps && l != &s->layers[0]) {
3226  av_log(s->avctx, AV_LOG_ERROR, "VPS changed in a non-base layer\n");
3227  set_sps(s, l, NULL);
3228  return AVERROR_INVALIDDATA;
3229  }
3230 
3231  av_refstruct_replace(&s->pps, pps);
3232  if (l->sps != sps) {
3233  const HEVCSPS *sps_base = s->layers[0].sps;
3234  enum AVPixelFormat pix_fmt = sps->pix_fmt;
3235 
3236  if (l != &s->layers[0]) {
3237  if (!sps_base) {
3238  av_log(s->avctx, AV_LOG_ERROR,
3239  "Access unit starts with a non-base layer frame\n");
3240  return AVERROR_INVALIDDATA;
3241  }
3242 
3243  // Files produced by Vision Pro lack VPS extension VUI,
3244  // so the secondary layer has no range information.
3245  // This check avoids failing in such a case.
3246  if (sps_base->pix_fmt == AV_PIX_FMT_YUVJ420P &&
3247  sps->pix_fmt == AV_PIX_FMT_YUV420P &&
3248  !sps->vui.common.video_signal_type_present_flag)
3249  pix_fmt = sps_base->pix_fmt;
3250 
3251  // Ignore range mismatch between base layer and alpha layer
3252  if (ff_hevc_is_alpha_video(s) &&
3253  sps_base->pix_fmt == AV_PIX_FMT_YUV420P &&
3255  pix_fmt = sps_base->pix_fmt;
3256 
3257  if (pix_fmt != sps_base->pix_fmt ||
3258  sps->width != sps_base->width ||
3259  sps->height != sps_base->height) {
3260  av_log(s->avctx, AV_LOG_ERROR,
3261  "Base/non-base layer SPS have unsupported parameter combination\n");
3262  return AVERROR(ENOSYS);
3263  }
3264  }
3265 
3266  ff_hevc_clear_refs(l);
3267 
3268  ret = set_sps(s, l, sps);
3269  if (ret < 0)
3270  return ret;
3271 
3272  if (l == &s->layers[0]) {
3274 
3275  ret = get_format(s, sps);
3276  if (ret < 0) {
3277  set_sps(s, l, NULL);
3278  return ret;
3279  }
3280 
3281  new_sequence = 1;
3282  }
3283  }
3284 
3285  memset(l->horizontal_bs, 0, l->bs_width * l->bs_height);
3286  memset(l->vertical_bs, 0, l->bs_width * l->bs_height);
3287  memset(l->cbf_luma, 0, sps->min_tb_width * sps->min_tb_height);
3288  memset(l->is_pcm, 0, (sps->min_pu_width + 1) * (sps->min_pu_height + 1));
3289  memset(l->tab_slice_address, -1, pic_size_in_ctb * sizeof(*l->tab_slice_address));
3290 
3291  if (IS_IDR(s))
3292  ff_hevc_clear_refs(l);
3293 
3294  s->slice_idx = 0;
3295  s->first_nal_type = s->nal_unit_type;
3296  s->poc = s->sh.poc;
3297 
3298  if (IS_IRAP(s)) {
3299  s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) ||
3300  (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos);
3301  s->recovery_poc = HEVC_RECOVERY_END;
3302  }
3303 
3304  if (s->recovery_poc != HEVC_RECOVERY_END &&
3305  s->sei.recovery_point.has_recovery_poc) {
3306  if (s->recovery_poc == HEVC_RECOVERY_UNSPECIFIED)
3307  s->recovery_poc = s->poc + s->sei.recovery_point.recovery_poc_cnt;
3308  else if (s->poc >= s->recovery_poc)
3309  s->recovery_poc = HEVC_RECOVERY_END;
3310  }
3311 
3312  /* 8.3.1 */
3313  if (s->temporal_id == 0 &&
3314  s->nal_unit_type != HEVC_NAL_TRAIL_N &&
3315  s->nal_unit_type != HEVC_NAL_TSA_N &&
3316  s->nal_unit_type != HEVC_NAL_STSA_N &&
3317  s->nal_unit_type != HEVC_NAL_RADL_N &&
3318  s->nal_unit_type != HEVC_NAL_RADL_R &&
3319  s->nal_unit_type != HEVC_NAL_RASL_N &&
3320  s->nal_unit_type != HEVC_NAL_RASL_R)
3321  s->poc_tid0 = s->poc;
3322 
3323  if (pps->tiles_enabled_flag)
3324  s->local_ctx[0].end_of_tiles_x = pps->column_width[0] << sps->log2_ctb_size;
3325 
3326  if (new_sequence) {
3327  ret = ff_hevc_output_frames(s, prev_layers_active_decode, prev_layers_active_output,
3328  0, 0, s->sh.no_output_of_prior_pics_flag);
3329  if (ret < 0)
3330  return ret;
3331  }
3332 
3334  if (ret < 0)
3335  return ret;
3336 
3337  ret = ff_hevc_set_new_ref(s, l, s->poc);
3338  if (ret < 0)
3339  goto fail;
3340 
3341  ret = ff_hevc_frame_rps(s, l);
3342  if (ret < 0) {
3343  av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
3344  goto fail;
3345  }
3346 
3347  if (IS_IRAP(s))
3348  s->cur_frame->f->flags |= AV_FRAME_FLAG_KEY;
3349  else
3350  s->cur_frame->f->flags &= ~AV_FRAME_FLAG_KEY;
3351 
3352  s->cur_frame->needs_fg = ((s->sei.common.film_grain_characteristics &&
3353  s->sei.common.film_grain_characteristics->present) ||
3354  s->sei.common.itut_t35.aom_film_grain.enable) &&
3355  !(s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) &&
3356  !s->avctx->hwaccel;
3357 
3358  ret = set_side_data(s);
3359  if (ret < 0)
3360  goto fail;
3361 
3362  if (s->cur_frame->needs_fg &&
3363  (s->sei.common.film_grain_characteristics && s->sei.common.film_grain_characteristics->present &&
3364  !ff_h274_film_grain_params_supported(s->sei.common.film_grain_characteristics->model_id,
3365  s->cur_frame->f->format) ||
3366  !av_film_grain_params_select(s->cur_frame->f))) {
3367  av_log_once(s->avctx, AV_LOG_WARNING, AV_LOG_DEBUG, &s->film_grain_warning_shown,
3368  "Unsupported film grain parameters. Ignoring film grain.\n");
3369  s->cur_frame->needs_fg = 0;
3370  }
3371 
3372  if (s->cur_frame->needs_fg) {
3373  s->cur_frame->frame_grain->format = s->cur_frame->f->format;
3374  s->cur_frame->frame_grain->width = s->cur_frame->f->width;
3375  s->cur_frame->frame_grain->height = s->cur_frame->f->height;
3376  if ((ret = ff_thread_get_buffer(s->avctx, s->cur_frame->frame_grain, 0)) < 0)
3377  goto fail;
3378 
3379  ret = av_frame_copy_props(s->cur_frame->frame_grain, s->cur_frame->f);
3380  if (ret < 0)
3381  goto fail;
3382  }
3383 
3384  s->cur_frame->f->pict_type = 3 - s->sh.slice_type;
3385 
3386  ret = ff_hevc_output_frames(s, s->layers_active_decode, s->layers_active_output,
3387  sps->temporal_layer[sps->max_sub_layers - 1].num_reorder_pics,
3388  sps->temporal_layer[sps->max_sub_layers - 1].max_dec_pic_buffering, 0);
3389  if (ret < 0)
3390  goto fail;
3391 
3392  if (s->avctx->hwaccel) {
3393  AVCodecInternal *avci = s->avctx->internal;
3394  AVPacket *avpkt = avci->in_pkt;
3395  ret = FF_HW_CALL(s->avctx, start_frame,
3396  avpkt->buf, NULL, 0);
3397  if (ret < 0)
3398  goto fail;
3399  }
3400 
3401  // after starting the base-layer frame we know which layers will be decoded,
3402  // so we can now figure out which NALUs to wait for before we can call
3403  // ff_thread_finish_setup()
3404  if (l == &s->layers[0])
3405  s->finish_setup_nal_idx = find_finish_setup_nal(s);
3406 
3407  if (nal_idx >= s->finish_setup_nal_idx)
3408  ff_thread_finish_setup(s->avctx);
3409 
3410  return 0;
3411 
3412 fail:
3413  if (l->cur_frame)
3415  l->cur_frame = NULL;
3416  s->cur_frame = s->collocated_ref = NULL;
3417  return ret;
3418 }
3419 
3421 {
3423  char msg_buf[4 * (50 + 2 * 2 * 16 /* MD5-size */)];
3424  int pixel_shift;
3425  int err = 0;
3426  int i, j;
3427 
3428  if (!desc)
3429  return AVERROR(EINVAL);
3430 
3431  pixel_shift = desc->comp[0].depth > 8;
3432 
3433  /* the checksums are LE, so we have to byteswap for >8bpp formats
3434  * on BE arches */
3435 #if HAVE_BIGENDIAN
3436  if (pixel_shift && !s->checksum_buf) {
3437  av_fast_malloc(&s->checksum_buf, &s->checksum_buf_size,
3438  FFMAX3(frame->linesize[0], frame->linesize[1],
3439  frame->linesize[2]));
3440  if (!s->checksum_buf)
3441  return AVERROR(ENOMEM);
3442  }
3443 #endif
3444 
3445  msg_buf[0] = '\0';
3446  for (i = 0; frame->data[i]; i++) {
3447  int width = s->avctx->coded_width;
3448  int height = s->avctx->coded_height;
3449  int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
3450  int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
3451  uint8_t md5[16];
3452 
3453  av_md5_init(s->md5_ctx);
3454  for (j = 0; j < h; j++) {
3455  const uint8_t *src = frame->data[i] + j * frame->linesize[i];
3456 #if HAVE_BIGENDIAN
3457  if (pixel_shift) {
3458  s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
3459  (const uint16_t *) src, w);
3460  src = s->checksum_buf;
3461  }
3462 #endif
3463  av_md5_update(s->md5_ctx, src, w << pixel_shift);
3464  }
3465  av_md5_final(s->md5_ctx, md5);
3466 
3467 #define MD5_PRI "%016" PRIx64 "%016" PRIx64
3468 #define MD5_PRI_ARG(buf) AV_RB64(buf), AV_RB64((const uint8_t*)(buf) + 8)
3469 
3470  if (!memcmp(md5, s->sei.picture_hash.md5[i], 16)) {
3471  av_strlcatf(msg_buf, sizeof(msg_buf),
3472  "plane %d - correct " MD5_PRI "; ",
3473  i, MD5_PRI_ARG(md5));
3474  } else {
3475  av_strlcatf(msg_buf, sizeof(msg_buf),
3476  "mismatching checksum of plane %d - " MD5_PRI " != " MD5_PRI "; ",
3477  i, MD5_PRI_ARG(md5), MD5_PRI_ARG(s->sei.picture_hash.md5[i]));
3478  err = AVERROR_INVALIDDATA;
3479  }
3480  }
3481 
3482  av_log(s->avctx, err < 0 ? AV_LOG_ERROR : AV_LOG_DEBUG,
3483  "Verifying checksum for frame with POC %d: %s\n",
3484  s->poc, msg_buf);
3485 
3486  return err;
3487  }
3488 
3490 {
3491  HEVCFrame *out = l->cur_frame;
3492  const AVFilmGrainParams *fgp;
3493  av_unused int ret;
3494 
3495  if (out->needs_fg) {
3496  av_assert0(out->frame_grain->buf[0]);
3497  fgp = av_film_grain_params_select(out->f);
3498  switch (fgp->type) {
3500  av_assert0(0);
3501  return AVERROR_BUG;
3503  ret = ff_h274_apply_film_grain(out->frame_grain, out->f, fgp);
3504  break;
3506  ret = ff_aom_apply_film_grain(out->frame_grain, out->f, fgp);
3507  break;
3508  }
3509  av_assert1(ret >= 0);
3510  }
3511 
3512  if (s->avctx->hwaccel) {
3513  ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame);
3514  if (ret < 0) {
3515  av_log(s->avctx, AV_LOG_ERROR,
3516  "hardware accelerator failed to decode picture\n");
3517  return ret;
3518  }
3519  } else {
3520  if (s->avctx->err_recognition & AV_EF_CRCCHECK &&
3521  s->sei.picture_hash.is_md5) {
3522  ret = verify_md5(s, out->f);
3523  if (ret < 0 && s->avctx->err_recognition & AV_EF_EXPLODE)
3524  return ret;
3525  }
3526  }
3527  s->sei.picture_hash.is_md5 = 0;
3528 
3529  av_log(s->avctx, AV_LOG_DEBUG, "Decoded frame with POC %zu/%d.\n",
3530  l - s->layers, s->poc);
3531 
3532  return 0;
3533 }
3534 
3535 static int decode_slice(HEVCContext *s, unsigned nal_idx, GetBitContext *gb)
3536 {
3537  const int layer_idx = s->vps ? s->vps->layer_idx[s->nuh_layer_id] : 0;
3538  HEVCLayerContext *l;
3539  int ret;
3540 
3541  // skip layers not requested to be decoded
3542  // layers_active_decode can only change while decoding a base-layer frame,
3543  // so we can check it for non-base layers
3544  if (layer_idx < 0 ||
3545  (s->nuh_layer_id > 0 && !(s->layers_active_decode & (1 << layer_idx))))
3546  return 0;
3547 
3548  ret = hls_slice_header(&s->sh, s, gb);
3549  // Once hls_slice_header has been called, the context is inconsistent with the slice header
3550  // until the context is reinitialized according to the contents of the new slice header
3551  // at the start of decode_slice_data.
3552  s->slice_initialized = 0;
3553  if (ret < 0) {
3554  return ret;
3555  }
3556 
3557  if ((s->avctx->skip_frame >= AVDISCARD_BIDIR && s->sh.slice_type == HEVC_SLICE_B) ||
3558  (s->avctx->skip_frame >= AVDISCARD_NONINTRA && s->sh.slice_type != HEVC_SLICE_I) ||
3559  (s->avctx->skip_frame >= AVDISCARD_NONKEY && !IS_IRAP(s)) ||
3560  ((s->nal_unit_type == HEVC_NAL_RASL_R || s->nal_unit_type == HEVC_NAL_RASL_N) &&
3561  s->no_rasl_output_flag)) {
3562  return 0;
3563  }
3564 
3565  // switching to a new layer, mark previous layer's frame (if any) as done
3566  if (s->cur_layer != layer_idx &&
3567  s->layers[s->cur_layer].cur_frame &&
3568  s->avctx->active_thread_type == FF_THREAD_FRAME)
3569  ff_progress_frame_report(&s->layers[s->cur_layer].cur_frame->tf, INT_MAX);
3570 
3571  s->cur_layer = layer_idx;
3572  l = &s->layers[s->cur_layer];
3573 
3574  if (s->sh.first_slice_in_pic_flag) {
3575  if (l->cur_frame) {
3576  av_log(s->avctx, AV_LOG_ERROR, "Two slices reporting being the first in the same frame.\n");
3577  return AVERROR_INVALIDDATA;
3578  }
3579 
3580  ret = hevc_frame_start(s, l, nal_idx);
3581  if (ret < 0)
3582  return ret;
3583  } else if (!l->cur_frame) {
3584  av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
3585  return AVERROR_INVALIDDATA;
3586  }
3587 
3588  if (s->nal_unit_type != s->first_nal_type) {
3589  av_log(s->avctx, AV_LOG_ERROR,
3590  "Non-matching NAL types of the VCL NALUs: %d %d\n",
3591  s->first_nal_type, s->nal_unit_type);
3592  return AVERROR_INVALIDDATA;
3593  }
3594 
3595  ret = decode_slice_data(s, l, &s->pkt.nals[nal_idx], gb);
3596  if (ret < 0)
3597  return ret;
3598 
3599  return 0;
3600 }
3601 
3602 static int decode_nal_unit(HEVCContext *s, unsigned nal_idx)
3603 {
3604  H2645NAL *nal = &s->pkt.nals[nal_idx];
3605  GetBitContext gb = nal->gb;
3606  int ret;
3607 
3608  s->nal_unit_type = nal->type;
3609  s->nuh_layer_id = nal->nuh_layer_id;
3610  s->temporal_id = nal->temporal_id;
3611 
3612  if (FF_HW_HAS_CB(s->avctx, decode_params) &&
3613  (s->nal_unit_type == HEVC_NAL_VPS ||
3614  s->nal_unit_type == HEVC_NAL_SPS ||
3615  s->nal_unit_type == HEVC_NAL_PPS ||
3616  s->nal_unit_type == HEVC_NAL_SEI_PREFIX ||
3617  s->nal_unit_type == HEVC_NAL_SEI_SUFFIX)) {
3618  ret = FF_HW_CALL(s->avctx, decode_params,
3619  nal->type, nal->raw_data, nal->raw_size);
3620  if (ret < 0)
3621  goto fail;
3622  }
3623 
3624  switch (s->nal_unit_type) {
3625  case HEVC_NAL_VPS:
3626  ret = ff_hevc_decode_nal_vps(&gb, s->avctx, &s->ps);
3627  if (ret < 0)
3628  goto fail;
3629  break;
3630  case HEVC_NAL_SPS:
3631  ret = ff_hevc_decode_nal_sps(&gb, s->avctx, &s->ps,
3632  nal->nuh_layer_id, s->apply_defdispwin);
3633  if (ret < 0)
3634  goto fail;
3635  break;
3636  case HEVC_NAL_PPS:
3637  ret = ff_hevc_decode_nal_pps(&gb, s->avctx, &s->ps);
3638  if (ret < 0)
3639  goto fail;
3640  break;
3641  case HEVC_NAL_SEI_PREFIX:
3642  case HEVC_NAL_SEI_SUFFIX:
3643  ret = ff_hevc_decode_nal_sei(&gb, s->avctx, &s->sei, &s->ps, s->nal_unit_type);
3644  if (ret < 0)
3645  goto fail;
3646  break;
3647  case HEVC_NAL_TRAIL_R:
3648  case HEVC_NAL_TRAIL_N:
3649  case HEVC_NAL_TSA_N:
3650  case HEVC_NAL_TSA_R:
3651  case HEVC_NAL_STSA_N:
3652  case HEVC_NAL_STSA_R:
3653  case HEVC_NAL_BLA_W_LP:
3654  case HEVC_NAL_BLA_W_RADL:
3655  case HEVC_NAL_BLA_N_LP:
3656  case HEVC_NAL_IDR_W_RADL:
3657  case HEVC_NAL_IDR_N_LP:
3658  case HEVC_NAL_CRA_NUT:
3659  case HEVC_NAL_RADL_N:
3660  case HEVC_NAL_RADL_R:
3661  case HEVC_NAL_RASL_N:
3662  case HEVC_NAL_RASL_R:
3663  ret = decode_slice(s, nal_idx, &gb);
3664  if (ret < 0)
3665  goto fail;
3666  break;
3667  case HEVC_NAL_EOS_NUT:
3668  case HEVC_NAL_EOB_NUT:
3669  case HEVC_NAL_AUD:
3670  case HEVC_NAL_FD_NUT:
3671  case HEVC_NAL_UNSPEC62: // Dolby Vision RPU
3672  case HEVC_NAL_UNSPEC63: // Dolby Vision EL
3673  break;
3674  default:
3675  av_log(s->avctx, AV_LOG_VERBOSE,
3676  "Skipping NAL unit %d\n", s->nal_unit_type);
3677  }
3678 
3679  return 0;
3680 fail:
3681  if (ret == AVERROR_INVALIDDATA &&
3682  !(s->avctx->err_recognition & AV_EF_EXPLODE)) {
3683  av_log(s->avctx, AV_LOG_WARNING,
3684  "Skipping invalid undecodable NALU: %d\n", s->nal_unit_type);
3685  return 0;
3686  }
3687  return ret;
3688 }
3689 
3691 {
3692  s->recovery_poc = HEVC_RECOVERY_UNSPECIFIED;
3693  s->sei.recovery_point.has_recovery_poc = 0;
3694 }
3695 
3696 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
3697 {
3698  int ret = 0;
3699  int eos_at_start = 1;
3700  int flags = (H2645_FLAG_IS_NALFF * !!s->is_nalff) | H2645_FLAG_SMALL_PADDING;
3701 
3702  s->cur_frame = s->collocated_ref = NULL;
3703  s->last_eos = s->eos;
3704  s->eos = 0;
3705  s->slice_initialized = 0;
3706  if (s->last_eos)
3708 
3709  for (int i = 0; i < FF_ARRAY_ELEMS(s->layers); i++) {
3710  HEVCLayerContext *l = &s->layers[i];
3711  l->cur_frame = NULL;
3712  }
3713 
3714  /* split the input packet into NAL units, so we know the upper bound on the
3715  * number of slices in the frame */
3716  ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx,
3717  s->nal_length_size, s->avctx->codec_id, flags);
3718  if (ret < 0) {
3719  av_log(s->avctx, AV_LOG_ERROR,
3720  "Error splitting the input into NAL units.\n");
3721  return ret;
3722  }
3723 
3724  for (int i = 0; i < s->pkt.nb_nals; i++) {
3725  if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
3726  s->pkt.nals[i].type == HEVC_NAL_EOS_NUT) {
3727  if (eos_at_start) {
3728  s->last_eos = 1;
3730  } else {
3731  s->eos = 1;
3732  }
3733  } else {
3734  eos_at_start = 0;
3735  }
3736  }
3737 
3738  /*
3739  * Check for RPU delimiter.
3740  *
3741  * Dolby Vision RPUs masquerade as unregistered NALs of type 62.
3742  *
3743  * We have to do this check here an create the rpu buffer, since RPUs are appended
3744  * to the end of an AU; they are normally the last non-EOB/EOS NAL in the AU.
3745  */
3746  H2645NAL *rpu_nal = NULL;
3747  for (int i = s->pkt.nb_nals - 1; i > 0 ; i--) {
3748  if (s->pkt.nals[i].type == HEVC_NAL_UNSPEC62 && s->pkt.nals[i].size > 2
3749  && !s->pkt.nals[i].nuh_layer_id && !s->pkt.nals[i].temporal_id) {
3750  rpu_nal = &s->pkt.nals[i];
3751  break;
3752  }
3753  }
3754 
3755  if (rpu_nal) {
3756  if (s->rpu_buf) {
3757  av_buffer_unref(&s->rpu_buf);
3758  av_log(s->avctx, AV_LOG_WARNING, "Multiple Dolby Vision RPUs found in one AU. Skipping previous.\n");
3759  }
3760 
3761  s->rpu_buf = av_buffer_alloc(rpu_nal->raw_size - 2);
3762  if (!s->rpu_buf) {
3763  ret = AVERROR(ENOMEM);
3764  goto fail;
3765  }
3766  memcpy(s->rpu_buf->data, rpu_nal->raw_data + 2, rpu_nal->raw_size - 2);
3767 
3768  ret = ff_dovi_rpu_parse(&s->dovi_ctx, rpu_nal->data + 2, rpu_nal->size - 2,
3769  s->avctx->err_recognition);
3770  if (ret < 0) {
3771  av_buffer_unref(&s->rpu_buf);
3772  av_log(s->avctx, AV_LOG_WARNING, "Error parsing DOVI NAL unit.\n");
3773  /* ignore */
3774  }
3775  }
3776 
3777  /* decode the NAL units */
3778  for (int i = 0; i < s->pkt.nb_nals; i++) {
3779  H2645NAL *nal = &s->pkt.nals[i];
3780 
3781  if (s->avctx->skip_frame >= AVDISCARD_ALL ||
3782  (s->avctx->skip_frame >= AVDISCARD_NONREF && ff_hevc_nal_is_nonref(nal->type)))
3783  continue;
3784 
3785  ret = decode_nal_unit(s, i);
3786  if (ret < 0) {
3787  av_log(s->avctx, AV_LOG_WARNING,
3788  "Error parsing NAL unit #%d.\n", i);
3789  goto fail;
3790  }
3791  }
3792 
3793 fail:
3794  for (int i = 0; i < FF_ARRAY_ELEMS(s->layers); i++) {
3795  HEVCLayerContext *l = &s->layers[i];
3796 
3797  if (!l->cur_frame)
3798  continue;
3799 
3800  if (ret >= 0)
3801  ret = hevc_frame_end(s, l);
3802 
3803  if (s->avctx->active_thread_type == FF_THREAD_FRAME)
3804  ff_progress_frame_report(&l->cur_frame->tf, INT_MAX);
3805  }
3806 
3807  return ret;
3808 }
3809 
3810 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3811 {
3812  int ret, i;
3813 
3814  ret = ff_hevc_decode_extradata(buf, length, &s->ps, &s->sei, &s->is_nalff,
3815  &s->nal_length_size, s->avctx->err_recognition,
3816  s->apply_defdispwin, s->avctx);
3817  if (ret < 0)
3818  return ret;
3819 
3820  /* export stream parameters from the first SPS */
3821  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3822  if (first && s->ps.sps_list[i]) {
3823  const HEVCSPS *sps = s->ps.sps_list[i];
3825 
3826  ret = export_multilayer(s, sps->vps);
3827  if (ret < 0)
3828  return ret;
3829 
3830  break;
3831  }
3832  }
3833 
3834  /* export stream parameters from SEI */
3836  if (ret < 0)
3837  return ret;
3838 
3839  return 0;
3840 }
3841 
3843 {
3844  HEVCContext *s = avctx->priv_data;
3845  AVCodecInternal *avci = avctx->internal;
3846  AVPacket *avpkt = avci->in_pkt;
3847 
3848  int ret;
3849  uint8_t *sd;
3850  size_t sd_size;
3851 
3852  s->pkt_dts = AV_NOPTS_VALUE;
3853 
3854  if (av_container_fifo_can_read(s->output_fifo))
3855  goto do_output;
3856 
3857  av_packet_unref(avpkt);
3858  ret = ff_decode_get_packet(avctx, avpkt);
3859  if (ret == AVERROR_EOF) {
3860  ret = ff_hevc_output_frames(s, s->layers_active_decode,
3861  s->layers_active_output, 0, 0, 0);
3862  if (ret < 0)
3863  return ret;
3864  goto do_output;
3865  } else if (ret < 0)
3866  return ret;
3867 
3868  s->pkt_dts = avpkt->dts;
3869 
3870  sd = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &sd_size);
3871  if (sd && sd_size > 0) {
3872  ret = hevc_decode_extradata(s, sd, sd_size, 0);
3873  if (ret < 0)
3874  return ret;
3875  }
3876 
3877  sd = av_packet_get_side_data(avpkt, AV_PKT_DATA_DOVI_CONF, &sd_size);
3878  if (sd && sd_size >= sizeof(s->dovi_ctx.cfg)) {
3879  int old = s->dovi_ctx.cfg.dv_profile;
3880  s->dovi_ctx.cfg = *(AVDOVIDecoderConfigurationRecord *) sd;
3881  if (old)
3882  av_log(avctx, AV_LOG_DEBUG,
3883  "New DOVI configuration record from input packet (profile %d -> %u).\n",
3884  old, s->dovi_ctx.cfg.dv_profile);
3885  }
3886 
3887  ret = decode_nal_units(s, avpkt->data, avpkt->size);
3888  if (ret < 0)
3889  return ret;
3890 
3891 do_output:
3892  if (av_container_fifo_read(s->output_fifo, frame, 0) >= 0) {
3895 
3896  return 0;
3897  }
3898 
3899  return avci->draining ? AVERROR_EOF : AVERROR(EAGAIN);
3900 }
3901 
3903 {
3904  int ret;
3905 
3906  ff_progress_frame_ref(&dst->tf, &src->tf);
3907 
3908  if (src->needs_fg) {
3909  ret = av_frame_ref(dst->frame_grain, src->frame_grain);
3910  if (ret < 0) {
3911  ff_hevc_unref_frame(dst, ~0);
3912  return ret;
3913  }
3914  dst->needs_fg = 1;
3915  }
3916 
3917  dst->pps = av_refstruct_ref_c(src->pps);
3918  dst->tab_mvf = av_refstruct_ref(src->tab_mvf);
3919  dst->rpl_tab = av_refstruct_ref(src->rpl_tab);
3920  dst->rpl = av_refstruct_ref(src->rpl);
3921  dst->nb_rpl_elems = src->nb_rpl_elems;
3922 
3923  dst->poc = src->poc;
3924  dst->ctb_count = src->ctb_count;
3925  dst->flags = src->flags;
3926 
3927  dst->base_layer_frame = src->base_layer_frame;
3928 
3929  av_refstruct_replace(&dst->hwaccel_picture_private,
3930  src->hwaccel_picture_private);
3931 
3932  return 0;
3933 }
3934 
3936 {
3937  HEVCContext *s = avctx->priv_data;
3938 
3939  for (int i = 0; i < FF_ARRAY_ELEMS(s->layers); i++) {
3940  pic_arrays_free(&s->layers[i]);
3941  av_refstruct_unref(&s->layers[i].sps);
3942  }
3943 
3944  av_refstruct_unref(&s->vps);
3945  av_refstruct_unref(&s->pps);
3946 
3947  ff_dovi_ctx_unref(&s->dovi_ctx);
3948  av_buffer_unref(&s->rpu_buf);
3949 
3950  av_freep(&s->md5_ctx);
3951 
3952  av_container_fifo_free(&s->output_fifo);
3953 
3954  for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {
3955  HEVCLayerContext *l = &s->layers[layer];
3956  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
3957  ff_hevc_unref_frame(&l->DPB[i], ~0);
3959  }
3960  }
3961 
3962  ff_hevc_ps_uninit(&s->ps);
3963 
3964  for (int i = 0; i < s->nb_wpp_progress; i++)
3965  ff_thread_progress_destroy(&s->wpp_progress[i]);
3966  av_freep(&s->wpp_progress);
3967 
3968  av_freep(&s->sh.entry_point_offset);
3969  av_freep(&s->sh.offset);
3970  av_freep(&s->sh.size);
3971 
3972  av_freep(&s->local_ctx);
3973 
3974  ff_h2645_packet_uninit(&s->pkt);
3975 
3976  ff_hevc_reset_sei(&s->sei);
3977 
3978  return 0;
3979 }
3980 
3982 {
3983  HEVCContext *s = avctx->priv_data;
3984 
3985  s->avctx = avctx;
3986 
3987  s->local_ctx = av_mallocz(sizeof(*s->local_ctx));
3988  if (!s->local_ctx)
3989  return AVERROR(ENOMEM);
3990  s->nb_local_ctx = 1;
3991 
3992  s->local_ctx[0].parent = s;
3993  s->local_ctx[0].logctx = avctx;
3994  s->local_ctx[0].common_cabac_state = &s->cabac;
3995 
3996  s->output_fifo = av_container_fifo_alloc_avframe(0);
3997  if (!s->output_fifo)
3998  return AVERROR(ENOMEM);
3999 
4000  for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {
4001  HEVCLayerContext *l = &s->layers[layer];
4002  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
4003  l->DPB[i].frame_grain = av_frame_alloc();
4004  if (!l->DPB[i].frame_grain)
4005  return AVERROR(ENOMEM);
4006  }
4007  }
4008 
4009  s->md5_ctx = av_md5_alloc();
4010  if (!s->md5_ctx)
4011  return AVERROR(ENOMEM);
4012 
4013  ff_bswapdsp_init(&s->bdsp);
4014 
4015  s->dovi_ctx.logctx = avctx;
4016  s->eos = 0;
4017 
4018  ff_hevc_reset_sei(&s->sei);
4019 
4020  return 0;
4021 }
4022 
4023 #if HAVE_THREADS
4024 static int hevc_update_thread_context(AVCodecContext *dst,
4025  const AVCodecContext *src)
4026 {
4027  HEVCContext *s = dst->priv_data;
4028  HEVCContext *s0 = src->priv_data;
4029  int ret;
4030 
4031  for (int layer = 0; layer < FF_ARRAY_ELEMS(s->layers); layer++) {
4032  HEVCLayerContext *l = &s->layers[layer];
4033  const HEVCLayerContext *l0 = &s0->layers[layer];
4034  for (int i = 0; i < FF_ARRAY_ELEMS(l->DPB); i++) {
4035  ff_hevc_unref_frame(&l->DPB[i], ~0);
4036  if (l0->DPB[i].f) {
4037  ret = hevc_ref_frame(&l->DPB[i], &l0->DPB[i]);
4038  if (ret < 0)
4039  return ret;
4040  }
4041  }
4042 
4043  if (l->sps != l0->sps) {
4044  ret = set_sps(s, l, l0->sps);
4045  if (ret < 0)
4046  return ret;
4047  }
4048  }
4049 
4050  for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
4051  av_refstruct_replace(&s->ps.vps_list[i], s0->ps.vps_list[i]);
4052 
4053  for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
4054  av_refstruct_replace(&s->ps.sps_list[i], s0->ps.sps_list[i]);
4055 
4056  for (int i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
4057  av_refstruct_replace(&s->ps.pps_list[i], s0->ps.pps_list[i]);
4058 
4059  // PPS do not persist between frames
4060  av_refstruct_unref(&s->pps);
4061 
4062  s->poc_tid0 = s0->poc_tid0;
4063  s->eos = s0->eos;
4064  s->no_rasl_output_flag = s0->no_rasl_output_flag;
4065 
4066  s->is_nalff = s0->is_nalff;
4067  s->nal_length_size = s0->nal_length_size;
4068  s->layers_active_decode = s0->layers_active_decode;
4069  s->layers_active_output = s0->layers_active_output;
4070 
4071  s->film_grain_warning_shown = s0->film_grain_warning_shown;
4072 
4073  if (s->nb_view_ids != s0->nb_view_ids ||
4074  memcmp(s->view_ids, s0->view_ids, sizeof(*s->view_ids) * s->nb_view_ids)) {
4075  av_freep(&s->view_ids);
4076  s->nb_view_ids = 0;
4077 
4078  if (s0->nb_view_ids) {
4079  s->view_ids = av_memdup(s0->view_ids, s0->nb_view_ids * sizeof(*s0->view_ids));
4080  if (!s->view_ids)
4081  return AVERROR(ENOMEM);
4082  s->nb_view_ids = s0->nb_view_ids;
4083  }
4084  }
4085 
4086  ret = ff_h2645_sei_ctx_replace(&s->sei.common, &s0->sei.common);
4087  if (ret < 0)
4088  return ret;
4089 
4090  ret = av_buffer_replace(&s->sei.common.itut_t35.hdr_plus,
4091  s0->sei.common.itut_t35.hdr_plus);
4092  if (ret < 0)
4093  return ret;
4094 
4095  ret = av_buffer_replace(&s->rpu_buf, s0->rpu_buf);
4096  if (ret < 0)
4097  return ret;
4098 
4099  ff_dovi_ctx_replace(&s->dovi_ctx, &s0->dovi_ctx);
4100 
4101  ret = av_buffer_replace(&s->sei.common.itut_t35.hdr_vivid,
4103  if (ret < 0)
4104  return ret;
4105 
4106  s->sei.common.frame_packing = s0->sei.common.frame_packing;
4107  s->sei.common.display_orientation = s0->sei.common.display_orientation;
4108  s->sei.common.alternative_transfer = s0->sei.common.alternative_transfer;
4109  s->sei.tdrdi = s0->sei.tdrdi;
4110  s->sei.recovery_point = s0->sei.recovery_point;
4111  s->recovery_poc = s0->recovery_poc;
4112 
4113  return 0;
4114 }
4115 #endif
4116 
4118 {
4119  int ret;
4120 
4121  if (sei->tdrdi.present) {
4122  AVBufferRef *buf;
4123  size_t size;
4124  AV3DReferenceDisplaysInfo *tdrdi = av_tdrdi_alloc(sei->tdrdi.num_ref_displays, &size);
4125 
4126  if (!tdrdi)
4127  return AVERROR(ENOMEM);
4128 
4129  buf = av_buffer_create((uint8_t *)tdrdi, size, NULL, NULL, 0);
4130  if (!buf) {
4131  av_free(tdrdi);
4132  return AVERROR(ENOMEM);
4133  }
4134 
4135  tdrdi->prec_ref_display_width = sei->tdrdi.prec_ref_display_width;
4136  tdrdi->ref_viewing_distance_flag = sei->tdrdi.ref_viewing_distance_flag;
4137  tdrdi->prec_ref_viewing_dist = sei->tdrdi.prec_ref_viewing_dist;
4138  tdrdi->num_ref_displays = sei->tdrdi.num_ref_displays;
4139  for (int i = 0; i < sei->tdrdi.num_ref_displays; i++) {
4140  AV3DReferenceDisplay *display = av_tdrdi_get_display(tdrdi, i);
4141 
4142  display->left_view_id = sei->tdrdi.left_view_id[i];
4143  display->right_view_id = sei->tdrdi.right_view_id[i];
4144  display->exponent_ref_display_width = sei->tdrdi.exponent_ref_display_width[i];
4145  display->mantissa_ref_display_width = sei->tdrdi.mantissa_ref_display_width[i];
4146  display->exponent_ref_viewing_distance = sei->tdrdi.exponent_ref_viewing_distance[i];
4147  display->mantissa_ref_viewing_distance = sei->tdrdi.mantissa_ref_viewing_distance[i];
4148  display->additional_shift_present_flag = sei->tdrdi.additional_shift_present_flag[i];
4149  display->num_sample_shift = sei->tdrdi.num_sample_shift[i];
4150  }
4153  if (ret < 0) {
4154  av_buffer_unref(&buf);
4155  return ret;
4156  }
4157  }
4158 
4159  ret = ff_h2645_sei_to_context(avctx, &sei->common);
4160  if (ret < 0)
4161  return ret;
4162 
4163  return 0;
4164 }
4165 
4167 {
4168  HEVCContext *s = avctx->priv_data;
4169  int ret;
4170 
4171  ret = hevc_init_context(avctx);
4172  if (ret < 0)
4173  return ret;
4174 
4175  s->sei.picture_timing.picture_struct = 0;
4176  s->eos = 1;
4177 
4178  atomic_init(&s->wpp_err, 0);
4179 
4180  if (!avctx->internal->is_copy) {
4181  const AVPacketSideData *sd;
4182 
4183  if (avctx->extradata_size > 0 && avctx->extradata) {
4184  ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
4185  if (ret < 0) {
4186  return ret;
4187  }
4188 
4189  ret = hevc_sei_to_context(avctx, &s->sei);
4190  if (ret < 0)
4191  return ret;
4192  }
4193 
4195  if (sd && sd->size >= sizeof(s->dovi_ctx.cfg))
4196  s->dovi_ctx.cfg = *(AVDOVIDecoderConfigurationRecord *) sd->data;
4197  }
4198 
4199  return 0;
4200 }
4201 
4203 {
4204  HEVCContext *s = avctx->priv_data;
4206  ff_hevc_reset_sei(&s->sei);
4207  ff_dovi_ctx_flush(&s->dovi_ctx);
4208  av_buffer_unref(&s->rpu_buf);
4209  s->eos = 1;
4210 
4211  if (FF_HW_HAS_CB(avctx, flush))
4212  FF_HW_SIMPLE_CALL(avctx, flush);
4213 }
4214 
4215 #define OFFSET(x) offsetof(HEVCContext, x)
4216 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
4217 
4218 static const AVOption options[] = {
4219  { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
4220  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
4221  { "strict-displaywin", "strictly apply default display window size", OFFSET(apply_defdispwin),
4222  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
4223  { "view_ids", "Array of view IDs that should be decoded and output; a single -1 to decode all views",
4224  .offset = OFFSET(view_ids), .type = AV_OPT_TYPE_INT | AV_OPT_TYPE_FLAG_ARRAY,
4225  .min = -1, .max = INT_MAX, .flags = PAR },
4226  { "view_ids_available", "Array of available view IDs is exported here",
4227  .offset = OFFSET(view_ids_available), .type = AV_OPT_TYPE_UINT | AV_OPT_TYPE_FLAG_ARRAY,
4229  { "view_pos_available", "Array of view positions for view_ids_available is exported here, as AVStereo3DView",
4230  .offset = OFFSET(view_pos_available), .type = AV_OPT_TYPE_UINT | AV_OPT_TYPE_FLAG_ARRAY,
4231  .flags = PAR | AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY, .unit = "view_pos" },
4232  { "unspecified", .type = AV_OPT_TYPE_CONST, .default_val = { .i64 = AV_STEREO3D_VIEW_UNSPEC }, .unit = "view_pos" },
4233  { "left", .type = AV_OPT_TYPE_CONST, .default_val = { .i64 = AV_STEREO3D_VIEW_LEFT }, .unit = "view_pos" },
4234  { "right", .type = AV_OPT_TYPE_CONST, .default_val = { .i64 = AV_STEREO3D_VIEW_RIGHT }, .unit = "view_pos" },
4235 
4236  { NULL },
4237 };
4238 
4239 static const AVClass hevc_decoder_class = {
4240  .class_name = "HEVC decoder",
4241  .item_name = av_default_item_name,
4242  .option = options,
4243  .version = LIBAVUTIL_VERSION_INT,
4244 };
4245 
4247  .p.name = "hevc",
4248  CODEC_LONG_NAME("HEVC (High Efficiency Video Coding)"),
4249  .p.type = AVMEDIA_TYPE_VIDEO,
4250  .p.id = AV_CODEC_ID_HEVC,
4251  .priv_data_size = sizeof(HEVCContext),
4252  .p.priv_class = &hevc_decoder_class,
4253  .init = hevc_decode_init,
4254  .close = hevc_decode_free,
4256  .flush = hevc_decode_flush,
4257  UPDATE_THREAD_CONTEXT(hevc_update_thread_context),
4258  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
4260  .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING |
4263  .p.profiles = NULL_IF_CONFIG_SMALL(ff_hevc_profiles),
4264  .hw_configs = (const AVCodecHWConfigInternal *const []) {
4265 #if CONFIG_HEVC_DXVA2_HWACCEL
4266  HWACCEL_DXVA2(hevc),
4267 #endif
4268 #if CONFIG_HEVC_D3D11VA_HWACCEL
4269  HWACCEL_D3D11VA(hevc),
4270 #endif
4271 #if CONFIG_HEVC_D3D11VA2_HWACCEL
4272  HWACCEL_D3D11VA2(hevc),
4273 #endif
4274 #if CONFIG_HEVC_D3D12VA_HWACCEL
4275  HWACCEL_D3D12VA(hevc),
4276 #endif
4277 #if CONFIG_HEVC_NVDEC_HWACCEL
4278  HWACCEL_NVDEC(hevc),
4279 #endif
4280 #if CONFIG_HEVC_VAAPI_HWACCEL
4281  HWACCEL_VAAPI(hevc),
4282 #endif
4283 #if CONFIG_HEVC_VDPAU_HWACCEL
4284  HWACCEL_VDPAU(hevc),
4285 #endif
4286 #if CONFIG_HEVC_VIDEOTOOLBOX_HWACCEL
4287  HWACCEL_VIDEOTOOLBOX(hevc),
4288 #endif
4289 #if CONFIG_HEVC_VULKAN_HWACCEL
4290  HWACCEL_VULKAN(hevc),
4291 #endif
4292  NULL
4293  },
4294 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
HEVCLayerContext::tab_ct_depth
uint8_t * tab_ct_depth
Definition: hevcdec.h:466
HEVC_NAL_AUD
@ HEVC_NAL_AUD
Definition: hevc.h:64
flags
const SwsFlags flags[]
Definition: swscale.c:85
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
ff_get_coded_side_data
const AVPacketSideData * ff_get_coded_side_data(const AVCodecContext *avctx, enum AVPacketSideDataType type)
Get side data of the given type from a decoding context.
Definition: decode.c:1372
ff_hevc_decode_extradata
int ff_hevc_decode_extradata(const uint8_t *data, int size, HEVCParamSets *ps, HEVCSEI *sei, int *is_nalff, int *nal_length_size, int err_recognition, int apply_defdispwin, void *logctx)
Definition: parse.c:79
hwconfig.h
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1973
HEVCLayerContext::horizontal_bs
uint8_t * horizontal_bs
Definition: hevcdec.h:480
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:434
export_multilayer
static int export_multilayer(HEVCContext *s, const HEVCVPS *vps)
Definition: hevcdec.c:416
hevc_decoder_class
static const AVClass hevc_decoder_class
Definition: hevcdec.c:4239
SliceHeader::beta_offset
int beta_offset
beta_offset_div2 * 2
Definition: hevcdec.h:259
bswapdsp.h
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
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
ff_hevc_dsp_init
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition: dsp.c:128
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:254
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
ff_hevc_luma_mv_mvp_mode
void ff_hevc_luma_mv_mvp_mode(HEVCLocalContext *lc, const HEVCPPS *pps, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv, int mvp_lx_flag, int LX)
Definition: mvs.c:589
HEVCLocalContext
Definition: hevcdec.h:391
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AV3DReferenceDisplay::num_sample_shift
int16_t num_sample_shift
The recommended additional horizontal shift for a stereo pair corresponding to the n-th reference bas...
Definition: tdrdi.h:141
HEVCLayerContext::bs_height
int bs_height
Definition: hevcdec.h:459
SliceHeader::slice_act_cr_qp_offset
int slice_act_cr_qp_offset
Definition: hevcdec.h:255
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:122
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
AV_STEREO3D_VIEW_LEFT
@ AV_STEREO3D_VIEW_LEFT
Frame contains only the left view.
Definition: stereo3d.h:158
ff_hevc_merge_flag_decode
int ff_hevc_merge_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:747
av_clip
#define av_clip
Definition: common.h:100
ff_thread_progress_report
void ff_thread_progress_report(ThreadProgress *pro, int n)
This function is a no-op in no-op mode; otherwise it notifies other threads that a certain level of p...
Definition: threadprogress.c:53
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:43
SliceHeader::chroma_offset_l1
int16_t chroma_offset_l1[16][2]
Definition: hevcdec.h:284
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:688
AVERROR
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 all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ff_dovi_ctx_unref
void ff_dovi_ctx_unref(DOVIContext *s)
Completely reset a DOVIContext, preserving only logctx.
Definition: dovi_rpu.c:30
threadprogress.h
decode_slice
static int decode_slice(HEVCContext *s, unsigned nal_idx, GetBitContext *gb)
Definition: hevcdec.c:3535
MD5_PRI_ARG
#define MD5_PRI_ARG(buf)
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:671
av_container_fifo_alloc_avframe
AVContainerFifo * av_container_fifo_alloc_avframe(unsigned flags)
Allocate an AVContainerFifo instance for AVFrames.
Definition: container_fifo.c:215
ff_hevc_end_of_slice_flag_decode
int ff_hevc_end_of_slice_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:563
PART_NxN
@ PART_NxN
Definition: hevcdec.h:98
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:1942
ff_hevc_cu_qp_delta_sign_flag
int ff_hevc_cu_qp_delta_sign_flag(HEVCLocalContext *lc)
Definition: cabac.c:613
SliceHeader::slice_act_y_qp_offset
int slice_act_y_qp_offset
Definition: hevcdec.h:253
ff_hevc_compute_poc
static int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
Definition: ps.h:548
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1223
decode_reset_recovery_point
static void decode_reset_recovery_point(HEVCContext *s)
Definition: hevcdec.c:3690
out
static FILE * out
Definition: movenc.c:55
HEVCContext::layers_active_output
unsigned layers_active_output
Definition: hevcdec.h:503
HEVC_RECOVERY_UNSPECIFIED
#define HEVC_RECOVERY_UNSPECIFIED
Definition: hevcdec.h:79
HEVCWindow::bottom_offset
unsigned int bottom_offset
Definition: ps.h:95
SAO_BAND
@ SAO_BAND
Definition: hevcdec.h:164
HEVCParamSets::pps_list
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
Definition: ps.h:511
ff_hevc_profiles
const AVProfile ff_hevc_profiles[]
Definition: profiles.c:97
ff_hevc_set_neighbour_available
void ff_hevc_set_neighbour_available(HEVCLocalContext *lc, int x0, int y0, int nPbW, int nPbH, int log2_ctb_size)
Definition: mvs.c:43
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:56
chroma_mc_uni
static void chroma_mc_uni(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, uint8_t *dst0, ptrdiff_t dststride, const uint8_t *src0, ptrdiff_t srcstride, int reflist, int x_off, int y_off, int block_w, int block_h, const struct MvField *current_mv, int chroma_weight, int chroma_offset)
8.5.3.2.2.2 Chroma sample uniprediction interpolation process
Definition: hevcdec.c:1876
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
ff_h2645_sei_to_frame
int ff_h2645_sei_to_frame(AVFrame *frame, H2645SEI *sei, enum AVCodecID codec_id, AVCodecContext *avctx, const H2645VUI *vui, unsigned bit_depth_luma, unsigned bit_depth_chroma, int seed)
Definition: h2645_sei.c:518
ff_h274_apply_film_grain
int ff_h274_apply_film_grain(AVFrame *out_frame, const AVFrame *in_frame, const AVFilmGrainParams *params)
Definition: h274.c:245
src1
const pixel * src1
Definition: h264pred_template.c:420
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:424
HEVCLocalContext::ctb_up_flag
uint8_t ctb_up_flag
Definition: hevcdec.h:423
ff_dovi_rpu_parse
int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size, int err_recognition)
Parse the contents of a Dolby Vision RPU and update the parsed values in the DOVIContext struct.
Definition: dovi_rpudec.c:343
ff_h2645_packet_split
int ff_h2645_packet_split(H2645Packet *pkt, const uint8_t *buf, int length, void *logctx, int nal_length_size, enum AVCodecID codec_id, int flags)
Split an input packet into NAL units.
Definition: h2645_parse.c:527
hevc_await_progress
static void hevc_await_progress(const HEVCContext *s, const HEVCFrame *ref, const Mv *mv, int y0, int height)
Definition: hevcdec.c:2039
av_cold
#define av_cold
Definition: attributes.h:119
int64_t
long long int64_t
Definition: coverity.c:34
HEVCLayerContext::tab_ipm
uint8_t * tab_ipm
Definition: hevcdec.h:470
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
SliceHeader::num_entry_point_offsets
int num_entry_point_offsets
Definition: hevcdec.h:268
av_tdrdi_get_display
static av_always_inline AV3DReferenceDisplay * av_tdrdi_get_display(AV3DReferenceDisplaysInfo *tdrdi, unsigned int idx)
Definition: tdrdi.h:145
HEVCFrame::frame_grain
AVFrame * frame_grain
Definition: hevcdec.h:367
ff_hevc_decode_short_term_rps
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: ps.c:113
hls_slice_header
static int hls_slice_header(SliceHeader *sh, const HEVCContext *s, GetBitContext *gb)
Definition: hevcdec.c:770
AV_FRAME_DATA_FILM_GRAIN_PARAMS
@ AV_FRAME_DATA_FILM_GRAIN_PARAMS
Film grain parameters for a frame, described by AVFilmGrainParams.
Definition: frame.h:188
PART_2NxnU
@ PART_2NxnU
Definition: hevcdec.h:99
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
ff_hevc_flush_dpb
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: refs.c:76
container_fifo.h
AV3DReferenceDisplay
Data structure for single deference display information.
Definition: tdrdi.h:100
HEVCLayerContext::bs_width
int bs_width
Definition: hevcdec.h:458
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:466
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:664
TransformUnit::cu_qp_delta
int cu_qp_delta
Definition: hevcdec.h:334
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:424
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:603
set_deblocking_bypass
static void set_deblocking_bypass(uint8_t *is_pcm, const HEVCSPS *sps, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:1514
HEVC_NAL_BLA_N_LP
@ HEVC_NAL_BLA_N_LP
Definition: hevc.h:47
SAOParams::offset_sign
int offset_sign[3][4]
sao_offset_sign
Definition: dsp.h:36
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:590
INTRA_DC
@ INTRA_DC
Definition: hevcdec.h:126
hevc_decode_flush
static av_cold void hevc_decode_flush(AVCodecContext *avctx)
Definition: hevcdec.c:4202
AVOption
AVOption.
Definition: opt.h:429
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
ff_hevc_pred_mode_decode
int ff_hevc_pred_mode_decode(HEVCLocalContext *lc)
Definition: cabac.c:634
HEVCContext::no_rasl_output_flag
int no_rasl_output_flag
Definition: hevcdec.h:532
data
const char data[16]
Definition: mxf.c:149
Mv::y
int16_t y
vertical component of motion vector
Definition: hevcdec.h:305
HEVC_NAL_TSA_N
@ HEVC_NAL_TSA_N
Definition: hevc.h:31
AV_FRAME_DATA_DOVI_RPU_BUFFER
@ AV_FRAME_DATA_DOVI_RPU_BUFFER
Dolby Vision RPU raw data, suitable for passing to x265 or other libraries.
Definition: frame.h:201
HEVC_NAL_IDR_N_LP
@ HEVC_NAL_IDR_N_LP
Definition: hevc.h:49
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
SAO_EDGE
@ SAO_EDGE
Definition: hevcdec.h:165
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
ff_aom_apply_film_grain
int ff_aom_apply_film_grain(AVFrame *out, const AVFrame *in, const AVFilmGrainParams *params)
Definition: aom_film_grain.c:68
SliceHeader::slice_temporal_mvp_enabled_flag
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevcdec.h:235
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:254
TransformUnit::is_cu_qp_delta_coded
uint8_t is_cu_qp_delta_coded
Definition: hevcdec.h:342
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
ff_hevc_output_frames
int ff_hevc_output_frames(HEVCContext *s, unsigned layers_active_decode, unsigned layers_active_output, unsigned max_output, unsigned max_dpb, int discard)
Find frames in the DPB that are ready for output and either write them to the output FIFO or drop the...
Definition: refs.c:267
hevc_receive_frame
static int hevc_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: hevcdec.c:3842
ff_hevc_hls_filters
void ff_hevc_hls_filters(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, int x_ctb, int y_ctb, int ctb_size)
Definition: filter.c:912
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:176
SliceHeader::slice_loop_filter_across_slices_enabled_flag
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: hevcdec.h:244
ff_hevc_sao_type_idx_decode
int ff_hevc_sao_type_idx_decode(HEVCLocalContext *lc)
Definition: cabac.c:521
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
HEVCLocalContext::ctb_up_left_flag
uint8_t ctb_up_left_flag
Definition: hevcdec.h:425
HEVC_NAL_IDR_W_RADL
@ HEVC_NAL_IDR_W_RADL
Definition: hevc.h:48
find_finish_setup_nal
static int find_finish_setup_nal(const HEVCContext *s)
Definition: hevcdec.c:3168
av_timecode_get_smpte
uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)
Convert sei info to SMPTE 12M binary representation.
Definition: timecode.c:70
RefPicList
Definition: hevcdec.h:194
AV_STEREO3D_VIEW_RIGHT
@ AV_STEREO3D_VIEW_RIGHT
Frame contains only the right view.
Definition: stereo3d.h:163
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:103
AV_STEREO3D_VIEW_UNSPEC
@ AV_STEREO3D_VIEW_UNSPEC
Content is unspecified.
Definition: stereo3d.h:168
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:517
thread.h
ff_hevc_prev_intra_luma_pred_flag_decode
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:702
PF_INTRA
@ PF_INTRA
Definition: hevcdec.h:118
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
set_sps
static int set_sps(HEVCContext *s, HEVCLayerContext *l, const HEVCSPS *sps)
Definition: hevcdec.c:740
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:487
verify_md5
static int verify_md5(HEVCContext *s, AVFrame *frame)
Definition: hevcdec.c:3420
MODE_SKIP
@ MODE_SKIP
Definition: hevcdec.h:108
HEVCLayerContext::skip_flag
uint8_t * skip_flag
Definition: hevcdec.h:465
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
HEVCLocalContext::end_of_tiles_x
int end_of_tiles_x
Definition: hevcdec.h:426
av_always_inline
#define av_always_inline
Definition: attributes.h:76
AV_PKT_DATA_DOVI_CONF
@ AV_PKT_DATA_DOVI_CONF
DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....
Definition: packet.h:280
CodingUnit::x
int x
Definition: hevcdec.h:291
tab_mode_idx
static const uint8_t tab_mode_idx[]
Definition: hevcdec.c:2322
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
AV3DReferenceDisplaysInfo
This structure describes information about the reference display width(s) and reference viewing dista...
Definition: tdrdi.h:53
BOUNDARY_LEFT_TILE
#define BOUNDARY_LEFT_TILE
Definition: hevcdec.h:440
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:563
golomb.h
exp golomb vlc stuff
AVCodecInternal::is_copy
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
Definition: internal.h:54
hls_coding_unit
static int hls_coding_unit(HEVCLocalContext *lc, const HEVCContext *s, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:2421
AVPacketSideData::size
size_t size
Definition: packet.h:426
PART_2Nx2N
@ PART_2Nx2N
Definition: hevcdec.h:95
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
intra_prediction_unit
static void intra_prediction_unit(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCSPS *sps, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:2326
hevc_decode_free
static av_cold int hevc_decode_free(AVCodecContext *avctx)
Definition: hevcdec.c:3935
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:57
HEVCLocalContext::ctb_up_right_flag
uint8_t ctb_up_right_flag
Definition: hevcdec.h:424
HEVCLayerContext::tab_slice_address
int32_t * tab_slice_address
Definition: hevcdec.h:476
ff_hevc_decoder
const FFCodec ff_hevc_decoder
Definition: hevcdec.c:4246
HEVCLayerContext::sao_pixel_buffer_v
uint8_t * sao_pixel_buffer_v[3]
Definition: hevcdec.h:484
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
HEVCLayerContext::sao_pixel_buffer_h
uint8_t * sao_pixel_buffer_h[3]
Definition: hevcdec.h:483
PRED_BI
@ PRED_BI
Definition: hevcdec.h:114
ff_hevc_split_transform_flag_decode
int ff_hevc_split_transform_flag_decode(HEVCLocalContext *lc, int log2_trafo_size)
Definition: cabac.c:821
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
PredictionUnit::intra_pred_mode_c
uint8_t intra_pred_mode_c[4]
Definition: hevcdec.h:329
md5
static struct AVMD5 * md5
Definition: movenc.c:57
InterPredIdc
InterPredIdc
Definition: hevcdec.h:111
MODE_INTER
@ MODE_INTER
Definition: hevcdec.h:106
timecode.h
HEVCWindow::left_offset
unsigned int left_offset
Definition: ps.h:92
GetBitContext
Definition: get_bits.h:109
SliceHeader::luma_log2_weight_denom
uint8_t luma_log2_weight_denom
Definition: hevcdec.h:272
ff_hevc_hls_mvd_coding
void ff_hevc_hls_mvd_coding(HEVCLocalContext *lc, int x0, int y0, int log2_cb_size)
Definition: cabac.c:1493
HEVCLocalContext::pu
PredictionUnit pu
Definition: hevcdec.h:436
HEVC_NAL_SEI_SUFFIX
@ HEVC_NAL_SEI_SUFFIX
Definition: hevc.h:69
av_film_grain_params_select
const AVFilmGrainParams * av_film_grain_params_select(const AVFrame *frame)
Select the most appropriate film grain parameters set for the frame, taking into account the frame's ...
Definition: film_grain_params.c:53
TransformUnit::res_scale_val
int res_scale_val
Definition: hevcdec.h:336
SliceHeader::short_term_ref_pic_set_size
int short_term_ref_pic_set_size
Definition: hevcdec.h:226
H2645_FLAG_IS_NALFF
@ H2645_FLAG_IS_NALFF
Definition: h2645_parse.h:97
ff_hevc_cu_chroma_qp_offset_idx
int ff_hevc_cu_chroma_qp_offset_idx(HEVCLocalContext *lc, int chroma_qp_offset_list_len_minus1)
Definition: cabac.c:623
val
static double val(void *priv, double ch)
Definition: aeval.c:77
ff_hevc_sao_offset_abs_decode
int ff_hevc_sao_offset_abs_decode(HEVCLocalContext *lc, int bit_depth)
Definition: cabac.c:541
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:619
SliceHeader::long_term_ref_pic_set_size
int long_term_ref_pic_set_size
Definition: hevcdec.h:229
hls_cross_component_pred
static int hls_cross_component_pred(HEVCLocalContext *lc, int idx)
Definition: hevcdec.c:1286
HEVCParamSets::sps_list
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
Definition: ps.h:510
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
hls_transform_tree
static int hls_transform_tree(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx, const int *base_cbf_cb, const int *base_cbf_cr)
Definition: hevcdec.c:1530
HEVC_NAL_SEI_PREFIX
@ HEVC_NAL_SEI_PREFIX
Definition: hevc.h:68
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
wpp_progress_init
static int wpp_progress_init(HEVCContext *s, unsigned count)
Definition: hevcdec.c:2901
ff_hevc_luma_mv_merge_mode
void ff_hevc_luma_mv_merge_mode(HEVCLocalContext *lc, const HEVCPPS *pps, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
Definition: mvs.c:482
AVRational::num
int num
Numerator.
Definition: rational.h:59
progressframe.h
av_unused
#define av_unused
Definition: attributes.h:164
refstruct.h
ff_hevc_pred_init
void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
Definition: pred.c:43
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2216
SliceHeader::slice_segment_addr
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice segment
Definition: hevcdec.h:209
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
ff_h2645_packet_uninit
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:685
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
pic_arrays_free
static void pic_arrays_free(HEVCLayerContext *l)
NOTE: Each function hls_foo correspond to the function foo in the specification (HLS stands for High ...
Definition: hevcdec.c:74
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:69
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:657
hls_decode_entry_wpp
static int hls_decode_entry_wpp(AVCodecContext *avctx, void *hevc_lclist, int job, int thread)
Definition: hevcdec.c:2806
ff_hevc_mvp_lx_flag_decode
int ff_hevc_mvp_lx_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
HEVC_SLICE_B
@ HEVC_SLICE_B
Definition: hevc.h:96
HEVCLayerContext::vertical_bs
uint8_t * vertical_bs
Definition: hevcdec.h:481
set_side_data
static int set_side_data(HEVCContext *s)
Definition: hevcdec.c:3083
QPEL_EXTRA_AFTER
#define QPEL_EXTRA_AFTER
Definition: hevcdec.h:63
film_grain_params.h
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
luma_mc_uni
static void luma_mc_uni(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, uint8_t *dst, ptrdiff_t dststride, const AVFrame *ref, const Mv *mv, int x_off, int y_off, int block_w, int block_h, int luma_weight, int luma_offset)
8.5.3.2.2.1 Luma sample unidirectional interpolation process
Definition: hevcdec.c:1718
TransformUnit::intra_pred_mode
int intra_pred_mode
Definition: hevcdec.h:339
ff_hevc_is_alpha_video
int ff_hevc_is_alpha_video(const HEVCContext *s)
Definition: hevcdec.c:455
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:681
SliceHeader::cabac_init_flag
uint8_t cabac_init_flag
Definition: hevcdec.h:242
DBParams::beta_offset
int beta_offset
Definition: hevcdec.h:350
H2645NAL::size
int size
Definition: h2645_parse.h:36
DBParams::tc_offset
int tc_offset
Definition: hevcdec.h:351
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:527
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:709
ff_hevc_decode_nal_sei
int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s, const HEVCParamSets *ps, enum HEVCNALUnitType type)
Definition: sei.c:303
ff_progress_frame_ref
void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src)
Set dst->f to src->f and make dst a co-owner of src->f.
Definition: decode.c:1948
AV_FRAME_SIDE_DATA_FLAG_NEW_REF
#define AV_FRAME_SIDE_DATA_FLAG_NEW_REF
Create a new reference to the passed in buffer instead of taking ownership of it.
Definition: frame.h:1097
QPEL_EXTRA_BEFORE
#define QPEL_EXTRA_BEFORE
Definition: hevcdec.h:62
stereo3d.h
HEVCLayerContext::cur_frame
HEVCFrame * cur_frame
Definition: hevcdec.h:454
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
HEVCLocalContext::parent
const struct HEVCContext * parent
Definition: hevcdec.h:399
s
#define s(width, name)
Definition: cbs_vp9.c:198
HEVCSPS::height
int height
Definition: ps.h:348
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
SAO_NOT_APPLIED
@ SAO_NOT_APPLIED
Definition: hevcdec.h:163
AV_PROFILE_HEVC_SCC
#define AV_PROFILE_HEVC_SCC
Definition: defs.h:164
set_ct_depth
static av_always_inline void set_ct_depth(const HEVCSPS *sps, uint8_t *tab_ct_depth, int x0, int y0, int log2_cb_size, int ct_depth)
Definition: hevcdec.c:2308
ff_hevc_part_mode_decode
int ff_hevc_part_mode_decode(HEVCLocalContext *lc, const HEVCSPS *sps, int log2_cb_size)
Definition: cabac.c:660
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
SliceHeader::luma_offset_l1
int16_t luma_offset_l1[16]
Definition: hevcdec.h:283
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:662
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:1943
ff_hevc_merge_idx_decode
int ff_hevc_merge_idx_decode(HEVCLocalContext *lc)
Definition: cabac.c:736
HEVCSEI::common
H2645SEI common
Definition: sei.h:107
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
ff_hevc_nal_is_nonref
static av_always_inline int ff_hevc_nal_is_nonref(enum HEVCNALUnitType type)
Definition: hevcdec.h:653
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1044
HEVCSEI
Definition: sei.h:106
HEVC_NAL_VPS
@ HEVC_NAL_VPS
Definition: hevc.h:61
HEVC_NAL_UNSPEC62
@ HEVC_NAL_UNSPEC62
Definition: hevc.h:91
export_stream_params_from_sei
static int export_stream_params_from_sei(HEVCContext *s)
Definition: hevcdec.c:388
hevc_frame_start
static int hevc_frame_start(HEVCContext *s, HEVCLayerContext *l, unsigned nal_idx)
Definition: hevcdec.c:3212
ff_hevc_save_states
void ff_hevc_save_states(HEVCLocalContext *lc, const HEVCPPS *pps, int ctb_addr_ts)
Definition: cabac.c:402
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
ff_hevc_skip_flag_decode
int ff_hevc_skip_flag_decode(HEVCLocalContext *lc, uint8_t *skip_flag, int x0, int y0, int x_cb, int y_cb, int min_cb_width)
Definition: cabac.c:573
SliceHeader::slice_rps
ShortTermRPS slice_rps
Definition: hevcdec.h:227
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:594
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AVPacketSideData::data
uint8_t * data
Definition: packet.h:425
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
ff_progress_frame_await
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_progress_frame_await() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading
decode.h
ff_hevc_cbf_cb_cr_decode
int ff_hevc_cbf_cb_cr_decode(HEVCLocalContext *lc, int trafo_depth)
Definition: cabac.c:826
hevc.h
IS_IDR
#define IS_IDR(s)
Definition: hevcdec.h:74
H2645NAL::data
const uint8_t * data
Definition: h2645_parse.h:35
av_container_fifo_read
int av_container_fifo_read(AVContainerFifo *cf, void *obj, unsigned flags)
Read the next available object from the FIFO into obj.
Definition: container_fifo.c:122
AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
@ AV_FRAME_DATA_3D_REFERENCE_DISPLAYS
This side data contains information about the reference display width(s) and reference viewing distan...
Definition: frame.h:256
RefPicList::ref
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:195
HEVCWindow::top_offset
unsigned int top_offset
Definition: ps.h:94
export_stream_params
static void export_stream_params(HEVCContext *s, const HEVCSPS *sps)
Definition: hevcdec.c:332
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
SliceHeader::size
int * size
Definition: hevcdec.h:267
SliceHeader::collocated_list
uint8_t collocated_list
Definition: hevcdec.h:245
av_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
SliceHeader::luma_offset_l0
int16_t luma_offset_l0[16]
Definition: hevcdec.h:280
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:639
AV_FILM_GRAIN_PARAMS_NONE
@ AV_FILM_GRAIN_PARAMS_NONE
Definition: film_grain_params.h:25
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:229
HEVCLayerContext::tab_mvf_pool
struct AVRefStructPool * tab_mvf_pool
Definition: hevcdec.h:486
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
INTRA_ANGULAR_26
@ INTRA_ANGULAR_26
Definition: hevcdec.h:151
SliceHeader::chroma_weight_l1
int16_t chroma_weight_l1[16][2]
Definition: hevcdec.h:277
CodingUnit::max_trafo_depth
uint8_t max_trafo_depth
MaxTrafoDepth.
Definition: hevcdec.h:299
AV_FRAME_DATA_DYNAMIC_HDR_VIVID
@ AV_FRAME_DATA_DYNAMIC_HDR_VIVID
HDR Vivid dynamic metadata associated with a video frame.
Definition: frame.h:215
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:332
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
SliceHeader::slice_ctb_addr_rs
int slice_ctb_addr_rs
Definition: hevcdec.h:286
SliceHeader::poc
int poc
Definition: hevcdec.h:216
ff_hevc_hls_residual_coding
void ff_hevc_hls_residual_coding(HEVCLocalContext *lc, const HEVCPPS *pps, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx)
Definition: cabac.c:981
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
ff_hevc_decode_nal_vps
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:786
FF_CODEC_PROPERTY_FILM_GRAIN
#define FF_CODEC_PROPERTY_FILM_GRAIN
Definition: avcodec.h:1658
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
hevc_ref_frame
static int hevc_ref_frame(HEVCFrame *dst, const HEVCFrame *src)
Definition: hevcdec.c:3902
if
if(ret)
Definition: filter_design.txt:179
hevc_decode_init
static av_cold int hevc_decode_init(AVCodecContext *avctx)
Definition: hevcdec.c:4166
srcstride
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t const uint8_t ptrdiff_t srcstride
Definition: dsp.h:88
SliceHeader::pic_output_flag
uint8_t pic_output_flag
Definition: hevcdec.h:220
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
fail
#define fail
Definition: test.h:478
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:110
pred_weight_table
static int pred_weight_table(SliceHeader *sh, void *logctx, const HEVCSPS *sps, GetBitContext *gb)
Definition: hevcdec.c:175
PredictionUnit::rem_intra_luma_pred_mode
int rem_intra_luma_pred_mode
Definition: hevcdec.h:325
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:586
HEVCContext::sei
HEVCSEI sei
Definition: hevcdec.h:511
H2645NAL::raw_size
int raw_size
Definition: h2645_parse.h:44
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_thread_progress_await
void ff_thread_progress_await(const ThreadProgress *pro_c, int n)
This function is a no-op in no-op mode; otherwise it waits until other threads have reached a certain...
Definition: threadprogress.c:64
IS_BLA
#define IS_BLA(s)
Definition: hevcdec.h:75
HEVCLayerContext::deblock
DBParams * deblock
Definition: hevcdec.h:462
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:37
NULL
#define NULL
Definition: coverity.c:32
parse.h
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:599
SAOParams::offset_abs
int offset_abs[3][4]
sao_offset_abs
Definition: dsp.h:35
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:681
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
HEVCLocalContext::tmp
int16_t tmp[MAX_PB_SIZE *MAX_PB_SIZE]
Definition: hevcdec.h:432
CTB
#define CTB(tab, x, y)
Definition: hevcdec.c:1196
hwaccel_internal.h
LongTermRPS::poc
int poc[32]
Definition: hevcdec.h:188
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:798
CodingUnit::cu_transquant_bypass_flag
uint8_t cu_transquant_bypass_flag
Definition: hevcdec.h:300
is_pcm
static int is_pcm(enum AVCodecID codec_id)
Definition: mxfdec.c:2553
HEVC_SLICE_I
@ HEVC_SLICE_I
Definition: hevc.h:98
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:478
ff_hevc_decode_nal_pps
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:2201
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
HEVCLocalContext::first_qp_group
uint8_t first_qp_group
Definition: hevcdec.h:396
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
ff_h2645_sei_to_context
int ff_h2645_sei_to_context(AVCodecContext *avctx, H2645SEI *sei)
Definition: h2645_sei.c:708
do_output
static void do_output(BM3DContext *s, uint8_t *dst, int dst_linesize, int plane, int nb_jobs)
Definition: vf_bm3d.c:630
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
HEVCLayerContext::cbf_luma
uint8_t * cbf_luma
Definition: hevcdec.h:469
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
HEVC_NAL_STSA_N
@ HEVC_NAL_STSA_N
Definition: hevc.h:33
profiles.h
ff_hevc_reset_sei
static void ff_hevc_reset_sei(HEVCSEI *sei)
Reset SEI values that are stored on the Context.
Definition: sei.h:128
AV3DReferenceDisplay::exponent_ref_display_width
uint8_t exponent_ref_display_width
The exponent part of the reference display width of the n-th reference display.
Definition: tdrdi.h:114
ff_hevc_res_scale_sign_flag
int ff_hevc_res_scale_sign_flag(HEVCLocalContext *lc, int idx)
Definition: cabac.c:861
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:106
L0
#define L0
Definition: hevcdec.h:56
flush
void(* flush)(AVBSFContext *ctx)
Definition: dts2pts.c:581
LongTermRPS::poc_msb_present
uint8_t poc_msb_present[32]
Definition: hevcdec.h:189
HEVC_NAL_EOS_NUT
@ HEVC_NAL_EOS_NUT
Definition: hevc.h:65
options
Definition: swscale.c:50
HEVCContext::film_grain_warning_shown
int film_grain_warning_shown
Definition: hevcdec.h:577
ff_log2
#define ff_log2
Definition: intmath.h:51
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:638
PART_Nx2N
@ PART_Nx2N
Definition: hevcdec.h:97
ff_hevc_ref_idx_lx_decode
int ff_hevc_ref_idx_lx_decode(HEVCLocalContext *lc, int num_ref_idx_lx)
Definition: cabac.c:762
RefPicListTab
Definition: hevcdec.h:201
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:341
BOUNDARY_UPPER_TILE
#define BOUNDARY_UPPER_TILE
Definition: hevcdec.h:442
attributes.h
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
decode_nal_unit
static int decode_nal_unit(HEVCContext *s, unsigned nal_idx)
Definition: hevcdec.c:3602
aom_film_grain.h
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
AV_OPT_TYPE_UINT
@ AV_OPT_TYPE_UINT
Underlying C type is unsigned int.
Definition: opt.h:335
h274.h
HEVCContext::is_nalff
int is_nalff
this flag is != 0 if bitstream is encapsulated as a format defined in 14496-15
Definition: hevcdec.h:560
AV_EF_CRCCHECK
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data,...
Definition: defs.h:48
FF_HW_HAS_CB
#define FF_HW_HAS_CB(avctx, function)
Definition: hwaccel_internal.h:179
SliceHeader::nb_refs
unsigned int nb_refs[2]
Definition: hevcdec.h:237
Mv::x
int16_t x
horizontal component of motion vector
Definition: hevcdec.h:304
sei
static int FUNC() sei(CodedBitstreamContext *ctx, RWContext *rw, H264RawSEI *current)
Definition: cbs_h264_syntax_template.c:858
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1646
PF_BI
@ PF_BI
Definition: hevcdec.h:121
ff_hevc_sao_eo_class_decode
int ff_hevc_sao_eo_class_decode(HEVCLocalContext *lc)
Definition: cabac.c:556
H2645SEI::display_orientation
H2645SEIDisplayOrientation display_orientation
Definition: h2645_sei.h:132
SAMPLE_CTB
#define SAMPLE_CTB(tab, x, y)
Definition: hevcdec.h:72
HEVCWindow
Definition: ps.h:91
SCAN_HORIZ
@ SCAN_HORIZ
Definition: hevcdec.h:178
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
get_bits_bytesize
static int get_bits_bytesize(const GetBitContext *s, int round_up)
Get the size of the GetBitContext's buffer in bytes.
Definition: get_bits.h:268
PAR
#define PAR
Definition: hevcdec.c:4216
HEVCLocalContext::edge_emu_buffer
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:429
IS_IRAP
#define IS_IRAP(s)
Definition: hevcdec.h:77
SAOParams::offset_val
int16_t offset_val[3][5]
SaoOffsetVal.
Definition: dsp.h:42
HEVCSEI::recovery_point
HEVCSEIRecoveryPoint recovery_point
Definition: sei.h:113
LongTermRPS::used
uint8_t used[32]
Definition: hevcdec.h:190
HEVC_NAL_RASL_R
@ HEVC_NAL_RASL_R
Definition: hevc.h:38
SliceHeader::colour_plane_id
uint8_t colour_plane_id
Definition: hevcdec.h:221
PART_nLx2N
@ PART_nLx2N
Definition: hevcdec.h:101
ff_hevc_cabac_init
int ff_hevc_cabac_init(HEVCLocalContext *lc, const HEVCPPS *pps, int ctb_addr_ts, const uint8_t *data, size_t size, int is_wpp)
Definition: cabac.c:454
HEVCContext::nal_length_size
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: hevcdec.h:574
luma_mc_bi
static void luma_mc_bi(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, uint8_t *dst, ptrdiff_t dststride, const AVFrame *ref0, const Mv *mv0, int x_off, int y_off, int block_w, int block_h, const AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
8.5.3.2.2.1 Luma sample bidirectional interpolation process
Definition: hevcdec.c:1782
SliceHeader::dependent_slice_segment_flag
uint8_t dependent_slice_segment_flag
Definition: hevcdec.h:219
HEVCSEITDRDI
Definition: sei.h:82
ff_hevc_set_new_ref
int ff_hevc_set_new_ref(HEVCContext *s, HEVCLayerContext *l, int poc)
Definition: refs.c:211
SliceHeader::slice_act_cb_qp_offset
int slice_act_cb_qp_offset
Definition: hevcdec.h:254
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:231
SliceHeader::first_slice_in_pic_flag
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:218
HEVCLocalContext::ctb_left_flag
uint8_t ctb_left_flag
Definition: hevcdec.h:422
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
H2645SEI::frame_packing
H2645SEIFramePacking frame_packing
Definition: h2645_sei.h:131
AVPacket::size
int size
Definition: packet.h:604
BOUNDARY_UPPER_SLICE
#define BOUNDARY_UPPER_SLICE
Definition: hevcdec.h:441
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ff_dovi_attach_side_data
int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
Attach the decoded AVDOVIMetadata as side data to an AVFrame.
Definition: dovi_rpudec.c:64
hevcdec.h
ff_hevc_frame_rps
int ff_hevc_frame_rps(HEVCContext *s, HEVCLayerContext *l)
Construct the reference picture sets for the current frame.
Definition: refs.c:536
height
#define height
Definition: dsp.h:89
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:278
codec_internal.h
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
HEVC_NAL_RASL_N
@ HEVC_NAL_RASL_N
Definition: hevc.h:37
HEVCSEITDRDI::right_view_id
uint16_t right_view_id[32]
Definition: sei.h:88
AV_OPT_TYPE_FLAG_ARRAY
@ AV_OPT_TYPE_FLAG_ARRAY
May be combined with another regular option type to declare an array option.
Definition: opt.h:346
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
HEVCSEITDRDI::left_view_id
uint16_t left_view_id[32]
Definition: sei.h:87
ff_hevc_unref_frame
void ff_hevc_unref_frame(HEVCFrame *frame, int flags)
Definition: refs.c:35
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:117
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
INTRA_PLANAR
@ INTRA_PLANAR
Definition: hevcdec.h:125
PART_2NxnD
@ PART_2NxnD
Definition: hevcdec.h:100
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
HEVC_NAL_SPS
@ HEVC_NAL_SPS
Definition: hevc.h:62
FF_CODEC_CAP_EXPORTS_CROPPING
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
Definition: codec_internal.h:61
size
int size
Definition: twinvq_data.h:10344
SCAN_VERT
@ SCAN_VERT
Definition: hevcdec.h:179
ff_hevc_pcm_flag_decode
int ff_hevc_pcm_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:697
H2645_FLAG_SMALL_PADDING
@ H2645_FLAG_SMALL_PADDING
Definition: h2645_parse.h:98
ff_hevc_deblocking_boundary_strengths
void ff_hevc_deblocking_boundary_strengths(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, int x0, int y0, int log2_trafo_size)
Definition: filter.c:742
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
SliceHeader::collocated_ref_idx
unsigned int collocated_ref_idx
Definition: hevcdec.h:247
HEVCContext::nb_view_ids
unsigned nb_view_ids
Definition: hevcdec.h:566
SliceHeader::entry_point_offset
unsigned * entry_point_offset
Definition: hevcdec.h:265
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:2178
hls_decode_neighbour
static void hls_decode_neighbour(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x_ctb, int y_ctb, int ctb_addr_ts)
Definition: hevcdec.c:2701
ff_frame_new_side_data_from_buf_ext
int ff_frame_new_side_data_from_buf_ext(const AVCodecContext *avctx, AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf)
Same as ff_frame_new_side_data_from_buf, but taking a AVFrameSideData array directly instead of an AV...
Definition: decode.c:2197
H2645NAL
Definition: h2645_parse.h:34
hls_slice_data_wpp
static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
Definition: hevcdec.c:2927
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
AVFrameSideData::data
uint8_t * data
Definition: frame.h:323
TransformUnit::chroma_mode_c
int chroma_mode_c
Definition: hevcdec.h:341
SUBDIVIDE
#define SUBDIVIDE(x, y, idx)
AVFilmGrainParams
This structure describes how to handle film grain synthesis in video for specific codecs.
Definition: film_grain_params.h:201
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1591
SliceHeader::short_term_ref_pic_set_sps_flag
int short_term_ref_pic_set_sps_flag
RPS coded in the slice header itself is stored here.
Definition: hevcdec.h:225
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:797
SliceHeader::no_output_of_prior_pics_flag
uint8_t no_output_of_prior_pics_flag
Definition: hevcdec.h:234
AVCodecHWConfigInternal
Definition: hwconfig.h:25
MvField
Definition: hevcdec.h:308
QPEL_EXTRA
#define QPEL_EXTRA
Definition: hevcdec.h:64
HEVC_NAL_PPS
@ HEVC_NAL_PPS
Definition: hevc.h:63
PF_L1
@ PF_L1
Definition: hevcdec.h:120
split
static char * split(char *message, char delim)
Definition: af_channelmap.c:89
HEVC_NAL_STSA_R
@ HEVC_NAL_STSA_R
Definition: hevc.h:34
av_frame_remove_side_data
void av_frame_remove_side_data(AVFrame *frame, enum AVFrameSideDataType type)
Remove and free all side data instances of the given type.
Definition: frame.c:725
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:602
av_refstruct_ref
void * av_refstruct_ref(void *obj)
Create a new reference to an object managed via this API, i.e.
Definition: refstruct.c:140
HEVC_MAX_NUH_LAYER_ID
@ HEVC_MAX_NUH_LAYER_ID
Definition: hevc.h:110
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
HEVCContext::dovi_ctx
DOVIContext dovi_ctx
Dolby Vision decoding context.
Definition: hevcdec.h:583
SliceHeader::chroma_weight_l0
int16_t chroma_weight_l0[16][2]
Definition: hevcdec.h:276
options
static const AVOption options[]
Definition: hevcdec.c:4218
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:592
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
ff_hevc_cbf_luma_decode
int ff_hevc_cbf_luma_decode(HEVCLocalContext *lc, int trafo_depth)
Definition: cabac.c:831
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
AVCodecInternal
Definition: internal.h:49
HEVCContext::ps
HEVCParamSets ps
Definition: hevcdec.h:510
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
av_zero_extend
#define av_zero_extend
Definition: common.h:151
ff_dovi_ctx_flush
av_cold void ff_dovi_ctx_flush(DOVIContext *s)
Partially reset the internal state.
Definition: dovi_rpu.c:43
TransformUnit::cu_qp_offset_cb
int8_t cu_qp_offset_cb
Definition: hevcdec.h:344
SliceHeader::chroma_log2_weight_denom
int16_t chroma_log2_weight_denom
Definition: hevcdec.h:273
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
MvField::pred_flag
int8_t pred_flag
Definition: hevcdec.h:311
HEVCLocalContext::ct_depth
int ct_depth
Definition: hevcdec.h:434
SAOParams::eo_class
int eo_class[3]
sao_eo_class
Definition: dsp.h:40
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1590
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AV_OPT_FLAG_READONLY
#define AV_OPT_FLAG_READONLY
The option may not be set through the AVOptions API, only read.
Definition: opt.h:368
ff_init_cabac_decoder
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:162
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: ps.c:2473
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
PART_nRx2N
@ PART_nRx2N
Definition: hevcdec.h:102
setup_multilayer
static int setup_multilayer(HEVCContext *s, const HEVCVPS *vps)
Definition: hevcdec.c:474
EPEL_EXTRA_BEFORE
#define EPEL_EXTRA_BEFORE
Definition: hevcdec.h:59
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
SliceHeader::slice_cb_qp_offset
int slice_cb_qp_offset
Definition: hevcdec.h:250
SliceHeader
Definition: hevcdec.h:205
ff_hevc_frame_nb_refs
int ff_hevc_frame_nb_refs(const SliceHeader *sh, const HEVCPPS *pps, unsigned layer_idx)
Get the number of candidate references for the current frame.
Definition: refs.c:616
MODE_INTRA
#define MODE_INTRA
Definition: vp3.c:83
HEVCLayerContext::filter_slice_edges
uint8_t * filter_slice_edges
Definition: hevcdec.h:474
HEVCLayerContext::qp_y_tab
int8_t * qp_y_tab
Definition: hevcdec.h:478
av_md5_init
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:143
ff_hevc_cu_transquant_bypass_flag_decode
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:568
HEVC_NAL_TSA_R
@ HEVC_NAL_TSA_R
Definition: hevc.h:32
AV3DReferenceDisplay::right_view_id
uint16_t right_view_id
The ViewId of the left view of a stereo pair corresponding to the n-th reference display.
Definition: tdrdi.h:109
SliceHeader::slice_sample_adaptive_offset_flag
uint8_t slice_sample_adaptive_offset_flag[3]
Definition: hevcdec.h:239
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:230
decode_nal_units
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
Definition: hevcdec.c:3696
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:131
hevc_pel_weight
static const uint8_t hevc_pel_weight[65]
Definition: hevcdec.c:62
nal
static int FUNC() nal(CodedBitstreamContext *ctx, RWContext *rw, LCEVCRawNAL *current, int nal_unit_type)
Definition: cbs_lcevc_syntax_template.c:657
HEVCFrame
Definition: hevcdec.h:360
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:526
HEVCFrame::tf
ProgressFrame tf
Definition: hevcdec.h:365
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
HEVCLayerContext
Definition: hevcdec.h:452
internal.h
EPEL_EXTRA_AFTER
#define EPEL_EXTRA_AFTER
Definition: hevcdec.h:60
src2
const pixel * src2
Definition: h264pred_template.c:421
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
ff_hevc_no_residual_syntax_flag_decode
int ff_hevc_no_residual_syntax_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:783
SliceHeader::offset
int * offset
Definition: hevcdec.h:266
HEVCSEITDRDI::num_ref_displays
uint8_t num_ref_displays
Definition: sei.h:86
common.h
HEVCContext::view_ids
int * view_ids
Definition: hevcdec.h:565
AVCodecInternal::in_pkt
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
Definition: internal.h:83
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
SliceHeader::mvd_l1_zero_flag
uint8_t mvd_l1_zero_flag
Definition: hevcdec.h:240
ff_hevc_mpm_idx_decode
int ff_hevc_mpm_idx_decode(HEVCLocalContext *lc)
Definition: cabac.c:707
delta
float delta
Definition: vorbis_enc_data.h:430
md5.h
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:228
chroma_mc_bi
static void chroma_mc_bi(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, uint8_t *dst0, ptrdiff_t dststride, const AVFrame *ref0, const AVFrame *ref1, int x_off, int y_off, int block_w, int block_h, const MvField *current_mv, int cidx)
8.5.3.2.2.2 Chroma sample bidirectional interpolation process
Definition: hevcdec.c:1946
ff_thread_progress_init
av_cold int ff_thread_progress_init(ThreadProgress *pro, int init_mode)
Initialize a ThreadProgress.
Definition: threadprogress.c:33
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PF_L0
@ PF_L0
Definition: hevcdec.h:119
EDGE_EMU_BUFFER_STRIDE
#define EDGE_EMU_BUFFER_STRIDE
Definition: hevcdec.h:66
cabac_functions.h
AV3DReferenceDisplay::mantissa_ref_display_width
uint8_t mantissa_ref_display_width
The mantissa part of the reference display width of the n-th reference display.
Definition: tdrdi.h:119
SET_SAO
#define SET_SAO(elem, value)
Definition: hevcdec.c:1198
SliceHeader::data_offset
unsigned data_offset
Definition: hevcdec.h:287
HEVCLocalContext::qp_y
int8_t qp_y
Definition: hevcdec.h:415
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
HEVCSPS::width
int width
coded frame dimension in various units
Definition: ps.h:347
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:688
HEVCSEI::tdrdi
HEVCSEITDRDI tdrdi
Definition: sei.h:112
SliceHeader::chroma_offset_l0
int16_t chroma_offset_l0[16][2]
Definition: hevcdec.h:281
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
SliceHeader::list_entry_lx
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:231
AVCodecContext::height
int height
Definition: avcodec.h:604
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
av_md5_final
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:188
HEVCContext::recovery_poc
int recovery_poc
Definition: hevcdec.h:529
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
HEVCFrame::f
AVFrame * f
Definition: hevcdec.h:363
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
ff_hevc_cu_chroma_qp_offset_flag
int ff_hevc_cu_chroma_qp_offset_flag(HEVCLocalContext *lc)
Definition: cabac.c:618
hls_coding_quadtree
static int hls_coding_quadtree(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int log2_cb_size, int cb_depth)
Definition: hevcdec.c:2608
SAOParams
Definition: dsp.h:34
hls_decode_entry
static int hls_decode_entry(HEVCContext *s, GetBitContext *gb)
Definition: hevcdec.c:2752
SliceHeader::short_term_rps
const ShortTermRPS * short_term_rps
Definition: hevcdec.h:228
hls_prediction_unit
static void hls_prediction_unit(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int partIdx, int idx)
Definition: hevcdec.c:2096
hls_transform_unit
static int hls_transform_unit(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
Definition: hevcdec.c:1302
SliceHeader::cu_chroma_qp_offset_enabled_flag
uint8_t cu_chroma_qp_offset_enabled_flag
Definition: hevcdec.h:257
decode_lt_rps
static int decode_lt_rps(const HEVCSPS *sps, LongTermRPS *rps, GetBitContext *gb, int cur_poc, int poc_lsb)
Definition: hevcdec.c:275
ff_hevc_sao_merge_flag_decode
int ff_hevc_sao_merge_flag_decode(HEVCLocalContext *lc)
Definition: cabac.c:516
HEVCLayerContext::sps
const HEVCSPS * sps
Definition: hevcdec.h:456
ret
ret
Definition: filter_design.txt:187
H2645NAL::raw_data
const uint8_t * raw_data
Definition: h2645_parse.h:45
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
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:265
PRED_L1
@ PRED_L1
Definition: hevcdec.h:113
PredictionUnit::mvd
Mv mvd
Definition: hevcdec.h:327
SliceHeader::disable_deblocking_filter_flag
uint8_t disable_deblocking_filter_flag
slice_header_disable_deblocking_filter_flag
Definition: hevcdec.h:243
HEVCLocalContext::edge_emu_buffer2
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:431
HEVC_NAL_EOB_NUT
@ HEVC_NAL_EOB_NUT
Definition: hevc.h:66
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
FFITUTT35Meta::hdr_plus
AVBufferRef * hdr_plus
Definition: itut35.h:64
ff_hevc_set_qPy
void ff_hevc_set_qPy(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, int xBase, int yBase, int log2_cb_size)
Definition: filter.c:122
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
av_container_fifo_free
void av_container_fifo_free(AVContainerFifo **pcf)
Free a AVContainerFifo and everything in it.
Definition: container_fifo.c:101
hls_sao_param
static void hls_sao_param(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, const HEVCSPS *sps, int rx, int ry)
Definition: hevcdec.c:1210
av_refstruct_pool_alloc
AVRefStructPool * av_refstruct_pool_alloc(size_t size, unsigned flags)
Equivalent to av_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
Definition: refstruct.c:335
pos
unsigned int pos
Definition: spdifenc.c:414
AV3DReferenceDisplay::mantissa_ref_viewing_distance
uint8_t mantissa_ref_viewing_distance
The mantissa part of the reference viewing distance of the n-th reference display.
Definition: tdrdi.h:129
SliceHeader::max_num_merge_cand
uint8_t max_num_merge_cand
5 - 5_minus_max_num_merge_cand
Definition: hevcdec.h:262
ff_thread_progress_destroy
av_cold void ff_thread_progress_destroy(ThreadProgress *pro)
Destroy a ThreadProgress.
Definition: threadprogress.c:44
SliceHeader::luma_weight_l0
int16_t luma_weight_l0[16]
Definition: hevcdec.h:275
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
ff_hevc_sao_band_position_decode
int ff_hevc_sao_band_position_decode(HEVCLocalContext *lc)
Definition: cabac.c:531
HEVCLocalContext::boundary_flags
int boundary_flags
Definition: hevcdec.h:445
U
#define U(x)
Definition: vpx_arith.h:37
HWACCEL_VULKAN
#define HWACCEL_VULKAN(codec)
Definition: hwconfig.h:76
LongTermRPS
Definition: hevcdec.h:187
SliceHeader::slice_type
enum HEVCSliceType slice_type
Definition: hevcdec.h:213
AV_FRAME_DATA_DYNAMIC_HDR_PLUS
@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS
HDR dynamic metadata associated with a video frame.
Definition: frame.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:443
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
HEVCContext::layers_active_decode
unsigned layers_active_decode
Definition: hevcdec.h:502
SliceHeader::slice_qp
int8_t slice_qp
Definition: hevcdec.h:270
HEVC_NAL_CRA_NUT
@ HEVC_NAL_CRA_NUT
Definition: hevc.h:50
ff_hevc_inter_pred_idc_decode
int ff_hevc_inter_pred_idc_decode(HEVCLocalContext *lc, int nPbW, int nPbH)
Definition: cabac.c:752
AV_FILM_GRAIN_PARAMS_H274
@ AV_FILM_GRAIN_PARAMS_H274
The union is valid when interpreted as AVFilmGrainH274Params (codec.h274)
Definition: film_grain_params.h:35
FF_CODEC_RECEIVE_FRAME_CB
#define FF_CODEC_RECEIVE_FRAME_CB(func)
Definition: codec_internal.h:355
av_refstruct_ref_c
const void * av_refstruct_ref_c(const void *obj)
Analog of av_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
ff_hevc_decode_nal_sps
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, unsigned nuh_layer_id, int apply_defdispwin)
Definition: ps.c:1735
ff_h274_film_grain_params_supported
static int ff_h274_film_grain_params_supported(int model_id, enum AVPixelFormat pix_fmt)
Check whether ff_h274_apply_film_grain() supports the given parameter combination.
Definition: h274.h:39
PredictionUnit::merge_flag
uint8_t merge_flag
Definition: hevcdec.h:328
av_refstruct_replace
void av_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
av_md5_alloc
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:50
AVRational::den
int den
Denominator.
Definition: rational.h:60
SliceHeader::slice_cr_qp_offset
int slice_cr_qp_offset
Definition: hevcdec.h:251
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
map_to_alpha_format
static enum AVPixelFormat map_to_alpha_format(HEVCContext *s, enum AVPixelFormat pix_fmt)
Definition: hevcdec.c:550
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:173
HEVCContext
Definition: hevcdec.h:490
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:593
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1636
HWACCEL_MAX
#define HWACCEL_MAX
CodingUnit::pred_mode
enum PredMode pred_mode
PredMode.
Definition: hevcdec.h:294
HEVCContext::layers
HEVCLayerContext layers[HEVC_VPS_MAX_LAYERS]
Definition: hevcdec.h:498
SliceHeader::pic_order_cnt_lsb
int pic_order_cnt_lsb
Definition: hevcdec.h:215
HEVCLayerContext::DPB
HEVCFrame DPB[32]
Definition: hevcdec.h:453
AV3DReferenceDisplay::additional_shift_present_flag
uint8_t additional_shift_present_flag
An array of flags to indicates that the information about additional horizontal shift of the left and...
Definition: tdrdi.h:135
HEVCContext::rpu_buf
AVBufferRef * rpu_buf
0 or 1 Dolby Vision RPUs.
Definition: hevcdec.h:582
HEVCLocalContext::qPy_pred
int qPy_pred
Definition: hevcdec.h:418
ff_hevc_split_coding_unit_flag_decode
int ff_hevc_split_coding_unit_flag_decode(HEVCLocalContext *lc, uint8_t *tab_ct_depth, const HEVCSPS *sps, int ct_depth, int x0, int y0)
Definition: cabac.c:639
SCAN_DIAG
@ SCAN_DIAG
Definition: hevcdec.h:177
intra_prediction_unit_default_value
static void intra_prediction_unit_default_value(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCSPS *sps, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:2396
SliceHeader::rpl_modification_flag
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:233
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
SAOParams::type_idx
uint8_t type_idx[3]
sao_type_idx
Definition: dsp.h:44
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1792
HEVCWindow::right_offset
unsigned int right_offset
Definition: ps.h:93
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
av_tdrdi_alloc
AV3DReferenceDisplaysInfo * av_tdrdi_alloc(unsigned int nb_displays, size_t *out_size)
Allocate a AV3DReferenceDisplaysInfo structure and initialize its fields to default values.
Definition: tdrdi.c:25
MD5_PRI
#define MD5_PRI
ff_thread_progress_reset
static void ff_thread_progress_reset(ThreadProgress *pro)
Reset the ThreadProgress.progress counter; must only be called if the ThreadProgress is not in use in...
Definition: threadprogress.h:72
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1657
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
Update hash value.
Definition: md5.c:153
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
HEVCLocalContext::tu
TransformUnit tu
Definition: hevcdec.h:420
av_container_fifo_can_read
size_t av_container_fifo_can_read(const AVContainerFifo *cf)
Definition: container_fifo.c:185
CodingUnit::y
int y
Definition: hevcdec.h:292
src0
const pixel *const src0
Definition: h264pred_template.c:419
AVCodecInternal::draining
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition: internal.h:139
HEVC_SCALABILITY_AUXILIARY
@ HEVC_SCALABILITY_AUXILIARY
Definition: hevc.h:169
av_log_once
void av_log_once(void *avcl, int initial_level, int subsequent_level, int *state, const char *fmt,...)
Definition: log.c:451
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
ff_hevc_cu_qp_delta_abs
int ff_hevc_cu_qp_delta_abs(HEVCLocalContext *lc)
Definition: cabac.c:586
MvField::mv
Mv mv[2]
mvL0, vvL1
Definition: hevcdec.h:309
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:619
SliceHeader::inter_layer_pred
uint8_t inter_layer_pred
Definition: hevcdec.h:222
desc
const char * desc
Definition: libsvtav1.c:83
Mv
Definition: hevcdec.h:303
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
ff_hevc_clear_refs
void ff_hevc_clear_refs(HEVCLayerContext *l)
Mark all frames in DPB as unused for reference.
Definition: refs.c:67
MvField::ref_idx
int8_t ref_idx[2]
refIdxL0, refIdxL1
Definition: hevcdec.h:310
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
PRED_L0
@ PRED_L0
Definition: hevcdec.h:112
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:353
AV3DReferenceDisplay::exponent_ref_viewing_distance
uint8_t exponent_ref_viewing_distance
The exponent part of the reference viewing distance of the n-th reference display.
Definition: tdrdi.h:124
HEVC_RECOVERY_END
#define HEVC_RECOVERY_END
Definition: hevcdec.h:80
HEVCVPS
Definition: ps.h:168
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
hevc_decode_extradata
static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
Definition: hevcdec.c:3810
EPEL_EXTRA
#define EPEL_EXTRA
Definition: hevcdec.h:61
ff_h2645_sei_ctx_replace
int ff_h2645_sei_ctx_replace(H2645SEI *dst, const H2645SEI *src)
Definition: h2645_sei.c:320
ff_hevc_slice_rpl
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: refs.c:345
HEVCContext::eos
int eos
current packet contains an EOS/EOB NAL
Definition: hevcdec.h:527
get_format
static enum AVPixelFormat get_format(HEVCContext *s, const HEVCSPS *sps)
Definition: hevcdec.c:578
HEVCLayerContext::sao
SAOParams * sao
Definition: hevcdec.h:461
HEVCSPS
Definition: ps.h:252
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:321
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
pic_arrays_init
static int pic_arrays_init(HEVCLayerContext *l, const HEVCSPS *sps)
Definition: hevcdec.c:103
HEVCPPS
Definition: ps.h:371
w
uint8_t w
Definition: llvidencdsp.c:39
HEVC_NAL_TRAIL_R
@ HEVC_NAL_TRAIL_R
Definition: hevc.h:30
CodingUnit::part_mode
enum PartMode part_mode
PartMode.
Definition: hevcdec.h:295
HEVC_NAL_RADL_R
@ HEVC_NAL_RADL_R
Definition: hevc.h:36
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
hevc_init_context
static av_cold int hevc_init_context(AVCodecContext *avctx)
Definition: hevcdec.c:3981
SliceHeader::tc_offset
int tc_offset
tc_offset_div2 * 2
Definition: hevcdec.h:260
LongTermRPS::nb_refs
uint8_t nb_refs
Definition: hevcdec.h:191
HEVC_NAL_UNSPEC63
@ HEVC_NAL_UNSPEC63
Definition: hevc.h:92
AV_OPT_FLAG_EXPORT
#define AV_OPT_FLAG_EXPORT
The option is intended for exporting values to the caller.
Definition: opt.h:363
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
AVPacket
This structure stores compressed data.
Definition: packet.h:580
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
TransformUnit::cross_pf
uint8_t cross_pf
Definition: hevcdec.h:346
HEVCLocalContext::cu
CodingUnit cu
Definition: hevcdec.h:435
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:557
SliceHeader::pps_id
unsigned int pps_id
Definition: hevcdec.h:206
FFITUTT35Meta::hdr_vivid
AVBufferRef * hdr_vivid
Definition: itut35.h:66
SliceHeader::luma_weight_l1
int16_t luma_weight_l1[16]
Definition: hevcdec.h:278
hevc_luma_mv_mvp_mode
static void hevc_luma_mv_mvp_mode(HEVCLocalContext *lc, const HEVCPPS *pps, const HEVCSPS *sps, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
Definition: hevcdec.c:2049
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
HEVCParamSets::vps_list
const HEVCVPS * vps_list[HEVC_MAX_VPS_COUNT]
RefStruct references.
Definition: ps.h:509
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
OFFSET
#define OFFSET(x)
Definition: hevcdec.c:4215
ff_hevc_log2_res_scale_abs
int ff_hevc_log2_res_scale_abs(HEVCLocalContext *lc, int idx)
Definition: cabac.c:851
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:604
int32_t
int32_t
Definition: audioconvert.c:56
decode_slice_data
static int decode_slice_data(HEVCContext *s, const HEVCLayerContext *l, const H2645NAL *nal, GetBitContext *gb)
Definition: hevcdec.c:3029
PredictionUnit::mpm_idx
int mpm_idx
Definition: hevcdec.h:324
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVCodecContext::properties
attribute_deprecated unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1655
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:511
ff_hevc_sao_offset_sign_decode
int ff_hevc_sao_offset_sign_decode(HEVCLocalContext *lc)
Definition: cabac.c:551
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
PredictionUnit::chroma_mode_c
uint8_t chroma_mode_c[4]
Definition: hevcdec.h:330
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
skip_bytes
static const av_unused uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
Definition: cabac_functions.h:203
PredictionUnit::intra_pred_mode
uint8_t intra_pred_mode[4]
Definition: hevcdec.h:326
TransformUnit::is_cu_chroma_qp_offset_coded
uint8_t is_cu_chroma_qp_offset_coded
Definition: hevcdec.h:343
h
h
Definition: vp9dsp_template.c:2070
hevc_frame_end
static int hevc_frame_end(HEVCContext *s, HEVCLayerContext *l)
Definition: hevcdec.c:3489
BOUNDARY_LEFT_SLICE
#define BOUNDARY_LEFT_SLICE
Definition: hevcdec.h:439
SliceHeader::slice_qp_delta
int slice_qp_delta
Definition: hevcdec.h:249
stride
#define stride
Definition: h264pred_template.c:536
SliceHeader::slice_addr
unsigned int slice_addr
address (in raster order) of the first block in the current slice
Definition: hevcdec.h:211
SliceHeader::use_integer_mv_flag
uint8_t use_integer_mv_flag
Definition: hevcdec.h:263
avstring.h
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
HEVCLayerContext::rpl_tab_pool
struct AVRefStructPool * rpl_tab_pool
Definition: hevcdec.h:487
H2645SEI::itut_t35
FFITUTT35Meta itut_t35
Definition: h2645_sei.h:129
ff_hevc_hls_filter
void ff_hevc_hls_filter(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, int x, int y, int ctb_size)
Definition: filter.c:872
width
#define width
Definition: dsp.h:89
TransformUnit::intra_pred_mode_c
int intra_pred_mode_c
Definition: hevcdec.h:340
AV3DReferenceDisplay::left_view_id
uint16_t left_view_id
The ViewId of the left view of a stereo pair corresponding to the n-th reference display.
Definition: tdrdi.h:104
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:228
HEVC_NAL_RADL_N
@ HEVC_NAL_RADL_N
Definition: hevc.h:35
AV_FILM_GRAIN_PARAMS_AV1
@ AV_FILM_GRAIN_PARAMS_AV1
The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)
Definition: film_grain_params.h:30
hevc_sei_to_context
static int hevc_sei_to_context(AVCodecContext *avctx, HEVCSEI *sei)
Definition: hevcdec.c:4117
hls_pcm_sample
static int hls_pcm_sample(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCPPS *pps, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:1658
HEVCLocalContext::end_of_tiles_y
int end_of_tiles_y
Definition: hevcdec.h:427
AVFilmGrainParams::type
enum AVFilmGrainParamsType type
Specifies the codec for which this structure is valid.
Definition: film_grain_params.h:205
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
HEVCContext::poc_tid0
int poc_tid0
Definition: hevcdec.h:525
CodingUnit::intra_split_flag
uint8_t intra_split_flag
IntraSplitFlag.
Definition: hevcdec.h:298
H2645SEI::alternative_transfer
H2645SEIAlternativeTransfer alternative_transfer
Definition: h2645_sei.h:133
POS
#define POS(c_idx, x, y)
HEVCSPS::pix_fmt
enum AVPixelFormat pix_fmt
Definition: ps.h:265
SHIFT_CTB_WPP
#define SHIFT_CTB_WPP
Definition: hevcdec.h:45
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3823
ff_hevc_intra_chroma_pred_mode_decode
int ff_hevc_intra_chroma_pred_mode_decode(HEVCLocalContext *lc)
Definition: cabac.c:725
luma_intra_pred_mode
static int luma_intra_pred_mode(HEVCLocalContext *lc, const HEVCLayerContext *l, const HEVCSPS *sps, int x0, int y0, int pu_size, int prev_intra_luma_pred_flag)
8.4.1
Definition: hevcdec.c:2226
PART_2NxN
@ PART_2NxN
Definition: hevcdec.h:96
av_frame_side_data_add
AVFrameSideData * av_frame_side_data_add(AVFrameSideData ***sd, int *nb_sd, enum AVFrameSideDataType type, AVBufferRef **buf, unsigned int flags)
Add a new side data entry to an array from an existing AVBufferRef.
Definition: side_data.c:228
src
#define src
Definition: vp8dsp.c:248
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:404
SliceHeader::long_term_rps
LongTermRPS long_term_rps
Definition: hevcdec.h:230
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
HEVCLayerContext::is_pcm
uint8_t * is_pcm
Definition: hevcdec.h:471
HEVC_NAL_FD_NUT
@ HEVC_NAL_FD_NUT
Definition: hevc.h:67
HEVC_NAL_BLA_W_RADL
@ HEVC_NAL_BLA_W_RADL
Definition: hevc.h:46
tdrdi.h
HEVC_NAL_TRAIL_N
@ HEVC_NAL_TRAIL_N
Definition: hevc.h:29
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
HEVC_SLICE_P
@ HEVC_SLICE_P
Definition: hevc.h:97
HEVCLocalContext::cc
CABACContext cc
Definition: hevcdec.h:401
TransformUnit::cu_qp_offset_cr
int8_t cu_qp_offset_cr
Definition: hevcdec.h:345
ff_dovi_ctx_replace
void ff_dovi_ctx_replace(DOVIContext *s, const DOVIContext *s0)
Definition: dovi_rpu.c:59
HEVC_NAL_BLA_W_LP
@ HEVC_NAL_BLA_W_LP
Definition: hevc.h:45
AVDOVIDecoderConfigurationRecord
Definition: dovi_meta.h:55
ff_hevc_rem_intra_luma_pred_mode_decode
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCLocalContext *lc)
Definition: cabac.c:715