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