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