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