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