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