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