FFmpeg  3.3.9
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 "libavutil/attributes.h"
27 #include "libavutil/common.h"
28 #include "libavutil/display.h"
29 #include "libavutil/internal.h"
31 #include "libavutil/md5.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/stereo3d.h"
35 
36 #include "bswapdsp.h"
37 #include "bytestream.h"
38 #include "cabac_functions.h"
39 #include "golomb.h"
40 #include "hevc.h"
41 #include "hevc_data.h"
42 #include "hevcdec.h"
43 #include "profiles.h"
44 
45 const uint8_t ff_hevc_pel_weight[65] = { [2] = 0, [4] = 1, [6] = 2, [8] = 3, [12] = 4, [16] = 5, [24] = 6, [32] = 7, [48] = 8, [64] = 9 };
46 
47 /**
48  * NOTE: Each function hls_foo correspond to the function foo in the
49  * specification (HLS stands for High Level Syntax).
50  */
51 
52 /**
53  * Section 5.7
54  */
55 
56 /* free everything allocated by pic_arrays_init() */
58 {
59  av_freep(&s->sao);
60  av_freep(&s->deblock);
61 
62  av_freep(&s->skip_flag);
64 
65  av_freep(&s->tab_ipm);
66  av_freep(&s->cbf_luma);
67  av_freep(&s->is_pcm);
68 
69  av_freep(&s->qp_y_tab);
72 
74  av_freep(&s->vertical_bs);
75 
77  av_freep(&s->sh.size);
78  av_freep(&s->sh.offset);
79 
82 }
83 
84 /* allocate arrays that depend on frame dimensions */
85 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
86 {
87  int log2_min_cb_size = sps->log2_min_cb_size;
88  int width = sps->width;
89  int height = sps->height;
90  int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
91  ((height >> log2_min_cb_size) + 1);
92  int ctb_count = sps->ctb_width * sps->ctb_height;
93  int min_pu_size = sps->min_pu_width * sps->min_pu_height;
94 
95  s->bs_width = (width >> 2) + 1;
96  s->bs_height = (height >> 2) + 1;
97 
98  s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
99  s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
100  if (!s->sao || !s->deblock)
101  goto fail;
102 
105  if (!s->skip_flag || !s->tab_ct_depth)
106  goto fail;
107 
109  s->tab_ipm = av_mallocz(min_pu_size);
110  s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
111  if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
112  goto fail;
113 
114  s->filter_slice_edges = av_mallocz(ctb_count);
115  s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
116  sizeof(*s->tab_slice_address));
117  s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
118  sizeof(*s->qp_y_tab));
119  if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
120  goto fail;
121 
124  if (!s->horizontal_bs || !s->vertical_bs)
125  goto fail;
126 
127  s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
129  s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
131  if (!s->tab_mvf_pool || !s->rpl_tab_pool)
132  goto fail;
133 
134  return 0;
135 
136 fail:
137  pic_arrays_free(s);
138  return AVERROR(ENOMEM);
139 }
140 
142 {
143  int i = 0;
144  int j = 0;
145  uint8_t luma_weight_l0_flag[16];
146  uint8_t chroma_weight_l0_flag[16];
147  uint8_t luma_weight_l1_flag[16];
148  uint8_t chroma_weight_l1_flag[16];
149  int luma_log2_weight_denom;
150 
151  luma_log2_weight_denom = get_ue_golomb_long(gb);
152  if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7) {
153  av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
154  return AVERROR_INVALIDDATA;
155  }
156  s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
157  if (s->ps.sps->chroma_format_idc != 0) {
158  int64_t chroma_log2_weight_denom = luma_log2_weight_denom + (int64_t)get_se_golomb(gb);
159  if (chroma_log2_weight_denom < 0 || chroma_log2_weight_denom > 7) {
160  av_log(s->avctx, AV_LOG_ERROR, "chroma_log2_weight_denom %"PRId64" is invalid\n", chroma_log2_weight_denom);
161  return AVERROR_INVALIDDATA;
162  }
163  s->sh.chroma_log2_weight_denom = chroma_log2_weight_denom;
164  }
165 
166  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
167  luma_weight_l0_flag[i] = get_bits1(gb);
168  if (!luma_weight_l0_flag[i]) {
169  s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
170  s->sh.luma_offset_l0[i] = 0;
171  }
172  }
173  if (s->ps.sps->chroma_format_idc != 0) {
174  for (i = 0; i < s->sh.nb_refs[L0]; i++)
175  chroma_weight_l0_flag[i] = get_bits1(gb);
176  } else {
177  for (i = 0; i < s->sh.nb_refs[L0]; i++)
178  chroma_weight_l0_flag[i] = 0;
179  }
180  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
181  if (luma_weight_l0_flag[i]) {
182  int delta_luma_weight_l0 = get_se_golomb(gb);
183  s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
184  s->sh.luma_offset_l0[i] = get_se_golomb(gb);
185  }
186  if (chroma_weight_l0_flag[i]) {
187  for (j = 0; j < 2; j++) {
188  int delta_chroma_weight_l0 = get_se_golomb(gb);
189  int delta_chroma_offset_l0 = get_se_golomb(gb);
190 
191  if ( (int8_t)delta_chroma_weight_l0 != delta_chroma_weight_l0
192  || delta_chroma_offset_l0 < -(1<<17) || delta_chroma_offset_l0 > (1<<17)) {
193  return AVERROR_INVALIDDATA;
194  }
195 
196  s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
197  s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
198  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
199  }
200  } else {
201  s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
202  s->sh.chroma_offset_l0[i][0] = 0;
203  s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
204  s->sh.chroma_offset_l0[i][1] = 0;
205  }
206  }
207  if (s->sh.slice_type == HEVC_SLICE_B) {
208  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
209  luma_weight_l1_flag[i] = get_bits1(gb);
210  if (!luma_weight_l1_flag[i]) {
211  s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
212  s->sh.luma_offset_l1[i] = 0;
213  }
214  }
215  if (s->ps.sps->chroma_format_idc != 0) {
216  for (i = 0; i < s->sh.nb_refs[L1]; i++)
217  chroma_weight_l1_flag[i] = get_bits1(gb);
218  } else {
219  for (i = 0; i < s->sh.nb_refs[L1]; i++)
220  chroma_weight_l1_flag[i] = 0;
221  }
222  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
223  if (luma_weight_l1_flag[i]) {
224  int delta_luma_weight_l1 = get_se_golomb(gb);
225  s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
226  s->sh.luma_offset_l1[i] = get_se_golomb(gb);
227  }
228  if (chroma_weight_l1_flag[i]) {
229  for (j = 0; j < 2; j++) {
230  int delta_chroma_weight_l1 = get_se_golomb(gb);
231  int delta_chroma_offset_l1 = get_se_golomb(gb);
232 
233  if ( (int8_t)delta_chroma_weight_l1 != delta_chroma_weight_l1
234  || delta_chroma_offset_l1 < -(1<<17) || delta_chroma_offset_l1 > (1<<17)) {
235  return AVERROR_INVALIDDATA;
236  }
237 
238  s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
239  s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
240  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
241  }
242  } else {
243  s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
244  s->sh.chroma_offset_l1[i][0] = 0;
245  s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
246  s->sh.chroma_offset_l1[i][1] = 0;
247  }
248  }
249  }
250  return 0;
251 }
252 
254 {
255  const HEVCSPS *sps = s->ps.sps;
256  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
257  int prev_delta_msb = 0;
258  unsigned int nb_sps = 0, nb_sh;
259  int i;
260 
261  rps->nb_refs = 0;
263  return 0;
264 
265  if (sps->num_long_term_ref_pics_sps > 0)
266  nb_sps = get_ue_golomb_long(gb);
267  nb_sh = get_ue_golomb_long(gb);
268 
269  if (nb_sps > sps->num_long_term_ref_pics_sps)
270  return AVERROR_INVALIDDATA;
271  if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
272  return AVERROR_INVALIDDATA;
273 
274  rps->nb_refs = nb_sh + nb_sps;
275 
276  for (i = 0; i < rps->nb_refs; i++) {
277  uint8_t delta_poc_msb_present;
278 
279  if (i < nb_sps) {
280  uint8_t lt_idx_sps = 0;
281 
282  if (sps->num_long_term_ref_pics_sps > 1)
283  lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
284 
285  rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
286  rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
287  } else {
288  rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
289  rps->used[i] = get_bits1(gb);
290  }
291 
292  delta_poc_msb_present = get_bits1(gb);
293  if (delta_poc_msb_present) {
294  int64_t delta = get_ue_golomb_long(gb);
295  int64_t poc;
296 
297  if (i && i != nb_sps)
298  delta += prev_delta_msb;
299 
300  poc = rps->poc[i] + s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
301  if (poc != (int32_t)poc)
302  return AVERROR_INVALIDDATA;
303  rps->poc[i] = poc;
304  prev_delta_msb = delta;
305  }
306  }
307 
308  return 0;
309 }
310 
311 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
312  const HEVCSPS *sps)
313 {
314  const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
315  unsigned int num = 0, den = 0;
316 
317  avctx->pix_fmt = sps->pix_fmt;
318  avctx->coded_width = sps->width;
319  avctx->coded_height = sps->height;
320  avctx->width = sps->output_width;
321  avctx->height = sps->output_height;
323  avctx->profile = sps->ptl.general_ptl.profile_idc;
324  avctx->level = sps->ptl.general_ptl.level_idc;
325 
326  ff_set_sar(avctx, sps->vui.sar);
327 
331  else
332  avctx->color_range = AVCOL_RANGE_MPEG;
333 
335  avctx->color_primaries = sps->vui.colour_primaries;
336  avctx->color_trc = sps->vui.transfer_characteristic;
337  avctx->colorspace = sps->vui.matrix_coeffs;
338  } else {
342  }
343 
344  if (vps->vps_timing_info_present_flag) {
345  num = vps->vps_num_units_in_tick;
346  den = vps->vps_time_scale;
347  } else if (sps->vui.vui_timing_info_present_flag) {
348  num = sps->vui.vui_num_units_in_tick;
349  den = sps->vui.vui_time_scale;
350  }
351 
352  if (num != 0 && den != 0)
353  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
354  num, den, 1 << 30);
355 }
356 
357 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
358 {
359  #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
361  int ret, i;
362 
363  pic_arrays_free(s);
364  s->ps.sps = NULL;
365  s->ps.vps = NULL;
366 
367  if (!sps)
368  return 0;
369 
370  ret = pic_arrays_init(s, sps);
371  if (ret < 0)
372  goto fail;
373 
374  export_stream_params(s->avctx, &s->ps, sps);
375 
376  switch (sps->pix_fmt) {
377  case AV_PIX_FMT_YUV420P:
378  case AV_PIX_FMT_YUVJ420P:
379 #if CONFIG_HEVC_DXVA2_HWACCEL
380  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
381 #endif
382 #if CONFIG_HEVC_D3D11VA_HWACCEL
383  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
384 #endif
385 #if CONFIG_HEVC_VAAPI_HWACCEL
386  *fmt++ = AV_PIX_FMT_VAAPI;
387 #endif
388 #if CONFIG_HEVC_VDPAU_HWACCEL
389  *fmt++ = AV_PIX_FMT_VDPAU;
390 #endif
391  break;
393 #if CONFIG_HEVC_DXVA2_HWACCEL
394  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
395 #endif
396 #if CONFIG_HEVC_D3D11VA_HWACCEL
397  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
398 #endif
399 #if CONFIG_HEVC_VAAPI_HWACCEL
400  *fmt++ = AV_PIX_FMT_VAAPI;
401 #endif
402  break;
403  }
404 
405  if (pix_fmt == AV_PIX_FMT_NONE) {
406  *fmt++ = sps->pix_fmt;
407  *fmt = AV_PIX_FMT_NONE;
408 
409  ret = ff_thread_get_format(s->avctx, pix_fmts);
410  if (ret < 0)
411  goto fail;
412  s->avctx->pix_fmt = ret;
413  }
414  else {
415  s->avctx->pix_fmt = pix_fmt;
416  }
417 
418  ff_hevc_pred_init(&s->hpc, sps->bit_depth);
419  ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
420  ff_videodsp_init (&s->vdsp, sps->bit_depth);
421 
422  for (i = 0; i < 3; i++) {
425  }
426 
427  if (sps->sao_enabled && !s->avctx->hwaccel) {
428  int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
429  int c_idx;
430 
431  for(c_idx = 0; c_idx < c_count; c_idx++) {
432  int w = sps->width >> sps->hshift[c_idx];
433  int h = sps->height >> sps->vshift[c_idx];
434  s->sao_pixel_buffer_h[c_idx] =
435  av_malloc((w * 2 * sps->ctb_height) <<
436  sps->pixel_shift);
437  s->sao_pixel_buffer_v[c_idx] =
438  av_malloc((h * 2 * sps->ctb_width) <<
439  sps->pixel_shift);
440  }
441  }
442 
443  s->ps.sps = sps;
444  s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
445 
446  return 0;
447 
448 fail:
449  pic_arrays_free(s);
450  s->ps.sps = NULL;
451  return ret;
452 }
453 
455 {
456  GetBitContext *gb = &s->HEVClc->gb;
457  SliceHeader *sh = &s->sh;
458  int i, ret;
459 
460  // Coded parameters
462  if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
463  s->seq_decode = (s->seq_decode + 1) & 0xff;
464  s->max_ra = INT_MAX;
465  if (IS_IDR(s))
467  }
469  if (IS_IRAP(s))
471 
472  sh->pps_id = get_ue_golomb_long(gb);
473  if (sh->pps_id >= HEVC_MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
474  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
475  return AVERROR_INVALIDDATA;
476  }
477  if (!sh->first_slice_in_pic_flag &&
478  s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
479  av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
480  return AVERROR_INVALIDDATA;
481  }
482  s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
483  if (s->nal_unit_type == HEVC_NAL_CRA_NUT && s->last_eos == 1)
485 
486  if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
487  const HEVCSPS* last_sps = s->ps.sps;
488  s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
489  if (last_sps && IS_IRAP(s) && s->nal_unit_type != HEVC_NAL_CRA_NUT) {
490  if (s->ps.sps->width != last_sps->width || s->ps.sps->height != last_sps->height ||
492  last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
494  }
496  ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
497  if (ret < 0)
498  return ret;
499 
500  s->seq_decode = (s->seq_decode + 1) & 0xff;
501  s->max_ra = INT_MAX;
502  }
503 
505  if (!sh->first_slice_in_pic_flag) {
506  int slice_address_length;
507 
510 
511  slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
512  s->ps.sps->ctb_height);
513  sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
514  if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
516  "Invalid slice segment address: %u.\n",
517  sh->slice_segment_addr);
518  return AVERROR_INVALIDDATA;
519  }
520 
521  if (!sh->dependent_slice_segment_flag) {
522  sh->slice_addr = sh->slice_segment_addr;
523  s->slice_idx++;
524  }
525  } else {
526  sh->slice_segment_addr = sh->slice_addr = 0;
527  s->slice_idx = 0;
528  s->slice_initialized = 0;
529  }
530 
531  if (!sh->dependent_slice_segment_flag) {
532  s->slice_initialized = 0;
533 
534  for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
535  skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
536 
537  sh->slice_type = get_ue_golomb_long(gb);
538  if (!(sh->slice_type == HEVC_SLICE_I ||
539  sh->slice_type == HEVC_SLICE_P ||
540  sh->slice_type == HEVC_SLICE_B)) {
541  av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
542  sh->slice_type);
543  return AVERROR_INVALIDDATA;
544  }
545  if (IS_IRAP(s) && sh->slice_type != HEVC_SLICE_I) {
546  av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
547  return AVERROR_INVALIDDATA;
548  }
549 
550  // when flag is not present, picture is inferred to be output
551  sh->pic_output_flag = 1;
553  sh->pic_output_flag = get_bits1(gb);
554 
556  sh->colour_plane_id = get_bits(gb, 2);
557 
558  if (!IS_IDR(s)) {
559  int poc, pos;
560 
563  if (!sh->first_slice_in_pic_flag && poc != s->poc) {
565  "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
567  return AVERROR_INVALIDDATA;
568  poc = s->poc;
569  }
570  s->poc = poc;
571 
573  pos = get_bits_left(gb);
575  ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
576  if (ret < 0)
577  return ret;
578 
579  sh->short_term_rps = &sh->slice_rps;
580  } else {
581  int numbits, rps_idx;
582 
583  if (!s->ps.sps->nb_st_rps) {
584  av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
585  return AVERROR_INVALIDDATA;
586  }
587 
588  numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
589  rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
590  sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
591  }
593 
594  pos = get_bits_left(gb);
595  ret = decode_lt_rps(s, &sh->long_term_rps, gb);
596  if (ret < 0) {
597  av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
599  return AVERROR_INVALIDDATA;
600  }
602 
605  else
607  } else {
608  s->sh.short_term_rps = NULL;
609  s->poc = 0;
610  }
611 
612  /* 8.3.1 */
613  if (sh->first_slice_in_pic_flag && s->temporal_id == 0 &&
621  s->pocTid0 = s->poc;
622 
623  if (s->ps.sps->sao_enabled) {
625  if (s->ps.sps->chroma_format_idc) {
628  }
629  } else {
633  }
634 
635  sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
636  if (sh->slice_type == HEVC_SLICE_P || sh->slice_type == HEVC_SLICE_B) {
637  int nb_refs;
638 
640  if (sh->slice_type == HEVC_SLICE_B)
642 
643  if (get_bits1(gb)) { // num_ref_idx_active_override_flag
644  sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
645  if (sh->slice_type == HEVC_SLICE_B)
646  sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
647  }
648  if (sh->nb_refs[L0] > HEVC_MAX_REFS || sh->nb_refs[L1] > HEVC_MAX_REFS) {
649  av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
650  sh->nb_refs[L0], sh->nb_refs[L1]);
651  return AVERROR_INVALIDDATA;
652  }
653 
654  sh->rpl_modification_flag[0] = 0;
655  sh->rpl_modification_flag[1] = 0;
656  nb_refs = ff_hevc_frame_nb_refs(s);
657  if (!nb_refs) {
658  av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
659  return AVERROR_INVALIDDATA;
660  }
661 
662  if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
663  sh->rpl_modification_flag[0] = get_bits1(gb);
664  if (sh->rpl_modification_flag[0]) {
665  for (i = 0; i < sh->nb_refs[L0]; i++)
666  sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
667  }
668 
669  if (sh->slice_type == HEVC_SLICE_B) {
670  sh->rpl_modification_flag[1] = get_bits1(gb);
671  if (sh->rpl_modification_flag[1] == 1)
672  for (i = 0; i < sh->nb_refs[L1]; i++)
673  sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
674  }
675  }
676 
677  if (sh->slice_type == HEVC_SLICE_B)
678  sh->mvd_l1_zero_flag = get_bits1(gb);
679 
681  sh->cabac_init_flag = get_bits1(gb);
682  else
683  sh->cabac_init_flag = 0;
684 
685  sh->collocated_ref_idx = 0;
687  sh->collocated_list = L0;
688  if (sh->slice_type == HEVC_SLICE_B)
689  sh->collocated_list = !get_bits1(gb);
690 
691  if (sh->nb_refs[sh->collocated_list] > 1) {
693  if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
695  "Invalid collocated_ref_idx: %d.\n",
696  sh->collocated_ref_idx);
697  return AVERROR_INVALIDDATA;
698  }
699  }
700  }
701 
702  if ((s->ps.pps->weighted_pred_flag && sh->slice_type == HEVC_SLICE_P) ||
704  int ret = pred_weight_table(s, gb);
705  if (ret < 0)
706  return ret;
707  }
708 
710  if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
712  "Invalid number of merging MVP candidates: %d.\n",
713  sh->max_num_merge_cand);
714  return AVERROR_INVALIDDATA;
715  }
716  }
717 
718  sh->slice_qp_delta = get_se_golomb(gb);
719 
723  } else {
724  sh->slice_cb_qp_offset = 0;
725  sh->slice_cr_qp_offset = 0;
726  }
727 
730  else
732 
734  int deblocking_filter_override_flag = 0;
735 
737  deblocking_filter_override_flag = get_bits1(gb);
738 
739  if (deblocking_filter_override_flag) {
742  sh->beta_offset = get_se_golomb(gb) * 2;
743  sh->tc_offset = get_se_golomb(gb) * 2;
744  }
745  } else {
747  sh->beta_offset = s->ps.pps->beta_offset;
748  sh->tc_offset = s->ps.pps->tc_offset;
749  }
750  } else {
752  sh->beta_offset = 0;
753  sh->tc_offset = 0;
754  }
755 
761  } else {
763  }
764  } else if (!s->slice_initialized) {
765  av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
766  return AVERROR_INVALIDDATA;
767  }
768 
769  sh->num_entry_point_offsets = 0;
771  unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
772  // It would be possible to bound this tighter but this here is simpler
773  if (num_entry_point_offsets > get_bits_left(gb)) {
774  av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
775  return AVERROR_INVALIDDATA;
776  }
777 
778  sh->num_entry_point_offsets = num_entry_point_offsets;
779  if (sh->num_entry_point_offsets > 0) {
780  int offset_len = get_ue_golomb_long(gb) + 1;
781 
782  if (offset_len < 1 || offset_len > 32) {
783  sh->num_entry_point_offsets = 0;
784  av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
785  return AVERROR_INVALIDDATA;
786  }
787 
789  av_freep(&sh->offset);
790  av_freep(&sh->size);
791  sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
792  sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
793  sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
794  if (!sh->entry_point_offset || !sh->offset || !sh->size) {
795  sh->num_entry_point_offsets = 0;
796  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
797  return AVERROR(ENOMEM);
798  }
799  for (i = 0; i < sh->num_entry_point_offsets; i++) {
800  unsigned val = get_bits_long(gb, offset_len);
801  sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
802  }
803  if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
804  s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
805  s->threads_number = 1;
806  } else
807  s->enable_parallel_tiles = 0;
808  } else
809  s->enable_parallel_tiles = 0;
810  }
811 
813  unsigned int length = get_ue_golomb_long(gb);
814  if (length*8LL > get_bits_left(gb)) {
815  av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
816  return AVERROR_INVALIDDATA;
817  }
818  for (i = 0; i < length; i++)
819  skip_bits(gb, 8); // slice_header_extension_data_byte
820  }
821 
822  // Inferred parameters
823  sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
824  if (sh->slice_qp > 51 ||
825  sh->slice_qp < -s->ps.sps->qp_bd_offset) {
827  "The slice_qp %d is outside the valid range "
828  "[%d, 51].\n",
829  sh->slice_qp,
830  -s->ps.sps->qp_bd_offset);
831  return AVERROR_INVALIDDATA;
832  }
833 
835 
837  av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
838  return AVERROR_INVALIDDATA;
839  }
840 
841  if (get_bits_left(gb) < 0) {
843  "Overread slice header by %d bits\n", -get_bits_left(gb));
844  return AVERROR_INVALIDDATA;
845  }
846 
848 
850  s->HEVClc->qp_y = s->sh.slice_qp;
851 
852  s->slice_initialized = 1;
853  s->HEVClc->tu.cu_qp_offset_cb = 0;
854  s->HEVClc->tu.cu_qp_offset_cr = 0;
855 
856  return 0;
857 }
858 
859 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
860 
861 #define SET_SAO(elem, value) \
862 do { \
863  if (!sao_merge_up_flag && !sao_merge_left_flag) \
864  sao->elem = value; \
865  else if (sao_merge_left_flag) \
866  sao->elem = CTB(s->sao, rx-1, ry).elem; \
867  else if (sao_merge_up_flag) \
868  sao->elem = CTB(s->sao, rx, ry-1).elem; \
869  else \
870  sao->elem = 0; \
871 } while (0)
872 
873 static void hls_sao_param(HEVCContext *s, int rx, int ry)
874 {
875  HEVCLocalContext *lc = s->HEVClc;
876  int sao_merge_left_flag = 0;
877  int sao_merge_up_flag = 0;
878  SAOParams *sao = &CTB(s->sao, rx, ry);
879  int c_idx, i;
880 
883  if (rx > 0) {
884  if (lc->ctb_left_flag)
885  sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
886  }
887  if (ry > 0 && !sao_merge_left_flag) {
888  if (lc->ctb_up_flag)
889  sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
890  }
891  }
892 
893  for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
894  int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
896 
897  if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
898  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
899  continue;
900  }
901 
902  if (c_idx == 2) {
903  sao->type_idx[2] = sao->type_idx[1];
904  sao->eo_class[2] = sao->eo_class[1];
905  } else {
906  SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
907  }
908 
909  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
910  continue;
911 
912  for (i = 0; i < 4; i++)
913  SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
914 
915  if (sao->type_idx[c_idx] == SAO_BAND) {
916  for (i = 0; i < 4; i++) {
917  if (sao->offset_abs[c_idx][i]) {
918  SET_SAO(offset_sign[c_idx][i],
920  } else {
921  sao->offset_sign[c_idx][i] = 0;
922  }
923  }
924  SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
925  } else if (c_idx != 2) {
926  SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
927  }
928 
929  // Inferred parameters
930  sao->offset_val[c_idx][0] = 0;
931  for (i = 0; i < 4; i++) {
932  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
933  if (sao->type_idx[c_idx] == SAO_EDGE) {
934  if (i > 1)
935  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
936  } else if (sao->offset_sign[c_idx][i]) {
937  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
938  }
939  sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
940  }
941  }
942 }
943 
944 #undef SET_SAO
945 #undef CTB
946 
947 static int hls_cross_component_pred(HEVCContext *s, int idx) {
948  HEVCLocalContext *lc = s->HEVClc;
949  int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
950 
951  if (log2_res_scale_abs_plus1 != 0) {
952  int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
953  lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
954  (1 - 2 * res_scale_sign_flag);
955  } else {
956  lc->tu.res_scale_val = 0;
957  }
958 
959 
960  return 0;
961 }
962 
963 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
964  int xBase, int yBase, int cb_xBase, int cb_yBase,
965  int log2_cb_size, int log2_trafo_size,
966  int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
967 {
968  HEVCLocalContext *lc = s->HEVClc;
969  const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
970  int i;
971 
972  if (lc->cu.pred_mode == MODE_INTRA) {
973  int trafo_size = 1 << log2_trafo_size;
974  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
975 
976  s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
977  }
978 
979  if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
980  (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
981  int scan_idx = SCAN_DIAG;
982  int scan_idx_c = SCAN_DIAG;
983  int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
984  (s->ps.sps->chroma_format_idc == 2 &&
985  (cbf_cb[1] || cbf_cr[1]));
986 
989  if (lc->tu.cu_qp_delta != 0)
990  if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
991  lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
992  lc->tu.is_cu_qp_delta_coded = 1;
993 
994  if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
995  lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
997  "The cu_qp_delta %d is outside the valid range "
998  "[%d, %d].\n",
999  lc->tu.cu_qp_delta,
1000  -(26 + s->ps.sps->qp_bd_offset / 2),
1001  (25 + s->ps.sps->qp_bd_offset / 2));
1002  return AVERROR_INVALIDDATA;
1003  }
1004 
1005  ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
1006  }
1007 
1008  if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
1010  int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
1011  if (cu_chroma_qp_offset_flag) {
1012  int cu_chroma_qp_offset_idx = 0;
1013  if (s->ps.pps->chroma_qp_offset_list_len_minus1 > 0) {
1014  cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
1016  "cu_chroma_qp_offset_idx not yet tested.\n");
1017  }
1018  lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
1019  lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
1020  } else {
1021  lc->tu.cu_qp_offset_cb = 0;
1022  lc->tu.cu_qp_offset_cr = 0;
1023  }
1025  }
1026 
1027  if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1028  if (lc->tu.intra_pred_mode >= 6 &&
1029  lc->tu.intra_pred_mode <= 14) {
1030  scan_idx = SCAN_VERT;
1031  } else if (lc->tu.intra_pred_mode >= 22 &&
1032  lc->tu.intra_pred_mode <= 30) {
1033  scan_idx = SCAN_HORIZ;
1034  }
1035 
1036  if (lc->tu.intra_pred_mode_c >= 6 &&
1037  lc->tu.intra_pred_mode_c <= 14) {
1038  scan_idx_c = SCAN_VERT;
1039  } else if (lc->tu.intra_pred_mode_c >= 22 &&
1040  lc->tu.intra_pred_mode_c <= 30) {
1041  scan_idx_c = SCAN_HORIZ;
1042  }
1043  }
1044 
1045  lc->tu.cross_pf = 0;
1046 
1047  if (cbf_luma)
1048  ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1049  if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1050  int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1051  int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1052  lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1053  (lc->cu.pred_mode == MODE_INTER ||
1054  (lc->tu.chroma_mode_c == 4)));
1055 
1056  if (lc->tu.cross_pf) {
1058  }
1059  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1060  if (lc->cu.pred_mode == MODE_INTRA) {
1061  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1062  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1063  }
1064  if (cbf_cb[i])
1065  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1066  log2_trafo_size_c, scan_idx_c, 1);
1067  else
1068  if (lc->tu.cross_pf) {
1069  ptrdiff_t stride = s->frame->linesize[1];
1070  int hshift = s->ps.sps->hshift[1];
1071  int vshift = s->ps.sps->vshift[1];
1072  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1073  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1074  int size = 1 << log2_trafo_size_c;
1075 
1076  uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1077  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1078  for (i = 0; i < (size * size); i++) {
1079  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1080  }
1081  s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1082  }
1083  }
1084 
1085  if (lc->tu.cross_pf) {
1087  }
1088  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1089  if (lc->cu.pred_mode == MODE_INTRA) {
1090  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1091  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1092  }
1093  if (cbf_cr[i])
1094  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1095  log2_trafo_size_c, scan_idx_c, 2);
1096  else
1097  if (lc->tu.cross_pf) {
1098  ptrdiff_t stride = s->frame->linesize[2];
1099  int hshift = s->ps.sps->hshift[2];
1100  int vshift = s->ps.sps->vshift[2];
1101  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1102  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1103  int size = 1 << log2_trafo_size_c;
1104 
1105  uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1106  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1107  for (i = 0; i < (size * size); i++) {
1108  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1109  }
1110  s->hevcdsp.add_residual[log2_trafo_size_c-2](dst, coeffs, stride);
1111  }
1112  }
1113  } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1114  int trafo_size_h = 1 << (log2_trafo_size + 1);
1115  int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1116  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1117  if (lc->cu.pred_mode == MODE_INTRA) {
1118  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1119  trafo_size_h, trafo_size_v);
1120  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1121  }
1122  if (cbf_cb[i])
1123  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1124  log2_trafo_size, scan_idx_c, 1);
1125  }
1126  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1127  if (lc->cu.pred_mode == MODE_INTRA) {
1128  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1129  trafo_size_h, trafo_size_v);
1130  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1131  }
1132  if (cbf_cr[i])
1133  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1134  log2_trafo_size, scan_idx_c, 2);
1135  }
1136  }
1137  } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1138  if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1139  int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1140  int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1141  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1142  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1143  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1144  if (s->ps.sps->chroma_format_idc == 2) {
1145  ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1146  trafo_size_h, trafo_size_v);
1147  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1148  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1149  }
1150  } else if (blk_idx == 3) {
1151  int trafo_size_h = 1 << (log2_trafo_size + 1);
1152  int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1153  ff_hevc_set_neighbour_available(s, xBase, yBase,
1154  trafo_size_h, trafo_size_v);
1155  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1156  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1157  if (s->ps.sps->chroma_format_idc == 2) {
1158  ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1159  trafo_size_h, trafo_size_v);
1160  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1161  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1162  }
1163  }
1164  }
1165 
1166  return 0;
1167 }
1168 
1169 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1170 {
1171  int cb_size = 1 << log2_cb_size;
1172  int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1173 
1174  int min_pu_width = s->ps.sps->min_pu_width;
1175  int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1176  int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1177  int i, j;
1178 
1179  for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1180  for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1181  s->is_pcm[i + j * min_pu_width] = 2;
1182 }
1183 
1184 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1185  int xBase, int yBase, int cb_xBase, int cb_yBase,
1186  int log2_cb_size, int log2_trafo_size,
1187  int trafo_depth, int blk_idx,
1188  const int *base_cbf_cb, const int *base_cbf_cr)
1189 {
1190  HEVCLocalContext *lc = s->HEVClc;
1191  uint8_t split_transform_flag;
1192  int cbf_cb[2];
1193  int cbf_cr[2];
1194  int ret;
1195 
1196  cbf_cb[0] = base_cbf_cb[0];
1197  cbf_cb[1] = base_cbf_cb[1];
1198  cbf_cr[0] = base_cbf_cr[0];
1199  cbf_cr[1] = base_cbf_cr[1];
1200 
1201  if (lc->cu.intra_split_flag) {
1202  if (trafo_depth == 1) {
1203  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1204  if (s->ps.sps->chroma_format_idc == 3) {
1205  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1206  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1207  } else {
1209  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1210  }
1211  }
1212  } else {
1213  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1215  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1216  }
1217 
1218  if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1219  log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1220  trafo_depth < lc->cu.max_trafo_depth &&
1221  !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1222  split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1223  } else {
1224  int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1225  lc->cu.pred_mode == MODE_INTER &&
1226  lc->cu.part_mode != PART_2Nx2N &&
1227  trafo_depth == 0;
1228 
1229  split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1230  (lc->cu.intra_split_flag && trafo_depth == 0) ||
1231  inter_split;
1232  }
1233 
1234  if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1235  if (trafo_depth == 0 || cbf_cb[0]) {
1236  cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1237  if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1238  cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1239  }
1240  }
1241 
1242  if (trafo_depth == 0 || cbf_cr[0]) {
1243  cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1244  if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1245  cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1246  }
1247  }
1248  }
1249 
1250  if (split_transform_flag) {
1251  const int trafo_size_split = 1 << (log2_trafo_size - 1);
1252  const int x1 = x0 + trafo_size_split;
1253  const int y1 = y0 + trafo_size_split;
1254 
1255 #define SUBDIVIDE(x, y, idx) \
1256 do { \
1257  ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1258  log2_trafo_size - 1, trafo_depth + 1, idx, \
1259  cbf_cb, cbf_cr); \
1260  if (ret < 0) \
1261  return ret; \
1262 } while (0)
1263 
1264  SUBDIVIDE(x0, y0, 0);
1265  SUBDIVIDE(x1, y0, 1);
1266  SUBDIVIDE(x0, y1, 2);
1267  SUBDIVIDE(x1, y1, 3);
1268 
1269 #undef SUBDIVIDE
1270  } else {
1271  int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1272  int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1273  int min_tu_width = s->ps.sps->min_tb_width;
1274  int cbf_luma = 1;
1275 
1276  if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1277  cbf_cb[0] || cbf_cr[0] ||
1278  (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1279  cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1280  }
1281 
1282  ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1283  log2_cb_size, log2_trafo_size,
1284  blk_idx, cbf_luma, cbf_cb, cbf_cr);
1285  if (ret < 0)
1286  return ret;
1287  // TODO: store cbf_luma somewhere else
1288  if (cbf_luma) {
1289  int i, j;
1290  for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1291  for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1292  int x_tu = (x0 + j) >> log2_min_tu_size;
1293  int y_tu = (y0 + i) >> log2_min_tu_size;
1294  s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1295  }
1296  }
1298  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1301  set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1302  }
1303  }
1304  return 0;
1305 }
1306 
1307 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1308 {
1309  HEVCLocalContext *lc = s->HEVClc;
1310  GetBitContext gb;
1311  int cb_size = 1 << log2_cb_size;
1312  ptrdiff_t stride0 = s->frame->linesize[0];
1313  ptrdiff_t stride1 = s->frame->linesize[1];
1314  ptrdiff_t stride2 = s->frame->linesize[2];
1315  uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1316  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)];
1317  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)];
1318 
1319  int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1320  (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1321  ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1322  s->ps.sps->pcm.bit_depth_chroma;
1323  const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1324  int ret;
1325 
1327  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1328 
1329  ret = init_get_bits(&gb, pcm, length);
1330  if (ret < 0)
1331  return ret;
1332 
1333  s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1334  if (s->ps.sps->chroma_format_idc) {
1335  s->hevcdsp.put_pcm(dst1, stride1,
1336  cb_size >> s->ps.sps->hshift[1],
1337  cb_size >> s->ps.sps->vshift[1],
1338  &gb, s->ps.sps->pcm.bit_depth_chroma);
1339  s->hevcdsp.put_pcm(dst2, stride2,
1340  cb_size >> s->ps.sps->hshift[2],
1341  cb_size >> s->ps.sps->vshift[2],
1342  &gb, s->ps.sps->pcm.bit_depth_chroma);
1343  }
1344 
1345  return 0;
1346 }
1347 
1348 /**
1349  * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1350  *
1351  * @param s HEVC decoding context
1352  * @param dst target buffer for block data at block position
1353  * @param dststride stride of the dst buffer
1354  * @param ref reference picture buffer at origin (0, 0)
1355  * @param mv motion vector (relative to block position) to get pixel data from
1356  * @param x_off horizontal position of block from origin (0, 0)
1357  * @param y_off vertical position of block from origin (0, 0)
1358  * @param block_w width of block
1359  * @param block_h height of block
1360  * @param luma_weight weighting factor applied to the luma prediction
1361  * @param luma_offset additive offset applied to the luma prediction value
1362  */
1363 
1364 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1365  AVFrame *ref, const Mv *mv, int x_off, int y_off,
1366  int block_w, int block_h, int luma_weight, int luma_offset)
1367 {
1368  HEVCLocalContext *lc = s->HEVClc;
1369  uint8_t *src = ref->data[0];
1370  ptrdiff_t srcstride = ref->linesize[0];
1371  int pic_width = s->ps.sps->width;
1372  int pic_height = s->ps.sps->height;
1373  int mx = mv->x & 3;
1374  int my = mv->y & 3;
1375  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1377  int idx = ff_hevc_pel_weight[block_w];
1378 
1379  x_off += mv->x >> 2;
1380  y_off += mv->y >> 2;
1381  src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1382 
1383  if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1384  x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1385  y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1386  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1387  int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1388  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1389 
1390  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1391  edge_emu_stride, srcstride,
1392  block_w + QPEL_EXTRA,
1393  block_h + QPEL_EXTRA,
1394  x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1395  pic_width, pic_height);
1396  src = lc->edge_emu_buffer + buf_offset;
1397  srcstride = edge_emu_stride;
1398  }
1399 
1400  if (!weight_flag)
1401  s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1402  block_h, mx, my, block_w);
1403  else
1404  s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1405  block_h, s->sh.luma_log2_weight_denom,
1406  luma_weight, luma_offset, mx, my, block_w);
1407 }
1408 
1409 /**
1410  * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1411  *
1412  * @param s HEVC decoding context
1413  * @param dst target buffer for block data at block position
1414  * @param dststride stride of the dst buffer
1415  * @param ref0 reference picture0 buffer at origin (0, 0)
1416  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1417  * @param x_off horizontal position of block from origin (0, 0)
1418  * @param y_off vertical position of block from origin (0, 0)
1419  * @param block_w width of block
1420  * @param block_h height of block
1421  * @param ref1 reference picture1 buffer at origin (0, 0)
1422  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1423  * @param current_mv current motion vector structure
1424  */
1425  static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1426  AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1427  int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1428 {
1429  HEVCLocalContext *lc = s->HEVClc;
1430  ptrdiff_t src0stride = ref0->linesize[0];
1431  ptrdiff_t src1stride = ref1->linesize[0];
1432  int pic_width = s->ps.sps->width;
1433  int pic_height = s->ps.sps->height;
1434  int mx0 = mv0->x & 3;
1435  int my0 = mv0->y & 3;
1436  int mx1 = mv1->x & 3;
1437  int my1 = mv1->y & 3;
1438  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1440  int x_off0 = x_off + (mv0->x >> 2);
1441  int y_off0 = y_off + (mv0->y >> 2);
1442  int x_off1 = x_off + (mv1->x >> 2);
1443  int y_off1 = y_off + (mv1->y >> 2);
1444  int idx = ff_hevc_pel_weight[block_w];
1445 
1446  uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1447  uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1448 
1449  if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1450  x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1451  y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1452  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1453  int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1454  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1455 
1456  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1457  edge_emu_stride, src0stride,
1458  block_w + QPEL_EXTRA,
1459  block_h + QPEL_EXTRA,
1460  x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1461  pic_width, pic_height);
1462  src0 = lc->edge_emu_buffer + buf_offset;
1463  src0stride = edge_emu_stride;
1464  }
1465 
1466  if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1467  x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1468  y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1469  const ptrdiff_t edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1470  int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1471  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1472 
1473  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1474  edge_emu_stride, src1stride,
1475  block_w + QPEL_EXTRA,
1476  block_h + QPEL_EXTRA,
1477  x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1478  pic_width, pic_height);
1479  src1 = lc->edge_emu_buffer2 + buf_offset;
1480  src1stride = edge_emu_stride;
1481  }
1482 
1483  s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1484  block_h, mx0, my0, block_w);
1485  if (!weight_flag)
1486  s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1487  block_h, mx1, my1, block_w);
1488  else
1489  s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1490  block_h, s->sh.luma_log2_weight_denom,
1491  s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1492  s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1493  s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1494  s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1495  mx1, my1, block_w);
1496 
1497 }
1498 
1499 /**
1500  * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1501  *
1502  * @param s HEVC decoding context
1503  * @param dst1 target buffer for block data at block position (U plane)
1504  * @param dst2 target buffer for block data at block position (V plane)
1505  * @param dststride stride of the dst1 and dst2 buffers
1506  * @param ref reference picture buffer at origin (0, 0)
1507  * @param mv motion vector (relative to block position) to get pixel data from
1508  * @param x_off horizontal position of block from origin (0, 0)
1509  * @param y_off vertical position of block from origin (0, 0)
1510  * @param block_w width of block
1511  * @param block_h height of block
1512  * @param chroma_weight weighting factor applied to the chroma prediction
1513  * @param chroma_offset additive offset applied to the chroma prediction value
1514  */
1515 
1516 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1517  ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1518  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1519 {
1520  HEVCLocalContext *lc = s->HEVClc;
1521  int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1522  int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1523  const Mv *mv = &current_mv->mv[reflist];
1524  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1526  int idx = ff_hevc_pel_weight[block_w];
1527  int hshift = s->ps.sps->hshift[1];
1528  int vshift = s->ps.sps->vshift[1];
1529  intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1530  intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1531  intptr_t _mx = mx << (1 - hshift);
1532  intptr_t _my = my << (1 - vshift);
1533 
1534  x_off += mv->x >> (2 + hshift);
1535  y_off += mv->y >> (2 + vshift);
1536  src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1537 
1538  if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1539  x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1540  y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1541  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1542  int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1543  int buf_offset0 = EPEL_EXTRA_BEFORE *
1544  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1545  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1546  edge_emu_stride, srcstride,
1547  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1548  x_off - EPEL_EXTRA_BEFORE,
1549  y_off - EPEL_EXTRA_BEFORE,
1550  pic_width, pic_height);
1551 
1552  src0 = lc->edge_emu_buffer + buf_offset0;
1553  srcstride = edge_emu_stride;
1554  }
1555  if (!weight_flag)
1556  s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1557  block_h, _mx, _my, block_w);
1558  else
1559  s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1560  block_h, s->sh.chroma_log2_weight_denom,
1561  chroma_weight, chroma_offset, _mx, _my, block_w);
1562 }
1563 
1564 /**
1565  * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1566  *
1567  * @param s HEVC decoding context
1568  * @param dst target buffer for block data at block position
1569  * @param dststride stride of the dst buffer
1570  * @param ref0 reference picture0 buffer at origin (0, 0)
1571  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1572  * @param x_off horizontal position of block from origin (0, 0)
1573  * @param y_off vertical position of block from origin (0, 0)
1574  * @param block_w width of block
1575  * @param block_h height of block
1576  * @param ref1 reference picture1 buffer at origin (0, 0)
1577  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1578  * @param current_mv current motion vector structure
1579  * @param cidx chroma component(cb, cr)
1580  */
1581 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1582  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1583 {
1584  HEVCLocalContext *lc = s->HEVClc;
1585  uint8_t *src1 = ref0->data[cidx+1];
1586  uint8_t *src2 = ref1->data[cidx+1];
1587  ptrdiff_t src1stride = ref0->linesize[cidx+1];
1588  ptrdiff_t src2stride = ref1->linesize[cidx+1];
1589  int weight_flag = (s->sh.slice_type == HEVC_SLICE_P && s->ps.pps->weighted_pred_flag) ||
1591  int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1592  int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1593  Mv *mv0 = &current_mv->mv[0];
1594  Mv *mv1 = &current_mv->mv[1];
1595  int hshift = s->ps.sps->hshift[1];
1596  int vshift = s->ps.sps->vshift[1];
1597 
1598  intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1599  intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1600  intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1601  intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1602  intptr_t _mx0 = mx0 << (1 - hshift);
1603  intptr_t _my0 = my0 << (1 - vshift);
1604  intptr_t _mx1 = mx1 << (1 - hshift);
1605  intptr_t _my1 = my1 << (1 - vshift);
1606 
1607  int x_off0 = x_off + (mv0->x >> (2 + hshift));
1608  int y_off0 = y_off + (mv0->y >> (2 + vshift));
1609  int x_off1 = x_off + (mv1->x >> (2 + hshift));
1610  int y_off1 = y_off + (mv1->y >> (2 + vshift));
1611  int idx = ff_hevc_pel_weight[block_w];
1612  src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1613  src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1614 
1615  if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1616  x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1617  y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1618  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1619  int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1620  int buf_offset1 = EPEL_EXTRA_BEFORE *
1621  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1622 
1623  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1624  edge_emu_stride, src1stride,
1625  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1626  x_off0 - EPEL_EXTRA_BEFORE,
1627  y_off0 - EPEL_EXTRA_BEFORE,
1628  pic_width, pic_height);
1629 
1630  src1 = lc->edge_emu_buffer + buf_offset1;
1631  src1stride = edge_emu_stride;
1632  }
1633 
1634  if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1635  x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1636  y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1637  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1638  int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1639  int buf_offset1 = EPEL_EXTRA_BEFORE *
1640  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1641 
1642  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1643  edge_emu_stride, src2stride,
1644  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1645  x_off1 - EPEL_EXTRA_BEFORE,
1646  y_off1 - EPEL_EXTRA_BEFORE,
1647  pic_width, pic_height);
1648 
1649  src2 = lc->edge_emu_buffer2 + buf_offset1;
1650  src2stride = edge_emu_stride;
1651  }
1652 
1653  s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1654  block_h, _mx0, _my0, block_w);
1655  if (!weight_flag)
1656  s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1657  src2, src2stride, lc->tmp,
1658  block_h, _mx1, _my1, block_w);
1659  else
1660  s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1661  src2, src2stride, lc->tmp,
1662  block_h,
1664  s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1665  s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1666  s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1667  s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1668  _mx1, _my1, block_w);
1669 }
1670 
1672  const Mv *mv, int y0, int height)
1673 {
1674  int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1675 
1676  if (s->threads_type == FF_THREAD_FRAME )
1677  ff_thread_await_progress(&ref->tf, y, 0);
1678 }
1679 
1680 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1681  int nPbH, int log2_cb_size, int part_idx,
1682  int merge_idx, MvField *mv)
1683 {
1684  HEVCLocalContext *lc = s->HEVClc;
1685  enum InterPredIdc inter_pred_idc = PRED_L0;
1686  int mvp_flag;
1687 
1688  ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1689  mv->pred_flag = 0;
1690  if (s->sh.slice_type == HEVC_SLICE_B)
1691  inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1692 
1693  if (inter_pred_idc != PRED_L1) {
1694  if (s->sh.nb_refs[L0])
1695  mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1696 
1697  mv->pred_flag = PF_L0;
1698  ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1699  mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1700  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1701  part_idx, merge_idx, mv, mvp_flag, 0);
1702  mv->mv[0].x += lc->pu.mvd.x;
1703  mv->mv[0].y += lc->pu.mvd.y;
1704  }
1705 
1706  if (inter_pred_idc != PRED_L0) {
1707  if (s->sh.nb_refs[L1])
1708  mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1709 
1710  if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1711  AV_ZERO32(&lc->pu.mvd);
1712  } else {
1713  ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1714  }
1715 
1716  mv->pred_flag += PF_L1;
1717  mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1718  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1719  part_idx, merge_idx, mv, mvp_flag, 1);
1720  mv->mv[1].x += lc->pu.mvd.x;
1721  mv->mv[1].y += lc->pu.mvd.y;
1722  }
1723 }
1724 
1725 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1726  int nPbW, int nPbH,
1727  int log2_cb_size, int partIdx, int idx)
1728 {
1729 #define POS(c_idx, x, y) \
1730  &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1731  (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1732  HEVCLocalContext *lc = s->HEVClc;
1733  int merge_idx = 0;
1734  struct MvField current_mv = {{{ 0 }}};
1735 
1736  int min_pu_width = s->ps.sps->min_pu_width;
1737 
1738  MvField *tab_mvf = s->ref->tab_mvf;
1739  RefPicList *refPicList = s->ref->refPicList;
1740  HEVCFrame *ref0 = NULL, *ref1 = NULL;
1741  uint8_t *dst0 = POS(0, x0, y0);
1742  uint8_t *dst1 = POS(1, x0, y0);
1743  uint8_t *dst2 = POS(2, x0, y0);
1744  int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1745  int min_cb_width = s->ps.sps->min_cb_width;
1746  int x_cb = x0 >> log2_min_cb_size;
1747  int y_cb = y0 >> log2_min_cb_size;
1748  int x_pu, y_pu;
1749  int i, j;
1750 
1751  int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1752 
1753  if (!skip_flag)
1755 
1756  if (skip_flag || lc->pu.merge_flag) {
1757  if (s->sh.max_num_merge_cand > 1)
1758  merge_idx = ff_hevc_merge_idx_decode(s);
1759  else
1760  merge_idx = 0;
1761 
1762  ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1763  partIdx, merge_idx, &current_mv);
1764  } else {
1765  hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1766  partIdx, merge_idx, &current_mv);
1767  }
1768 
1769  x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1770  y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1771 
1772  for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1773  for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1774  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1775 
1776  if (current_mv.pred_flag & PF_L0) {
1777  ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1778  if (!ref0)
1779  return;
1780  hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1781  }
1782  if (current_mv.pred_flag & PF_L1) {
1783  ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1784  if (!ref1)
1785  return;
1786  hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1787  }
1788 
1789  if (current_mv.pred_flag == PF_L0) {
1790  int x0_c = x0 >> s->ps.sps->hshift[1];
1791  int y0_c = y0 >> s->ps.sps->vshift[1];
1792  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1793  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1794 
1795  luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1796  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1797  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1798  s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1799 
1800  if (s->ps.sps->chroma_format_idc) {
1801  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1802  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1803  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1804  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1805  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1806  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1807  }
1808  } else if (current_mv.pred_flag == PF_L1) {
1809  int x0_c = x0 >> s->ps.sps->hshift[1];
1810  int y0_c = y0 >> s->ps.sps->vshift[1];
1811  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1812  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1813 
1814  luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1815  &current_mv.mv[1], x0, y0, nPbW, nPbH,
1816  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1817  s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1818 
1819  if (s->ps.sps->chroma_format_idc) {
1820  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1821  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1822  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1823 
1824  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1825  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1826  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1827  }
1828  } else if (current_mv.pred_flag == PF_BI) {
1829  int x0_c = x0 >> s->ps.sps->hshift[1];
1830  int y0_c = y0 >> s->ps.sps->vshift[1];
1831  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1832  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1833 
1834  luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1835  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1836  ref1->frame, &current_mv.mv[1], &current_mv);
1837 
1838  if (s->ps.sps->chroma_format_idc) {
1839  chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1840  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1841 
1842  chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1843  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1844  }
1845  }
1846 }
1847 
1848 /**
1849  * 8.4.1
1850  */
1851 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1852  int prev_intra_luma_pred_flag)
1853 {
1854  HEVCLocalContext *lc = s->HEVClc;
1855  int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1856  int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1857  int min_pu_width = s->ps.sps->min_pu_width;
1858  int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1859  int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1860  int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1861 
1862  int cand_up = (lc->ctb_up_flag || y0b) ?
1863  s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1864  int cand_left = (lc->ctb_left_flag || x0b) ?
1865  s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1866 
1867  int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1868 
1869  MvField *tab_mvf = s->ref->tab_mvf;
1870  int intra_pred_mode;
1871  int candidate[3];
1872  int i, j;
1873 
1874  // intra_pred_mode prediction does not cross vertical CTB boundaries
1875  if ((y0 - 1) < y_ctb)
1876  cand_up = INTRA_DC;
1877 
1878  if (cand_left == cand_up) {
1879  if (cand_left < 2) {
1880  candidate[0] = INTRA_PLANAR;
1881  candidate[1] = INTRA_DC;
1882  candidate[2] = INTRA_ANGULAR_26;
1883  } else {
1884  candidate[0] = cand_left;
1885  candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1886  candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1887  }
1888  } else {
1889  candidate[0] = cand_left;
1890  candidate[1] = cand_up;
1891  if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1892  candidate[2] = INTRA_PLANAR;
1893  } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1894  candidate[2] = INTRA_DC;
1895  } else {
1896  candidate[2] = INTRA_ANGULAR_26;
1897  }
1898  }
1899 
1900  if (prev_intra_luma_pred_flag) {
1901  intra_pred_mode = candidate[lc->pu.mpm_idx];
1902  } else {
1903  if (candidate[0] > candidate[1])
1904  FFSWAP(uint8_t, candidate[0], candidate[1]);
1905  if (candidate[0] > candidate[2])
1906  FFSWAP(uint8_t, candidate[0], candidate[2]);
1907  if (candidate[1] > candidate[2])
1908  FFSWAP(uint8_t, candidate[1], candidate[2]);
1909 
1910  intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1911  for (i = 0; i < 3; i++)
1912  if (intra_pred_mode >= candidate[i])
1913  intra_pred_mode++;
1914  }
1915 
1916  /* write the intra prediction units into the mv array */
1917  if (!size_in_pus)
1918  size_in_pus = 1;
1919  for (i = 0; i < size_in_pus; i++) {
1920  memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1921  intra_pred_mode, size_in_pus);
1922 
1923  for (j = 0; j < size_in_pus; j++) {
1924  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1925  }
1926  }
1927 
1928  return intra_pred_mode;
1929 }
1930 
1931 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1932  int log2_cb_size, int ct_depth)
1933 {
1934  int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1935  int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1936  int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1937  int y;
1938 
1939  for (y = 0; y < length; y++)
1940  memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1941  ct_depth, length);
1942 }
1943 
1944 static const uint8_t tab_mode_idx[] = {
1945  0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1946  21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1947 
1948 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1949  int log2_cb_size)
1950 {
1951  HEVCLocalContext *lc = s->HEVClc;
1952  static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1953  uint8_t prev_intra_luma_pred_flag[4];
1954  int split = lc->cu.part_mode == PART_NxN;
1955  int pb_size = (1 << log2_cb_size) >> split;
1956  int side = split + 1;
1957  int chroma_mode;
1958  int i, j;
1959 
1960  for (i = 0; i < side; i++)
1961  for (j = 0; j < side; j++)
1962  prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1963 
1964  for (i = 0; i < side; i++) {
1965  for (j = 0; j < side; j++) {
1966  if (prev_intra_luma_pred_flag[2 * i + j])
1968  else
1970 
1971  lc->pu.intra_pred_mode[2 * i + j] =
1972  luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1973  prev_intra_luma_pred_flag[2 * i + j]);
1974  }
1975  }
1976 
1977  if (s->ps.sps->chroma_format_idc == 3) {
1978  for (i = 0; i < side; i++) {
1979  for (j = 0; j < side; j++) {
1980  lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1981  if (chroma_mode != 4) {
1982  if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1983  lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1984  else
1985  lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1986  } else {
1987  lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1988  }
1989  }
1990  }
1991  } else if (s->ps.sps->chroma_format_idc == 2) {
1992  int mode_idx;
1993  lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1994  if (chroma_mode != 4) {
1995  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1996  mode_idx = 34;
1997  else
1998  mode_idx = intra_chroma_table[chroma_mode];
1999  } else {
2000  mode_idx = lc->pu.intra_pred_mode[0];
2001  }
2002  lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
2003  } else if (s->ps.sps->chroma_format_idc != 0) {
2004  chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2005  if (chroma_mode != 4) {
2006  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2007  lc->pu.intra_pred_mode_c[0] = 34;
2008  else
2009  lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
2010  } else {
2011  lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
2012  }
2013  }
2014 }
2015 
2017  int x0, int y0,
2018  int log2_cb_size)
2019 {
2020  HEVCLocalContext *lc = s->HEVClc;
2021  int pb_size = 1 << log2_cb_size;
2022  int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
2023  int min_pu_width = s->ps.sps->min_pu_width;
2024  MvField *tab_mvf = s->ref->tab_mvf;
2025  int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
2026  int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
2027  int j, k;
2028 
2029  if (size_in_pus == 0)
2030  size_in_pus = 1;
2031  for (j = 0; j < size_in_pus; j++)
2032  memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2033  if (lc->cu.pred_mode == MODE_INTRA)
2034  for (j = 0; j < size_in_pus; j++)
2035  for (k = 0; k < size_in_pus; k++)
2036  tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2037 }
2038 
2039 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2040 {
2041  int cb_size = 1 << log2_cb_size;
2042  HEVCLocalContext *lc = s->HEVClc;
2043  int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2044  int length = cb_size >> log2_min_cb_size;
2045  int min_cb_width = s->ps.sps->min_cb_width;
2046  int x_cb = x0 >> log2_min_cb_size;
2047  int y_cb = y0 >> log2_min_cb_size;
2048  int idx = log2_cb_size - 2;
2049  int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2050  int x, y, ret;
2051 
2052  lc->cu.x = x0;
2053  lc->cu.y = y0;
2054  lc->cu.pred_mode = MODE_INTRA;
2055  lc->cu.part_mode = PART_2Nx2N;
2056  lc->cu.intra_split_flag = 0;
2057 
2058  SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2059  for (x = 0; x < 4; x++)
2060  lc->pu.intra_pred_mode[x] = 1;
2063  if (lc->cu.cu_transquant_bypass_flag)
2064  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2065  } else
2066  lc->cu.cu_transquant_bypass_flag = 0;
2067 
2068  if (s->sh.slice_type != HEVC_SLICE_I) {
2069  uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2070 
2071  x = y_cb * min_cb_width + x_cb;
2072  for (y = 0; y < length; y++) {
2073  memset(&s->skip_flag[x], skip_flag, length);
2074  x += min_cb_width;
2075  }
2076  lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2077  } else {
2078  x = y_cb * min_cb_width + x_cb;
2079  for (y = 0; y < length; y++) {
2080  memset(&s->skip_flag[x], 0, length);
2081  x += min_cb_width;
2082  }
2083  }
2084 
2085  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2086  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2087  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2088 
2090  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2091  } else {
2092  int pcm_flag = 0;
2093 
2094  if (s->sh.slice_type != HEVC_SLICE_I)
2096  if (lc->cu.pred_mode != MODE_INTRA ||
2097  log2_cb_size == s->ps.sps->log2_min_cb_size) {
2098  lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2099  lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2100  lc->cu.pred_mode == MODE_INTRA;
2101  }
2102 
2103  if (lc->cu.pred_mode == MODE_INTRA) {
2104  if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2105  log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2106  log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2107  pcm_flag = ff_hevc_pcm_flag_decode(s);
2108  }
2109  if (pcm_flag) {
2110  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2111  ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2113  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2114 
2115  if (ret < 0)
2116  return ret;
2117  } else {
2118  intra_prediction_unit(s, x0, y0, log2_cb_size);
2119  }
2120  } else {
2121  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2122  switch (lc->cu.part_mode) {
2123  case PART_2Nx2N:
2124  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2125  break;
2126  case PART_2NxN:
2127  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2128  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2129  break;
2130  case PART_Nx2N:
2131  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2132  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2133  break;
2134  case PART_2NxnU:
2135  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2136  hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2137  break;
2138  case PART_2NxnD:
2139  hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2140  hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2141  break;
2142  case PART_nLx2N:
2143  hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2144  hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2145  break;
2146  case PART_nRx2N:
2147  hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2148  hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2149  break;
2150  case PART_NxN:
2151  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2152  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2153  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2154  hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2155  break;
2156  }
2157  }
2158 
2159  if (!pcm_flag) {
2160  int rqt_root_cbf = 1;
2161 
2162  if (lc->cu.pred_mode != MODE_INTRA &&
2163  !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2164  rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2165  }
2166  if (rqt_root_cbf) {
2167  const static int cbf[2] = { 0 };
2168  lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2171  ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2172  log2_cb_size,
2173  log2_cb_size, 0, 0, cbf, cbf);
2174  if (ret < 0)
2175  return ret;
2176  } else {
2178  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2179  }
2180  }
2181  }
2182 
2184  ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2185 
2186  x = y_cb * min_cb_width + x_cb;
2187  for (y = 0; y < length; y++) {
2188  memset(&s->qp_y_tab[x], lc->qp_y, length);
2189  x += min_cb_width;
2190  }
2191 
2192  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2193  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2194  lc->qPy_pred = lc->qp_y;
2195  }
2196 
2197  set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2198 
2199  return 0;
2200 }
2201 
2202 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2203  int log2_cb_size, int cb_depth)
2204 {
2205  HEVCLocalContext *lc = s->HEVClc;
2206  const int cb_size = 1 << log2_cb_size;
2207  int ret;
2208  int split_cu;
2209 
2210  lc->ct_depth = cb_depth;
2211  if (x0 + cb_size <= s->ps.sps->width &&
2212  y0 + cb_size <= s->ps.sps->height &&
2213  log2_cb_size > s->ps.sps->log2_min_cb_size) {
2214  split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2215  } else {
2216  split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2217  }
2218  if (s->ps.pps->cu_qp_delta_enabled_flag &&
2219  log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2220  lc->tu.is_cu_qp_delta_coded = 0;
2221  lc->tu.cu_qp_delta = 0;
2222  }
2223 
2225  log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2227  }
2228 
2229  if (split_cu) {
2230  int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2231  const int cb_size_split = cb_size >> 1;
2232  const int x1 = x0 + cb_size_split;
2233  const int y1 = y0 + cb_size_split;
2234 
2235  int more_data = 0;
2236 
2237  more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2238  if (more_data < 0)
2239  return more_data;
2240 
2241  if (more_data && x1 < s->ps.sps->width) {
2242  more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2243  if (more_data < 0)
2244  return more_data;
2245  }
2246  if (more_data && y1 < s->ps.sps->height) {
2247  more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2248  if (more_data < 0)
2249  return more_data;
2250  }
2251  if (more_data && x1 < s->ps.sps->width &&
2252  y1 < s->ps.sps->height) {
2253  more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2254  if (more_data < 0)
2255  return more_data;
2256  }
2257 
2258  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2259  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2260  lc->qPy_pred = lc->qp_y;
2261 
2262  if (more_data)
2263  return ((x1 + cb_size_split) < s->ps.sps->width ||
2264  (y1 + cb_size_split) < s->ps.sps->height);
2265  else
2266  return 0;
2267  } else {
2268  ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2269  if (ret < 0)
2270  return ret;
2271  if ((!((x0 + cb_size) %
2272  (1 << (s->ps.sps->log2_ctb_size))) ||
2273  (x0 + cb_size >= s->ps.sps->width)) &&
2274  (!((y0 + cb_size) %
2275  (1 << (s->ps.sps->log2_ctb_size))) ||
2276  (y0 + cb_size >= s->ps.sps->height))) {
2277  int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2278  return !end_of_slice_flag;
2279  } else {
2280  return 1;
2281  }
2282  }
2283 
2284  return 0;
2285 }
2286 
2287 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2288  int ctb_addr_ts)
2289 {
2290  HEVCLocalContext *lc = s->HEVClc;
2291  int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2292  int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2293  int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2294 
2295  s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2296 
2298  if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2299  lc->first_qp_group = 1;
2300  lc->end_of_tiles_x = s->ps.sps->width;
2301  } else if (s->ps.pps->tiles_enabled_flag) {
2302  if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2303  int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2304  lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2305  lc->first_qp_group = 1;
2306  }
2307  } else {
2308  lc->end_of_tiles_x = s->ps.sps->width;
2309  }
2310 
2311  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2312 
2313  lc->boundary_flags = 0;
2314  if (s->ps.pps->tiles_enabled_flag) {
2315  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]])
2317  if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2319  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]])
2321  if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2323  } else {
2324  if (ctb_addr_in_slice <= 0)
2326  if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2328  }
2329 
2330  lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2331  lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2332  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]]));
2333  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]]));
2334 }
2335 
2336 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2337 {
2338  HEVCContext *s = avctxt->priv_data;
2339  int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2340  int more_data = 1;
2341  int x_ctb = 0;
2342  int y_ctb = 0;
2343  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2344 
2345  if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2346  av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2347  return AVERROR_INVALIDDATA;
2348  }
2349 
2351  int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2352  if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2353  av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2354  return AVERROR_INVALIDDATA;
2355  }
2356  }
2357 
2358  while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2359  int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2360 
2361  x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2362  y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2363  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2364 
2365  ff_hevc_cabac_init(s, ctb_addr_ts);
2366 
2367  hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2368 
2369  s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2370  s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2372 
2373  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2374  if (more_data < 0) {
2375  s->tab_slice_address[ctb_addr_rs] = -1;
2376  return more_data;
2377  }
2378 
2379 
2380  ctb_addr_ts++;
2381  ff_hevc_save_states(s, ctb_addr_ts);
2382  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2383  }
2384 
2385  if (x_ctb + ctb_size >= s->ps.sps->width &&
2386  y_ctb + ctb_size >= s->ps.sps->height)
2387  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2388 
2389  return ctb_addr_ts;
2390 }
2391 
2393 {
2394  int arg[2];
2395  int ret[2];
2396 
2397  arg[0] = 0;
2398  arg[1] = 1;
2399 
2400  s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2401  return ret[0];
2402 }
2403 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2404 {
2405  HEVCContext *s1 = avctxt->priv_data, *s;
2406  HEVCLocalContext *lc;
2407  int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2408  int more_data = 1;
2409  int *ctb_row_p = input_ctb_row;
2410  int ctb_row = ctb_row_p[job];
2411  int ctb_addr_rs = s1->sh.slice_ctb_addr_rs + ctb_row * ((s1->ps.sps->width + ctb_size - 1) >> s1->ps.sps->log2_ctb_size);
2412  int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2413  int thread = ctb_row % s1->threads_number;
2414  int ret;
2415 
2416  s = s1->sList[self_id];
2417  lc = s->HEVClc;
2418 
2419  if(ctb_row) {
2420  ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2421 
2422  if (ret < 0)
2423  return ret;
2424  ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2425  }
2426 
2427  while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2428  int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2429  int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2430 
2431  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2432 
2433  ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2434 
2435  if (atomic_load(&s1->wpp_err)) {
2436  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2437  return 0;
2438  }
2439 
2440  ff_hevc_cabac_init(s, ctb_addr_ts);
2441  hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2442  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2443 
2444  if (more_data < 0) {
2445  s->tab_slice_address[ctb_addr_rs] = -1;
2446  atomic_store(&s1->wpp_err, 1);
2447  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2448  return more_data;
2449  }
2450 
2451  ctb_addr_ts++;
2452 
2453  ff_hevc_save_states(s, ctb_addr_ts);
2454  ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2455  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2456 
2457  if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2458  atomic_store(&s1->wpp_err, 1);
2459  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2460  return 0;
2461  }
2462 
2463  if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2464  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2465  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2466  return ctb_addr_ts;
2467  }
2468  ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2469  x_ctb+=ctb_size;
2470 
2471  if(x_ctb >= s->ps.sps->width) {
2472  break;
2473  }
2474  }
2475  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2476 
2477  return 0;
2478 }
2479 
2480 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2481 {
2482  const uint8_t *data = nal->data;
2483  int length = nal->size;
2484  HEVCLocalContext *lc = s->HEVClc;
2485  int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2486  int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2487  int64_t offset;
2488  int64_t startheader, cmpt = 0;
2489  int i, j, res = 0;
2490 
2491  if (!ret || !arg) {
2492  av_free(ret);
2493  av_free(arg);
2494  return AVERROR(ENOMEM);
2495  }
2496 
2498  av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2500  s->ps.sps->ctb_width, s->ps.sps->ctb_height
2501  );
2502  res = AVERROR_INVALIDDATA;
2503  goto error;
2504  }
2505 
2507 
2508  if (!s->sList[1]) {
2509  for (i = 1; i < s->threads_number; i++) {
2510  s->sList[i] = av_malloc(sizeof(HEVCContext));
2511  memcpy(s->sList[i], s, sizeof(HEVCContext));
2512  s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2513  s->sList[i]->HEVClc = s->HEVClcList[i];
2514  }
2515  }
2516 
2517  offset = (lc->gb.index >> 3);
2518 
2519  for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2520  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2521  startheader--;
2522  cmpt++;
2523  }
2524  }
2525 
2526  for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2527  offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2528  for (j = 0, cmpt = 0, startheader = offset
2529  + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2530  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2531  startheader--;
2532  cmpt++;
2533  }
2534  }
2535  s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2536  s->sh.offset[i - 1] = offset;
2537 
2538  }
2539  if (s->sh.num_entry_point_offsets != 0) {
2540  offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2541  if (length < offset) {
2542  av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2543  res = AVERROR_INVALIDDATA;
2544  goto error;
2545  }
2546  s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2547  s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2548 
2549  }
2550  s->data = data;
2551 
2552  for (i = 1; i < s->threads_number; i++) {
2553  s->sList[i]->HEVClc->first_qp_group = 1;
2554  s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2555  memcpy(s->sList[i], s, sizeof(HEVCContext));
2556  s->sList[i]->HEVClc = s->HEVClcList[i];
2557  }
2558 
2559  atomic_store(&s->wpp_err, 0);
2560  ff_reset_entries(s->avctx);
2561 
2562  for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2563  arg[i] = i;
2564  ret[i] = 0;
2565  }
2566 
2569 
2570  for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2571  res += ret[i];
2572 error:
2573  av_free(ret);
2574  av_free(arg);
2575  return res;
2576 }
2577 
2579 {
2580  AVFrame *out = s->ref->frame;
2581 
2582  if (s->sei_frame_packing_present &&
2585  s->content_interpretation_type > 0 &&
2586  s->content_interpretation_type < 3) {
2588  if (!stereo)
2589  return AVERROR(ENOMEM);
2590 
2591  switch (s->frame_packing_arrangement_type) {
2592  case 3:
2593  if (s->quincunx_subsampling)
2595  else
2596  stereo->type = AV_STEREO3D_SIDEBYSIDE;
2597  break;
2598  case 4:
2599  stereo->type = AV_STEREO3D_TOPBOTTOM;
2600  break;
2601  case 5:
2602  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2603  break;
2604  }
2605 
2606  if (s->content_interpretation_type == 2)
2607  stereo->flags = AV_STEREO3D_FLAG_INVERT;
2608  }
2609 
2611  (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2612  double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2613  AVFrameSideData *rotation = av_frame_new_side_data(out,
2615  sizeof(int32_t) * 9);
2616  if (!rotation)
2617  return AVERROR(ENOMEM);
2618 
2619  av_display_rotation_set((int32_t *)rotation->data, angle);
2620  av_display_matrix_flip((int32_t *)rotation->data,
2621  s->sei_hflip, s->sei_vflip);
2622  }
2623 
2624  // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2625  // so the side data persists for the entire coded video sequence.
2627  IS_IRAP(s) && s->no_rasl_output_flag) {
2629  }
2631  // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2632  const int mapping[3] = {2, 0, 1};
2633  const int chroma_den = 50000;
2634  const int luma_den = 10000;
2635  int i;
2636  AVMasteringDisplayMetadata *metadata =
2638  if (!metadata)
2639  return AVERROR(ENOMEM);
2640 
2641  for (i = 0; i < 3; i++) {
2642  const int j = mapping[i];
2643  metadata->display_primaries[i][0].num = s->display_primaries[j][0];
2644  metadata->display_primaries[i][0].den = chroma_den;
2645  metadata->display_primaries[i][1].num = s->display_primaries[j][1];
2646  metadata->display_primaries[i][1].den = chroma_den;
2647  }
2648  metadata->white_point[0].num = s->white_point[0];
2649  metadata->white_point[0].den = chroma_den;
2650  metadata->white_point[1].num = s->white_point[1];
2651  metadata->white_point[1].den = chroma_den;
2652 
2653  metadata->max_luminance.num = s->max_mastering_luminance;
2654  metadata->max_luminance.den = luma_den;
2655  metadata->min_luminance.num = s->min_mastering_luminance;
2656  metadata->min_luminance.den = luma_den;
2657  metadata->has_luminance = 1;
2658  metadata->has_primaries = 1;
2659 
2660  av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2662  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2663  av_q2d(metadata->display_primaries[0][0]),
2664  av_q2d(metadata->display_primaries[0][1]),
2665  av_q2d(metadata->display_primaries[1][0]),
2666  av_q2d(metadata->display_primaries[1][1]),
2667  av_q2d(metadata->display_primaries[2][0]),
2668  av_q2d(metadata->display_primaries[2][1]),
2669  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2671  "min_luminance=%f, max_luminance=%f\n",
2672  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2673  }
2674 
2675  if (s->a53_caption) {
2678  s->a53_caption_size);
2679  if (sd)
2680  memcpy(sd->data, s->a53_caption, s->a53_caption_size);
2681  av_freep(&s->a53_caption);
2682  s->a53_caption_size = 0;
2684  }
2685 
2686  return 0;
2687 }
2688 
2690 {
2691  HEVCLocalContext *lc = s->HEVClc;
2692  int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2693  ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2694  int ret;
2695 
2696  memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2697  memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2698  memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2699  memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2700  memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2701 
2702  s->is_decoded = 0;
2703  s->first_nal_type = s->nal_unit_type;
2704 
2706 
2707  if (s->ps.pps->tiles_enabled_flag)
2708  lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2709 
2710  ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2711  if (ret < 0)
2712  goto fail;
2713 
2714  ret = ff_hevc_frame_rps(s);
2715  if (ret < 0) {
2716  av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2717  goto fail;
2718  }
2719 
2720  s->ref->frame->key_frame = IS_IRAP(s);
2721 
2722  ret = set_side_data(s);
2723  if (ret < 0)
2724  goto fail;
2725 
2726  s->frame->pict_type = 3 - s->sh.slice_type;
2727 
2728  if (!IS_IRAP(s))
2729  ff_hevc_bump_frame(s);
2730 
2732  ret = ff_hevc_output_frame(s, s->output_frame, 0);
2733  if (ret < 0)
2734  goto fail;
2735 
2736  if (!s->avctx->hwaccel)
2738 
2739  return 0;
2740 
2741 fail:
2742  if (s->ref)
2743  ff_hevc_unref_frame(s, s->ref, ~0);
2744  s->ref = NULL;
2745  return ret;
2746 }
2747 
2748 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2749 {
2750  HEVCLocalContext *lc = s->HEVClc;
2751  GetBitContext *gb = &lc->gb;
2752  int ctb_addr_ts, ret;
2753 
2754  *gb = nal->gb;
2755  s->nal_unit_type = nal->type;
2756  s->temporal_id = nal->temporal_id;
2757 
2758  switch (s->nal_unit_type) {
2759  case HEVC_NAL_VPS:
2760  ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2761  if (ret < 0)
2762  goto fail;
2763  break;
2764  case HEVC_NAL_SPS:
2765  ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2766  s->apply_defdispwin);
2767  if (ret < 0)
2768  goto fail;
2769  break;
2770  case HEVC_NAL_PPS:
2771  ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2772  if (ret < 0)
2773  goto fail;
2774  break;
2775  case HEVC_NAL_SEI_PREFIX:
2776  case HEVC_NAL_SEI_SUFFIX:
2777  ret = ff_hevc_decode_nal_sei(s);
2778  if (ret < 0)
2779  goto fail;
2780  break;
2781  case HEVC_NAL_TRAIL_R:
2782  case HEVC_NAL_TRAIL_N:
2783  case HEVC_NAL_TSA_N:
2784  case HEVC_NAL_TSA_R:
2785  case HEVC_NAL_STSA_N:
2786  case HEVC_NAL_STSA_R:
2787  case HEVC_NAL_BLA_W_LP:
2788  case HEVC_NAL_BLA_W_RADL:
2789  case HEVC_NAL_BLA_N_LP:
2790  case HEVC_NAL_IDR_W_RADL:
2791  case HEVC_NAL_IDR_N_LP:
2792  case HEVC_NAL_CRA_NUT:
2793  case HEVC_NAL_RADL_N:
2794  case HEVC_NAL_RADL_R:
2795  case HEVC_NAL_RASL_N:
2796  case HEVC_NAL_RASL_R:
2797  ret = hls_slice_header(s);
2798  if (ret < 0)
2799  return ret;
2800 
2801  if (s->sh.first_slice_in_pic_flag) {
2802  if (s->max_ra == INT_MAX) {
2803  if (s->nal_unit_type == HEVC_NAL_CRA_NUT || IS_BLA(s)) {
2804  s->max_ra = s->poc;
2805  } else {
2806  if (IS_IDR(s))
2807  s->max_ra = INT_MIN;
2808  }
2809  }
2810 
2812  s->poc <= s->max_ra) {
2813  s->is_decoded = 0;
2814  break;
2815  } else {
2816  if (s->nal_unit_type == HEVC_NAL_RASL_R && s->poc > s->max_ra)
2817  s->max_ra = INT_MIN;
2818  }
2819 
2820  ret = hevc_frame_start(s);
2821  if (ret < 0)
2822  return ret;
2823  } else if (!s->ref) {
2824  av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2825  goto fail;
2826  }
2827 
2828  if (s->nal_unit_type != s->first_nal_type) {
2830  "Non-matching NAL types of the VCL NALUs: %d %d\n",
2831  s->first_nal_type, s->nal_unit_type);
2832  return AVERROR_INVALIDDATA;
2833  }
2834 
2835  if (!s->sh.dependent_slice_segment_flag &&
2836  s->sh.slice_type != HEVC_SLICE_I) {
2837  ret = ff_hevc_slice_rpl(s);
2838  if (ret < 0) {
2840  "Error constructing the reference lists for the current slice.\n");
2841  goto fail;
2842  }
2843  }
2844 
2845  if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2846  ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2847  if (ret < 0)
2848  goto fail;
2849  }
2850 
2851  if (s->avctx->hwaccel) {
2852  ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2853  if (ret < 0)
2854  goto fail;
2855  } else {
2856  if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2857  ctb_addr_ts = hls_slice_data_wpp(s, nal);
2858  else
2859  ctb_addr_ts = hls_slice_data(s);
2860  if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2861  s->is_decoded = 1;
2862  }
2863 
2864  if (ctb_addr_ts < 0) {
2865  ret = ctb_addr_ts;
2866  goto fail;
2867  }
2868  }
2869  break;
2870  case HEVC_NAL_EOS_NUT:
2871  case HEVC_NAL_EOB_NUT:
2872  s->seq_decode = (s->seq_decode + 1) & 0xff;
2873  s->max_ra = INT_MAX;
2874  break;
2875  case HEVC_NAL_AUD:
2876  case HEVC_NAL_FD_NUT:
2877  break;
2878  default:
2879  av_log(s->avctx, AV_LOG_INFO,
2880  "Skipping NAL unit %d\n", s->nal_unit_type);
2881  }
2882 
2883  return 0;
2884 fail:
2886  return ret;
2887  return 0;
2888 }
2889 
2890 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2891 {
2892  int i, ret = 0;
2893 
2894  s->ref = NULL;
2895  s->last_eos = s->eos;
2896  s->eos = 0;
2897 
2898  /* split the input packet into NAL units, so we know the upper bound on the
2899  * number of slices in the frame */
2900  ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2901  s->nal_length_size, s->avctx->codec_id, 1);
2902  if (ret < 0) {
2904  "Error splitting the input into NAL units.\n");
2905  return ret;
2906  }
2907 
2908  for (i = 0; i < s->pkt.nb_nals; i++) {
2909  if (s->pkt.nals[i].type == HEVC_NAL_EOB_NUT ||
2910  s->pkt.nals[i].type == HEVC_NAL_EOS_NUT)
2911  s->eos = 1;
2912  }
2913 
2914  /* decode the NAL units */
2915  for (i = 0; i < s->pkt.nb_nals; i++) {
2916  ret = decode_nal_unit(s, &s->pkt.nals[i]);
2917  if (ret < 0) {
2919  "Error parsing NAL unit #%d.\n", i);
2920  goto fail;
2921  }
2922  }
2923 
2924 fail:
2925  if (s->ref && s->threads_type == FF_THREAD_FRAME)
2926  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2927 
2928  return ret;
2929 }
2930 
2931 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2932 {
2933  int i;
2934  for (i = 0; i < 16; i++)
2935  av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2936 }
2937 
2939 {
2941  int pixel_shift;
2942  int i, j;
2943 
2944  if (!desc)
2945  return AVERROR(EINVAL);
2946 
2947  pixel_shift = desc->comp[0].depth > 8;
2948 
2949  av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2950  s->poc);
2951 
2952  /* the checksums are LE, so we have to byteswap for >8bpp formats
2953  * on BE arches */
2954 #if HAVE_BIGENDIAN
2955  if (pixel_shift && !s->checksum_buf) {
2957  FFMAX3(frame->linesize[0], frame->linesize[1],
2958  frame->linesize[2]));
2959  if (!s->checksum_buf)
2960  return AVERROR(ENOMEM);
2961  }
2962 #endif
2963 
2964  for (i = 0; frame->data[i]; i++) {
2965  int width = s->avctx->coded_width;
2966  int height = s->avctx->coded_height;
2967  int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2968  int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2969  uint8_t md5[16];
2970 
2971  av_md5_init(s->md5_ctx);
2972  for (j = 0; j < h; j++) {
2973  const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2974 #if HAVE_BIGENDIAN
2975  if (pixel_shift) {
2976  s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2977  (const uint16_t *) src, w);
2978  src = s->checksum_buf;
2979  }
2980 #endif
2981  av_md5_update(s->md5_ctx, src, w << pixel_shift);
2982  }
2983  av_md5_final(s->md5_ctx, md5);
2984 
2985  if (!memcmp(md5, s->md5[i], 16)) {
2986  av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2987  print_md5(s->avctx, AV_LOG_DEBUG, md5);
2988  av_log (s->avctx, AV_LOG_DEBUG, "; ");
2989  } else {
2990  av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2991  print_md5(s->avctx, AV_LOG_ERROR, md5);
2992  av_log (s->avctx, AV_LOG_ERROR, " != ");
2993  print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2994  av_log (s->avctx, AV_LOG_ERROR, "\n");
2995  return AVERROR_INVALIDDATA;
2996  }
2997  }
2998 
2999  av_log(s->avctx, AV_LOG_DEBUG, "\n");
3000 
3001  return 0;
3002 }
3003 
3004 static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
3005 {
3006  AVCodecContext *avctx = s->avctx;
3007  GetByteContext gb;
3008  int ret, i;
3009 
3010  bytestream2_init(&gb, buf, length);
3011 
3012  if (length > 3 && (buf[0] || buf[1] || buf[2] > 1)) {
3013  /* It seems the extradata is encoded as hvcC format.
3014  * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3015  * is finalized. When finalized, configurationVersion will be 1 and we
3016  * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3017  int i, j, num_arrays, nal_len_size;
3018 
3019  s->is_nalff = 1;
3020 
3021  bytestream2_skip(&gb, 21);
3022  nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3023  num_arrays = bytestream2_get_byte(&gb);
3024 
3025  /* nal units in the hvcC always have length coded with 2 bytes,
3026  * so put a fake nal_length_size = 2 while parsing them */
3027  s->nal_length_size = 2;
3028 
3029  /* Decode nal units from hvcC. */
3030  for (i = 0; i < num_arrays; i++) {
3031  int type = bytestream2_get_byte(&gb) & 0x3f;
3032  int cnt = bytestream2_get_be16(&gb);
3033 
3034  for (j = 0; j < cnt; j++) {
3035  // +2 for the nal size field
3036  int nalsize = bytestream2_peek_be16(&gb) + 2;
3037  if (bytestream2_get_bytes_left(&gb) < nalsize) {
3039  "Invalid NAL unit size in extradata.\n");
3040  return AVERROR_INVALIDDATA;
3041  }
3042 
3043  ret = decode_nal_units(s, gb.buffer, nalsize);
3044  if (ret < 0) {
3045  av_log(avctx, AV_LOG_ERROR,
3046  "Decoding nal unit %d %d from hvcC failed\n",
3047  type, i);
3048  return ret;
3049  }
3050  bytestream2_skip(&gb, nalsize);
3051  }
3052  }
3053 
3054  /* Now store right nal length size, that will be used to parse
3055  * all other nals */
3056  s->nal_length_size = nal_len_size;
3057  } else {
3058  s->is_nalff = 0;
3059  ret = decode_nal_units(s, buf, length);
3060  if (ret < 0)
3061  return ret;
3062  }
3063 
3064  /* export stream parameters from the first SPS */
3065  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3066  if (first && s->ps.sps_list[i]) {
3067  const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3068  export_stream_params(s->avctx, &s->ps, sps);
3069  break;
3070  }
3071  }
3072 
3073  return 0;
3074 }
3075 
3076 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
3077  AVPacket *avpkt)
3078 {
3079  int ret;
3080  int new_extradata_size;
3081  uint8_t *new_extradata;
3082  HEVCContext *s = avctx->priv_data;
3083 
3084  if (!avpkt->size) {
3085  ret = ff_hevc_output_frame(s, data, 1);
3086  if (ret < 0)
3087  return ret;
3088 
3089  *got_output = ret;
3090  return 0;
3091  }
3092 
3093  new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
3094  &new_extradata_size);
3095  if (new_extradata && new_extradata_size > 0) {
3096  ret = hevc_decode_extradata(s, new_extradata, new_extradata_size, 0);
3097  if (ret < 0)
3098  return ret;
3099  }
3100 
3101  s->ref = NULL;
3102  ret = decode_nal_units(s, avpkt->data, avpkt->size);
3103  if (ret < 0)
3104  return ret;
3105 
3106  if (avctx->hwaccel) {
3107  if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
3108  av_log(avctx, AV_LOG_ERROR,
3109  "hardware accelerator failed to decode picture\n");
3110  ff_hevc_unref_frame(s, s->ref, ~0);
3111  return ret;
3112  }
3113  } else {
3114  /* verify the SEI checksum */
3115  if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3116  s->is_md5) {
3117  ret = verify_md5(s, s->ref->frame);
3118  if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3119  ff_hevc_unref_frame(s, s->ref, ~0);
3120  return ret;
3121  }
3122  }
3123  }
3124  s->is_md5 = 0;
3125 
3126  if (s->is_decoded) {
3127  av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3128  s->is_decoded = 0;
3129  }
3130 
3131  if (s->output_frame->buf[0]) {
3132  av_frame_move_ref(data, s->output_frame);
3133  *got_output = 1;
3134  }
3135 
3136  return avpkt->size;
3137 }
3138 
3140 {
3141  int ret;
3142 
3143  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3144  if (ret < 0)
3145  return ret;
3146 
3147  dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3148  if (!dst->tab_mvf_buf)
3149  goto fail;
3150  dst->tab_mvf = src->tab_mvf;
3151 
3152  dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3153  if (!dst->rpl_tab_buf)
3154  goto fail;
3155  dst->rpl_tab = src->rpl_tab;
3156 
3157  dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3158  if (!dst->rpl_buf)
3159  goto fail;
3160 
3161  dst->poc = src->poc;
3162  dst->ctb_count = src->ctb_count;
3163  dst->window = src->window;
3164  dst->flags = src->flags;
3165  dst->sequence = src->sequence;
3166 
3167  if (src->hwaccel_picture_private) {
3169  if (!dst->hwaccel_priv_buf)
3170  goto fail;
3172  }
3173 
3174  return 0;
3175 fail:
3176  ff_hevc_unref_frame(s, dst, ~0);
3177  return AVERROR(ENOMEM);
3178 }
3179 
3181 {
3182  HEVCContext *s = avctx->priv_data;
3183  int i;
3184 
3185  pic_arrays_free(s);
3186 
3187  av_freep(&s->md5_ctx);
3188 
3189  av_freep(&s->cabac_state);
3190 
3191  for (i = 0; i < 3; i++) {
3192  av_freep(&s->sao_pixel_buffer_h[i]);
3193  av_freep(&s->sao_pixel_buffer_v[i]);
3194  }
3196 
3197  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3198  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3199  av_frame_free(&s->DPB[i].frame);
3200  }
3201 
3202  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3203  av_buffer_unref(&s->ps.vps_list[i]);
3204  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3205  av_buffer_unref(&s->ps.sps_list[i]);
3206  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3207  av_buffer_unref(&s->ps.pps_list[i]);
3208  s->ps.sps = NULL;
3209  s->ps.pps = NULL;
3210  s->ps.vps = NULL;
3211 
3213  av_freep(&s->sh.offset);
3214  av_freep(&s->sh.size);
3215 
3216  for (i = 1; i < s->threads_number; i++) {
3217  HEVCLocalContext *lc = s->HEVClcList[i];
3218  if (lc) {
3219  av_freep(&s->HEVClcList[i]);
3220  av_freep(&s->sList[i]);
3221  }
3222  }
3223  if (s->HEVClc == s->HEVClcList[0])
3224  s->HEVClc = NULL;
3225  av_freep(&s->HEVClcList[0]);
3226 
3228 
3229  return 0;
3230 }
3231 
3233 {
3234  HEVCContext *s = avctx->priv_data;
3235  int i;
3236 
3237  s->avctx = avctx;
3238 
3239  s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3240  if (!s->HEVClc)
3241  goto fail;
3242  s->HEVClcList[0] = s->HEVClc;
3243  s->sList[0] = s;
3244 
3246  if (!s->cabac_state)
3247  goto fail;
3248 
3250  if (!s->output_frame)
3251  goto fail;
3252 
3253  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3254  s->DPB[i].frame = av_frame_alloc();
3255  if (!s->DPB[i].frame)
3256  goto fail;
3257  s->DPB[i].tf.f = s->DPB[i].frame;
3258  }
3259 
3260  s->max_ra = INT_MAX;
3261 
3262  s->md5_ctx = av_md5_alloc();
3263  if (!s->md5_ctx)
3264  goto fail;
3265 
3266  ff_bswapdsp_init(&s->bdsp);
3267 
3268  s->context_initialized = 1;
3269  s->eos = 0;
3270 
3271  ff_hevc_reset_sei(s);
3272 
3273  return 0;
3274 
3275 fail:
3276  hevc_decode_free(avctx);
3277  return AVERROR(ENOMEM);
3278 }
3279 
3281  const AVCodecContext *src)
3282 {
3283  HEVCContext *s = dst->priv_data;
3284  HEVCContext *s0 = src->priv_data;
3285  int i, ret;
3286 
3287  if (!s->context_initialized) {
3288  ret = hevc_init_context(dst);
3289  if (ret < 0)
3290  return ret;
3291  }
3292 
3293  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3294  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3295  if (s0->DPB[i].frame->buf[0]) {
3296  ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3297  if (ret < 0)
3298  return ret;
3299  }
3300  }
3301 
3302  if (s->ps.sps != s0->ps.sps)
3303  s->ps.sps = NULL;
3304  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3305  av_buffer_unref(&s->ps.vps_list[i]);
3306  if (s0->ps.vps_list[i]) {
3307  s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3308  if (!s->ps.vps_list[i])
3309  return AVERROR(ENOMEM);
3310  }
3311  }
3312 
3313  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3314  av_buffer_unref(&s->ps.sps_list[i]);
3315  if (s0->ps.sps_list[i]) {
3316  s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3317  if (!s->ps.sps_list[i])
3318  return AVERROR(ENOMEM);
3319  }
3320  }
3321 
3322  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3323  av_buffer_unref(&s->ps.pps_list[i]);
3324  if (s0->ps.pps_list[i]) {
3325  s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3326  if (!s->ps.pps_list[i])
3327  return AVERROR(ENOMEM);
3328  }
3329  }
3330 
3331  if (s->ps.sps != s0->ps.sps)
3332  if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3333  return ret;
3334 
3335  s->seq_decode = s0->seq_decode;
3336  s->seq_output = s0->seq_output;
3337  s->pocTid0 = s0->pocTid0;
3338  s->max_ra = s0->max_ra;
3339  s->eos = s0->eos;
3341 
3342  s->is_nalff = s0->is_nalff;
3344 
3345  s->threads_number = s0->threads_number;
3346  s->threads_type = s0->threads_type;
3347 
3348  if (s0->eos) {
3349  s->seq_decode = (s->seq_decode + 1) & 0xff;
3350  s->max_ra = INT_MAX;
3351  }
3352 
3353  return 0;
3354 }
3355 
3357 {
3358  HEVCContext *s = avctx->priv_data;
3359  int ret;
3360 
3361  avctx->internal->allocate_progress = 1;
3362 
3363  ret = hevc_init_context(avctx);
3364  if (ret < 0)
3365  return ret;
3366 
3367  s->enable_parallel_tiles = 0;
3368  s->picture_struct = 0;
3369  s->eos = 1;
3370 
3371  atomic_init(&s->wpp_err, 0);
3372 
3373  if(avctx->active_thread_type & FF_THREAD_SLICE)
3374  s->threads_number = avctx->thread_count;
3375  else
3376  s->threads_number = 1;
3377 
3378  if (avctx->extradata_size > 0 && avctx->extradata) {
3379  ret = hevc_decode_extradata(s, avctx->extradata, avctx->extradata_size, 1);
3380  if (ret < 0) {
3381  hevc_decode_free(avctx);
3382  return ret;
3383  }
3384  }
3385 
3386  if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3388  else
3390 
3391  return 0;
3392 }
3393 
3395 {
3396  HEVCContext *s = avctx->priv_data;
3397  int ret;
3398 
3399  memset(s, 0, sizeof(*s));
3400 
3401  ret = hevc_init_context(avctx);
3402  if (ret < 0)
3403  return ret;
3404 
3405  return 0;
3406 }
3407 
3409 {
3410  HEVCContext *s = avctx->priv_data;
3411  ff_hevc_flush_dpb(s);
3412  s->max_ra = INT_MAX;
3413  s->eos = 1;
3414 }
3415 
3416 #define OFFSET(x) offsetof(HEVCContext, x)
3417 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3418 
3419 static const AVOption options[] = {
3420  { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3421  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3422  { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3423  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3424  { NULL },
3425 };
3426 
3427 static const AVClass hevc_decoder_class = {
3428  .class_name = "HEVC decoder",
3429  .item_name = av_default_item_name,
3430  .option = options,
3431  .version = LIBAVUTIL_VERSION_INT,
3432 };
3433 
3435  .name = "hevc",
3436  .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3437  .type = AVMEDIA_TYPE_VIDEO,
3438  .id = AV_CODEC_ID_HEVC,
3439  .priv_data_size = sizeof(HEVCContext),
3440  .priv_class = &hevc_decoder_class,
3442  .close = hevc_decode_free,
3445  .update_thread_context = hevc_update_thread_context,
3447  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3449  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
3451 };
static int set_side_data(HEVCContext *s)
Definition: hevcdec.c:2578
static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride, 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:1364
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)
Split an input packet into NAL units.
Definition: h2645_parse.c:250
int8_t cu_qp_offset_cr
Definition: hevcdec.h:379
int frame_packing_arrangement_type
Definition: hevcdec.h:578
static void intra_prediction_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:1948
uint8_t ctb_up_flag
Definition: hevcdec.h:442
const HEVCPPS * pps
Definition: hevc_ps.h:321
AVFrame * frame
Definition: hevcdec.h:394
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc_ps.h:196
#define SHIFT_CTB_WPP
Definition: hevcdec.h:45
AVRational framerate
Definition: avcodec.h:3429
int sei_frame_packing_present
frame packing arrangement variables
Definition: hevcdec.h:577
const char const char void * val
Definition: avisynth_c.h:771
uint8_t log2_sao_offset_scale_luma
Definition: hevc_ps.h:292
HEVCPredContext hpc
Definition: hevcdec.h:519
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
int pic_order_cnt_lsb
Definition: hevcdec.h:257
int short_term_ref_pic_set_sps_flag
Definition: hevcdec.h:265
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:125
int size
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2333
static int verify_md5(HEVCContext *s, AVFrame *frame)
Definition: hevcdec.c:2938
int quincunx_subsampling
Definition: hevcdec.h:580
This structure describes decoded (raw) audio or video data.
Definition: frame.h:187
HEVCFrame * ref
Definition: hevcdec.h:505
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
#define HEVC_CONTEXTS
Definition: hevcdec.h:54
int ctb_height
Definition: hevc_ps.h:217
uint8_t is_cu_qp_delta_coded
Definition: hevcdec.h:376
#define atomic_store(object, desired)
Definition: stdatomic.h:85
AVOption.
Definition: opt.h:246
AVBufferRef * vps_list[HEVC_MAX_VPS_COUNT]
Definition: hevc_ps.h:314
static void flush(AVCodecContext *avctx)
int size
Definition: h2645_parse.h:35
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc_ps.h:288
struct HEVCSPS::@68 pcm
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1934
int max_dec_pic_buffering
Definition: hevc_ps.h:163
const char * fmt
Definition: avisynth_c.h:769
void(* put_pcm)(uint8_t *_dst, ptrdiff_t _stride, int width, int height, struct GetBitContext *gb, int pcm_bit_depth)
Definition: hevcdsp.h:46
void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
Definition: hevcpred.c:43
VideoDSPContext vdsp
Definition: hevcdec.h:521
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
Definition: hevc_cabac.c:675
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:262
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int init_thread_copy(AVCodecContext *avctx)
Definition: tta.c:392
void(* put_hevc_qpel_bi_w[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *_src, ptrdiff_t _srcstride, int16_t *src2, int height, int denom, int wx0, int wx1, int ox0, int ox1, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:82
int content_interpretation_type
Definition: hevcdec.h:579
AVFrame * f
Definition: thread.h:36
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:135
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:370
int16_t x
horizontal component of motion vector
Definition: hevcdec.h:338
const char * desc
Definition: nvenc.c:60
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
Definition: hevcdec.c:2748
ShortTermRPS st_rps[HEVC_MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc_ps.h:176
void * hwaccel_picture_private
Definition: hevcdec.h:410
uint8_t * cabac_state
Definition: hevcdec.h:482
int sei_hflip
Definition: hevcdec.h:585
InterPredIdc
Definition: hevcdec.h:159
uint8_t nb_refs
Definition: hevcdec.h:233
MvField * tab_mvf
Definition: hevcdec.h:396
int pic_init_qp_minus26
Definition: hevc_ps.h:245
int bs_width
Definition: hevcdec.h:513
uint8_t intra_split_flag
IntraSplitFlag.
Definition: hevcdec.h:332
VUI vui
Definition: hevc_ps.h:169
int rem_intra_luma_pred_mode
Definition: hevcdec.h:359
static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1, int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
8.5.3.2.2.2 Chroma sample bidirectional interpolation process
Definition: hevcdec.c:1581
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2469
static int hls_transform_tree(HEVCContext *s, 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:1184
int vshift[3]
Definition: hevc_ps.h:228
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:865
static const AVClass hevc_decoder_class
Definition: hevcdec.c:3427
int num
Numerator.
Definition: rational.h:59
int size
Definition: avcodec.h:1658
unsigned int slice_addr
Definition: hevcdec.h:253
uint32_t vui_time_scale
Definition: hevc_ps.h:76
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
Definition: hevcdec.c:253
uint8_t weighted_bipred_flag
Definition: hevc_ps.h:257
static void hevc_decode_flush(AVCodecContext *avctx)
Definition: hevcdec.c:3408
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
Definition: hevc_cabac.c:585
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:459
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:111
int tc_offset
Definition: hevcdec.h:385
PredictionUnit pu
Definition: hevcdec.h:455
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1960
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc_ps.h:270
uint8_t cabac_init_present_flag
Definition: hevc_ps.h:241
int16_t chroma_offset_l1[16][2]
Definition: hevcdec.h:319
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:524
void(* put_hevc_epel_uni[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *_src, ptrdiff_t _srcstride, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:89
int has_primaries
Flag indicating whether the display primaries (and white point) are set.
HEVCParamSets ps
Definition: hevcdec.h:492
int min_cb_height
Definition: hevc_ps.h:220
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc_ps.h:303
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc_ps.h:243
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
int8_t cr_qp_offset_list[6]
Definition: hevc_ps.h:291
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:781
uint8_t dependent_slice_segment_flag
Definition: hevcdec.h:260
#define src
Definition: vp8dsp.c:254
CABACContext cc
Definition: hevcdec.h:432
ShortTermRPS slice_rps
Definition: hevcdec.h:267
#define SET_SAO(elem, value)
Definition: hevcdec.c:861
int profile
profile
Definition: avcodec.h:3235
Views are next to each other.
Definition: stereo3d.h:45
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:3681
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
int width
Definition: hevc_ps.h:214
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
static void hls_sao_param(HEVCContext *s, int rx, int ry)
Definition: hevcdec.c:873
uint16_t seq_decode
Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...
Definition: hevcdec.h:549
static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_addr_ts)
Definition: hevcdec.c:2287
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
Definition: md5.c:153
uint8_t threads_type
Definition: hevcdec.h:476
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc_ps.h:230
int pixel_shift
Definition: hevc_ps.h:155
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc_ps.h:263
#define PAR
Definition: hevcdec.c:3417
uint32_t min_mastering_luminance
Definition: hevcdec.h:597
int max_ra
Definition: hevcdec.h:512
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:817
int output_width
Definition: hevc_ps.h:148
const uint8_t * data
Definition: hevcdec.h:555
AVBufferPool * rpl_tab_pool
candidate references for the current frame
Definition: hevcdec.h:495
uint8_t log2_sao_offset_scale_chroma
Definition: hevc_ps.h:293
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:3052
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:72
#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: avcodec.h:1019
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
int chroma_format_idc
Definition: hevc_ps.h:144
uint8_t disable_dbf
Definition: hevc_ps.h:274
unsigned int log2_max_trafo_size
Definition: hevc_ps.h:199
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevcdec.h:251
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:32
void(* put_hevc_epel[10][2][2])(int16_t *dst, uint8_t *src, ptrdiff_t srcstride, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:86
enum HEVCSliceType slice_type
Definition: hevcdec.h:255
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:315
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:855
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:550
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:749
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
int end_of_tiles_x
Definition: hevcdec.h:445
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
enum HEVCNALUnitType nal_unit_type
Definition: hevcdec.h:503
static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0, int log2_cb_size, int ct_depth)
Definition: hevcdec.c:1931
static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:1169
void ff_hevc_reset_sei(HEVCContext *s)
Reset SEI values that are stored on the Context.
Definition: hevc_sei.c:383
float delta
AVOptions.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:123
uint8_t ctb_up_right_flag
Definition: hevcdec.h:443
LongTermRPS long_term_rps
Definition: hevcdec.h:270
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
Definition: hevc_cabac.c:786
int poc[32]
Definition: hevcdec.h:231
static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
Definition: hevcdec.c:2480
struct HEVCFrame * ref[HEVC_MAX_REFS]
Definition: hevcdec.h:237
uint8_t vps_timing_info_present_flag
Definition: hevc_ps.h:124
uint8_t matrix_coeffs
Definition: hevc_ps.h:61
#define OFFSET(x)
Definition: hevcdec.c:3416
void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int log2_trafo_size)
Definition: hevc_filter.c:714
int min_tb_width
Definition: hevc_ps.h:221
int num_entry_point_offsets
Definition: hevcdec.h:303
#define BOUNDARY_LEFT_TILE
Definition: hevcdec.h:459
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:694
AVFrame * output_frame
Definition: hevcdec.h:488
int apply_defdispwin
Definition: hevcdec.h:569
SAOParams * sao
Definition: hevcdec.h:501
const HEVCVPS * vps
Definition: hevc_ps.h:319
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc_ps.h:244
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1847
unsigned int log2_min_pcm_cb_size
Definition: hevc_ps.h:189
AVCodecContext * avctx
Definition: hevcdec.h:469
int min_cb_width
Definition: hevc_ps.h:219
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:736
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:371
static AVFrame * frame
#define QPEL_EXTRA_BEFORE
Definition: hevcdec.h:64
struct AVMD5 * md5
Definition: movenc.c:56
const char data[16]
Definition: mxf.c:90
Structure to hold side data for an AVFrame.
Definition: frame.h:149
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:299
BswapDSPContext bdsp
Definition: hevcdec.h:522
#define height
ThreadFrame tf
Definition: hevcdec.h:395
uint8_t first_slice_in_pic_flag
Definition: hevcdec.h:259
uint8_t * data
Definition: avcodec.h:1657
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
const uint8_t * buffer
Definition: bytestream.h:34
uint8_t ctb_up_left_flag
Definition: hevcdec.h:444
void ff_hevc_hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc_cabac.c:1523
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Definition: hevc_cabac.c:607
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:3973
uint8_t threads_number
Definition: hevcdec.h:477
uint8_t is_cu_chroma_qp_offset_coded
Definition: hevcdec.h:377
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:225
void(* put_hevc_qpel_uni_w[10][2][2])(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride, int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:76
int8_t pred_flag
Definition: hevcdec.h:345
AVBufferRef * pps_list[HEVC_MAX_PPS_COUNT]
Definition: hevc_ps.h:316
int8_t * qp_y_tab
Definition: hevcdec.h:523
uint8_t loop_filter_disable_flag
Definition: hevc_ps.h:191
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:860
int sei_anticlockwise_rotation
Definition: hevcdec.h:584
uint8_t pic_output_flag
Definition: hevcdec.h:261
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
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
uint8_t * tab_ct_depth
Definition: hevcdec.h:531
uint8_t cu_transquant_bypass_flag
Definition: hevcdec.h:334
void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size)
Definition: hevc_filter.c:842
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
Views are alternated temporally.
Definition: stereo3d.h:66
void(* put_hevc_qpel[10][2][2])(int16_t *dst, uint8_t *src, ptrdiff_t srcstride, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:72
int8_t cb_qp_offset_list[6]
Definition: hevc_ps.h:290
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
int ff_hevc_log2_res_scale_abs(HEVCContext *s, int idx)
Definition: hevc_cabac.c:885
uint8_t transquant_bypass_enable_flag
Definition: hevc_ps.h:259
#define av_log(a,...)
uint8_t used[32]
Definition: hevcdec.h:232
int temporal_id
temporal_id_plus1 - 1
Definition: hevcdec.h:504
uint8_t first_qp_group
Definition: hevcdec.h:429
HEVCDSPContext hevcdsp
Definition: hevcdec.h:520
int ctb_count
Definition: hevcdec.h:399
uint8_t no_output_of_prior_pics_flag
Definition: hevcdec.h:274
HEVCLocalContext * HEVClcList[MAX_NB_THREADS]
Definition: hevcdec.h:473
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:504
int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
Definition: hevc_cabac.c:659
int bit_depth_chroma
Definition: hevc_ps.h:154
const AVProfile ff_hevc_profiles[]
Definition: profiles.c:78
int slice_idx
number of the slice being currently decoded
Definition: hevcdec.h:509
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:589
static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
Definition: hevcdec.c:2403
uint8_t intra_pred_mode[4]
Definition: hevcdec.h:360
uint8_t colour_plane_id
RPS coded in the slice header itself is stored here.
Definition: hevcdec.h:262
#define QPEL_EXTRA_AFTER
Definition: hevcdec.h:65
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:602
#define SAMPLE_CTB(tab, x, y)
Definition: hevcdec.h:74
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:2054
uint8_t cu_chroma_qp_offset_enabled_flag
Definition: hevcdec.h:293
int flags
Additional information about the frame packing.
Definition: stereo3d.h:132
uint8_t slice_initialized
1 if the independent slice segment header was successfully parsed
Definition: hevcdec.h:485
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:158
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
Definition: hevcdec.c:3139
int * skipped_bytes_pos
Definition: h2645_parse.h:61
int min_pu_height
Definition: hevc_ps.h:224
#define atomic_load(object)
Definition: stdatomic.h:93
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:416
av_default_item_name
AVBufferRef * rpl_tab_buf
Definition: hevcdec.h:406
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size)
Definition: hevc_filter.c:867
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
uint8_t rpl_modification_flag[2]
Definition: hevcdec.h:273
int * size
Definition: hevcdec.h:302
int vui_timing_info_present_flag
Definition: hevc_ps.h:74
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
Definition: hevcdec.c:2890
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3180
static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:1307
RefPicList * refPicList
Definition: hevcdec.h:397
int16_t luma_offset_l0[16]
Definition: hevcdec.h:315
int bs_height
Definition: hevcdec.h:514
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:57
void(* intra_pred[4])(struct HEVCContext *s, int x0, int y0, int c_idx)
Definition: hevcpred.h:32
#define CTB(tab, x, y)
Definition: hevcdec.c:859
#define s0
Definition: regdef.h:37
uint16_t display_primaries[3][2]
Definition: hevcdec.h:594
static void intra_prediction_unit_default_value(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:2016
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * arg
Definition: jacosubdec.c:66
unsigned int log2_ctb_size
Definition: hevc_ps.h:200
static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
Definition: hevcdec.c:357
int picture_struct
Definition: hevcdec.h:587
uint8_t * sao_pixel_buffer_h[3]
Definition: hevcdec.h:489
int8_t cu_qp_offset_cb
Definition: hevcdec.h:378
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:222
int tc_offset
tc_offset_div2 * 2
Definition: hevcdec.h:296
const char * name
Name of the codec implementation.
Definition: avcodec.h:3688
const ShortTermRPS * short_term_rps
Definition: hevcdec.h:268
uint8_t merge_flag
Definition: hevcdec.h:362
#define IS_IDR(s)
Definition: hevcdec.h:76
struct AVMD5 * md5_ctx
Definition: hevcdec.h:562
unsigned * entry_point_offset
Definition: hevcdec.h:300
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int8_t slice_qp
Definition: hevcdec.h:305
#define FFMAX(a, b)
Definition: common.h:94
#define BOUNDARY_UPPER_TILE
Definition: hevcdec.h:461
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
static void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.h:229
#define fail()
Definition: checkasm.h:89
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1057
uint8_t max_trafo_depth
MaxTrafoDepth.
Definition: hevcdec.h:333
int raw_size
Definition: h2645_parse.h:44
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: hevcdec.h:416
uint8_t colour_primaries
Definition: hevc_ps.h:59
static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: hevcdec.c:3076
static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevcdec.c:2039
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevcdec.h:275
Definition: hevcdec.h:168
uint8_t * vertical_bs
Definition: hevcdec.h:525
int ff_hevc_sao_band_position_decode(HEVCContext *s)
Definition: hevc_cabac.c:565
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
int chroma_mode_c
Definition: hevcdec.h:375
uint8_t tiles_enabled_flag
Definition: hevc_ps.h:262
int ff_alloc_entries(AVCodecContext *avctx, int count)
int eo_class[3]
sao_eo_class
Definition: hevcdsp.h:38
uint32_t vps_num_units_in_tick
Definition: hevc_ps.h:125
int16_t luma_weight_l0[16]
Definition: hevcdec.h:310
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:469
int * col_idxX
Definition: hevc_ps.h:300
struct HEVCContext * sList[MAX_NB_THREADS]
Definition: hevcdec.h:471
int slice_qp_delta
Definition: hevcdec.h:289
common internal API header
int intra_pred_mode
Definition: hevcdec.h:373
enum HEVCNALUnitType first_nal_type
Definition: hevcdec.h:559
int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
Compute POC of the current frame and return it.
Definition: hevc_refs.c:519
const HEVCSPS * sps
Definition: hevc_ps.h:320
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
Definition: hevc_cabac.c:590
uint8_t lists_modification_present_flag
Definition: hevc_ps.h:281
#define IS_IRAP(s)
Definition: hevcdec.h:79
uint8_t profile_idc
Definition: hevc_ps.h:95
#define L1
Definition: hevcdec.h:59
AVBufferRef * tab_mvf_buf
Definition: hevcdec.h:405
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:171
uint8_t type_idx[3]
sao_type_idx
Definition: hevcdsp.h:42
uint8_t chroma_mode_c[4]
Definition: hevcdec.h:364
int beta_offset
beta_offset_div2 * 2
Definition: hevcdec.h:295
AVMasteringDisplayMetadata * av_mastering_display_metadata_create_side_data(AVFrame *frame)
Allocate a complete AVMasteringDisplayMetadata and add it to the frame.
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:261
int res_scale_val
Definition: hevcdec.h:370
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx)
Definition: hevc_cabac.c:894
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:3020
Definition: hevcdec.h:169
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3172
int max_transform_hierarchy_depth_inter
Definition: hevc_ps.h:203
#define FFMIN(a, b)
Definition: common.h:96
uint8_t * sao_pixel_buffer_v[3]
Definition: hevcdec.h:490
#define EPEL_EXTRA_BEFORE
Definition: hevcdec.h:61
int slice_cr_qp_offset
Definition: hevcdec.h:291
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
int offset_abs[3][4]
sao_offset_abs
Definition: hevcdsp.h:33
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc_ps.h:265
#define width
int output_height
Definition: hevc_ps.h:148
int width
picture width / height.
Definition: avcodec.h:1919
uint8_t * tab_ipm
Definition: hevcdec.h:533
static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, int prev_intra_luma_pred_flag)
8.4.1
Definition: hevcdec.c:1851
int hshift[3]
Definition: hevc_ps.h:227
struct HEVCSPS::@67 temporal_layer[HEVC_MAX_SUB_LAYERS]
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
int32_t
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:177
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2448
uint8_t cu_qp_delta_enabled_flag
Definition: hevc_ps.h:250
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc_ps.h:183
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
Definition: hevcdec.c:2931
int sei_mastering_display_info_present
mastering display
Definition: hevcdec.h:593
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:3173
Context Adaptive Binary Arithmetic Coder inline functions.
int level
level
Definition: avcodec.h:3333
int intra_pred_mode_c
Definition: hevcdec.h:374
int ctb_width
Definition: hevc_ps.h:216
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:57
int16_t chroma_weight_l0[16][2]
Definition: hevcdec.h:311
int height
Definition: hevc_ps.h:215
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:3031
void(* put_hevc_qpel_bi[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *_src, ptrdiff_t _srcstride, int16_t *src2, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:79
static av_cold int hevc_decode_init(AVCodecContext *avctx)
Definition: hevcdec.c:3356
uint8_t output_flag_present_flag
Definition: hevc_ps.h:258
uint16_t seq_output
Definition: hevcdec.h:550
PTLCommon general_ptl
Definition: hevc_ps.h:105
static int hevc_decode_extradata(HEVCContext *s, uint8_t *buf, int length, int first)
Definition: hevcdec.c:3004
int16_t luma_offset_l1[16]
Definition: hevcdec.h:318
int16_t chroma_offset_l0[16][2]
Definition: hevcdec.h:316
if(ret< 0)
Definition: vf_mcdeint.c:282
uint32_t max_mastering_luminance
Definition: hevcdec.h:596
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:114
int type
NAL unit type.
Definition: h2645_parse.h:52
static void error(const char *err)
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
Definition: display.c:50
#define IS_BLA(s)
Definition: hevcdec.h:77
#define POS(c_idx, x, y)
unsigned vps_id
Definition: hevc_ps.h:143
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:3161
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:480
unsigned int pps_id
address (in raster order) of the first block in the current slice segment
Definition: hevcdec.h:248
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc_ps.h:255
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:85
uint32_t vps_time_scale
Definition: hevc_ps.h:126
void ff_reset_entries(AVCodecContext *avctx)
int colour_description_present_flag
Definition: hevc_ps.h:58
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1061
static const int8_t mv[256][2]
Definition: 4xm.c:77
HEVCFrame DPB[32]
Definition: hevcdec.h:506
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:251
enum AVPixelFormat pix_fmt
Definition: hevc_ps.h:156
RefPicListTab ** rpl_tab
Definition: hevcdec.h:398
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:770
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:3221
int sei_display_orientation_present
display orientation
Definition: hevcdec.h:583
int slice_cb_qp_offset
Definition: hevcdec.h:290
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition: hevcdsp.c:126
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: avcodec.h:1412
const uint8_t ff_hevc_pel_weight[65]
Definition: hevcdec.c:45
#define src1
Definition: h264pred.c:139
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:127
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:66
static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist, int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
8.5.3.2.2.2 Chroma sample uniprediction interpolation process
Definition: hevcdec.c:1516
int short_term_ref_pic_set_size
Definition: hevcdec.h:266
static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
Definition: hevcdec.c:1680
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:83
int16_t tmp[64 *64]
Definition: hevcdec.h:451
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3889
#define L0
Definition: hevcdec.h:58
uint8_t is_nalff
this flag is != 0 if bitstream is encapsulated as a format defined in 14496-15
Definition: hevcdec.h:567
static int hls_transform_unit(HEVCContext *s, 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:963
enum AVCodecID codec_id
Definition: avcodec.h:1749
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:302
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:218
PTL ptl
Definition: hevc_ps.h:170
int max_sub_layers
Definition: hevc_ps.h:161
#define EPEL_EXTRA_AFTER
Definition: hevcdec.h:62
unsigned int log2_min_pu_size
Definition: hevc_ps.h:201
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:457
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:87
int ff_hevc_decode_nal_sei(HEVCContext *s)
Definition: hevc_sei.c:371
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:597
uint8_t md5[3][16]
Definition: hevcdec.h:563
unsigned int sps_id
seq_parameter_set_id
Definition: hevc_ps.h:237
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
int long_term_ref_pic_set_size
Definition: hevcdec.h:269
main external API structure.
Definition: avcodec.h:1732
uint8_t is_md5
Definition: hevcdec.h:564
uint8_t sao_enabled
Definition: hevc_ps.h:179
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:65
enum PredMode pred_mode
PredMode.
Definition: hevcdec.h:328
AVBufferRef * hwaccel_priv_buf
Definition: hevcdec.h:409
int num_extra_slice_header_bits
Definition: hevc_ps.h:283
uint8_t * data
The data buffer.
Definition: buffer.h:89
atomic_int wpp_err
Definition: hevcdec.h:553
int16_t y
vertical component of motion vector
Definition: hevcdec.h:339
uint8_t cross_pf
Definition: hevcdec.h:380
#define EDGE_EMU_BUFFER_STRIDE
Definition: hevcdec.h:68
const uint8_t * data
Definition: h2645_parse.h:36
uint8_t num_long_term_ref_pics_sps
Definition: hevc_ps.h:184
uint8_t * data
Definition: frame.h:151
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:143
TransformUnit tu
Definition: hevcdec.h:439
uint8_t cross_component_prediction_enabled_flag
Definition: hevc_ps.h:286
void * buf
Definition: avisynth_c.h:690
uint32_t vui_num_units_in_tick
Definition: hevc_ps.h:75
int extradata_size
Definition: avcodec.h:1848
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
uint8_t ctb_left_flag
Definition: hevcdec.h:441
uint8_t deblocking_filter_control_present_flag
Definition: hevc_ps.h:272
int cu_qp_delta
Definition: hevcdec.h:368
uint8_t * is_pcm
Definition: hevcdec.h:536
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:314
static int pred_weight_table(HEVCContext *s, GetBitContext *gb)
Definition: hevcdec.c:141
uint8_t * checksum_buf
used on BE to byteswap the lines for checksumming
Definition: hevcdec.h:542
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:355
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc_ps.h:193
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:649
unsigned int nb_st_rps
Definition: hevc_ps.h:175
int coded_height
Definition: avcodec.h:1934
uint8_t cabac_init_flag
Definition: hevcdec.h:282
Describe the class of an AVClass context structure.
Definition: log.h:67
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc_ps.h:266
void ff_hevc_bump_frame(HEVCContext *s)
Definition: hevc_refs.c:241
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:3552
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:307
static const AVProfile profiles[]
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:667
uint8_t chroma_qp_offset_list_enabled_flag
Definition: hevc_ps.h:287
int poc
Definition: hevcdec.h:400
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:275
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2462
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2455
Copyright (c) 2016 Neil Birkbeck neil.birkbeck@gmail.com
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:213
AVFrame * frame
Definition: hevcdec.h:487
static av_cold int hevc_init_context(AVCodecContext *avctx)
Definition: hevcdec.c:3232
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:426
int enable_parallel_tiles
Definition: hevcdec.h:552
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:448
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:450
void(* add_residual[4])(uint8_t *dst, int16_t *res, ptrdiff_t stride)
Definition: hevcdsp.h:49
unsigned int max_num_merge_cand
5 - 5_minus_max_num_merge_cand
Definition: hevcdec.h:298
int checksum_buf_size
Definition: hevcdec.h:543
int last_eos
last packet contains an EOS/EOB NAL
Definition: hevcdec.h:511
DBParams * deblock
Definition: hevcdec.h:502
GetBitContext gb
Definition: hevcdec.h:431
#define BOUNDARY_UPPER_SLICE
Definition: hevcdec.h:460
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:3028
static int hevc_frame_start(HEVCContext *s)
Definition: hevcdec.c:2689
unsigned int log2_min_tb_size
Definition: hevc_ps.h:198
void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
Definition: hevc_mvs.c:479
#define src0
Definition: h264pred.c:138
enum PartMode part_mode
PartMode.
Definition: hevcdec.h:329
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc_ps.h:182
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1473
uint8_t intra_pred_mode_c[4]
Definition: hevcdec.h:363
#define s1
Definition: regdef.h:38
void(* put_hevc_qpel_uni[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:74
Definition: hevcdec.h:167
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1225
Definition: hevcdec.h:337
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:188
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:126
HEVCWindow window
Definition: hevcdec.h:403
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:347
int * tile_id
TileId.
Definition: hevc_ps.h:304
int16_t luma_weight_l1[16]
Definition: hevcdec.h:313
int16_t chroma_log2_weight_denom
Definition: hevcdec.h:308
int tc_offset
tc_offset_div2 * 2
Definition: hevc_ps.h:276
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:152
uint8_t transfer_characteristic
Definition: hevc_ps.h:60
AVRational display_primaries[3][2]
CIE 1931 xy chromaticity coords of color primaries (r, g, b order).
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
Definition: hevc_cabac.c:796
int pocTid0
Definition: hevcdec.h:508
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevcdec.h:421
HEVCLocalContext * HEVClc
Definition: hevcdec.h:474
static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref, const Mv *mv, int y0, int height)
Definition: hevcdec.c:1671
static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps, const HEVCSPS *sps)
Definition: hevcdec.c:311
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:498
#define QPEL_EXTRA
Definition: hevcdec.h:66
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3878
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:33
AVCodec ff_hevc_decoder
Definition: hevcdec.c:3434
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:201
uint8_t level
Definition: svq3.c:207
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
Definition: hevc_cabac.c:654
uint8_t level_idc
Definition: hevc_ps.h:97
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:479
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:3864
int eos
current packet contains an EOS/EOB NAL
Definition: hevcdec.h:510
static int hls_slice_header(HEVCContext *s)
Definition: hevcdec.c:454
#define BOUNDARY_LEFT_SLICE
Definition: hevcdec.h:458
int sei_vflip
Definition: hevcdec.h:585
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
Definition: hevcdec.c:85
void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, 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:582
int max_transform_hierarchy_depth_intra
Definition: hevc_ps.h:204
Mv mv[2]
Definition: hevcdec.h:343
int
static int hls_slice_data(HEVCContext *s)
Definition: hevcdec.c:2392
uint8_t * skip_flag
Definition: hevcdec.h:530
static int hevc_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: hevcdec.c:3280
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:759
int8_t ref_idx[2]
Definition: hevcdec.h:344
common internal and external API header
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:238
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
uint8_t weighted_pred_flag
Definition: hevc_ps.h:256
uint8_t * horizontal_bs
Definition: hevcdec.h:524
uint8_t * a53_caption
Definition: hevcdec.h:589
static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int partIdx, int idx)
Definition: hevcdec.c:1725
unsigned int nb_refs[2]
Definition: hevcdec.h:277
int32_t * tab_slice_address
Definition: hevcdec.h:527
uint8_t disable_deblocking_filter_flag
slice_header_disable_deblocking_filter_flag
Definition: hevcdec.h:283
int16_t offset_val[3][5]
SaoOffsetVal.
Definition: hevcdsp.h:40
unsigned int * column_width
ColumnWidth.
Definition: hevc_ps.h:296
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
Definition: hevcdec.c:2336
uint8_t * filter_slice_edges
Definition: hevcdec.h:539
uint8_t slice_header_extension_present_flag
Definition: hevc_ps.h:284
uint8_t collocated_list
Definition: hevcdec.h:285
#define HEVC_MAX_PPS_COUNT
Definition: hevc.h:67
unsigned properties
Definition: avcodec.h:3550
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: hevcdec.h:573
int den
Denominator.
Definition: rational.h:60
int slice_ctb_addr_rs
Definition: hevcdec.h:321
AVBufferPool * tab_mvf_pool
Definition: hevcdec.h:494
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:555
int video_full_range_flag
Definition: hevc_ps.h:57
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7) *EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevcdec.h:450
GetBitContext gb
Definition: h2645_parse.h:47
static const uint8_t tab_mode_idx[]
Definition: hevcdec.c:1944
AVRational sar
Definition: hevc_ps.h:50
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc_ps.h:289
uint16_t white_point[2]
Definition: hevcdec.h:595
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: hevcdec.h:284
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1774
const uint8_t * raw_data
Definition: h2645_parse.h:45
void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, int nPbW, int nPbH)
Definition: hevc_mvs.c:42
#define av_free(p)
unsigned int collocated_ref_idx
Definition: hevcdec.h:287
int ff_hevc_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:670
CodingUnit cu
Definition: hevcdec.h:454
static const int16_t coeffs[]
int min_pu_width
Definition: hevc_ps.h:223
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1782
int beta_offset
Definition: hevcdec.h:384
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:741
void(* put_hevc_epel_bi[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *_src, ptrdiff_t _srcstride, int16_t *src2, int height, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:93
H2645NAL * nals
Definition: h2645_parse.h:70
int ff_hevc_pcm_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:731
void ff_hevc_hls_residual_coding(HEVCContext *s, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx)
Definition: hevc_cabac.c:1013
#define HWACCEL_MAX
Views are on top of each other.
Definition: stereo3d.h:55
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:256
#define AV_ZERO32(d)
Definition: intreadwrite.h:619
unsigned int list_entry_lx[2][32]
Definition: hevcdec.h:271
uint8_t luma_log2_weight_denom
Definition: hevcdec.h:307
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:542
int16_t chroma_weight_l1[16][2]
Definition: hevcdec.h:312
uint8_t long_term_ref_pics_present_flag
Definition: hevc_ps.h:181
H2645Packet pkt
Definition: hevcdec.h:557
int temporal_id
HEVC only, nuh_temporal_id_plus_1 - 1.
Definition: h2645_parse.h:57
void(* put_hevc_epel_uni_w[10][2][2])(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride, int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:91
static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride, AVFrame *ref0, const Mv *mv0, int x_off, int y_off, int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
8.5.3.2.2.1 Luma sample bidirectional interpolation process
Definition: hevcdec.c:1425
int boundary_flags
Definition: hevcdec.h:464
FILE * out
Definition: movenc.c:54
int diff_cu_qp_delta_depth
Definition: hevc_ps.h:251
static int hls_cross_component_pred(HEVCContext *s, int idx)
Definition: hevcdec.c:947
Public header for MD5 hash function implementation.
#define atomic_init(obj, value)
Definition: stdatomic.h:33
#define av_freep(p)
static const AVOption options[]
Definition: hevcdec.c:3419
#define EPEL_EXTRA
Definition: hevcdec.h:63
int num_reorder_pics
Definition: hevc_ps.h:164
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: ffmpeg.c:2261
#define av_always_inline
Definition: attributes.h:39
HW decoding through Direct3D11, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer...
Definition: pixfmt.h:247
void ff_hevc_set_qPy(HEVCContext *s, int xBase, int yBase, int log2_cb_size)
Definition: hevc_filter.c:121
#define av_malloc_array(a, b)
uint8_t context_initialized
Definition: hevcdec.h:566
AVBufferRef * rpl_buf
Definition: hevcdec.h:407
int is_decoded
Definition: hevcdec.h:516
int video_signal_type_present_flag
Definition: hevc_ps.h:55
#define FFSWAP(type, a, b)
Definition: common.h:99
const char int length
Definition: avisynth_c.h:768
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc_ps.h:273
int bit_depth
Definition: hevc_ps.h:153
int beta_offset
beta_offset_div2 * 2
Definition: hevc_ps.h:275
#define SUBDIVIDE(x, y, idx)
int min_tb_height
Definition: hevc_ps.h:222
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
Definition: hevc_cabac.c:575
static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, int cb_depth)
Definition: hevcdec.c:2202
#define HEVC_MAX_REFS
Definition: hevc.h:71
uint8_t * cbf_luma
Definition: hevcdec.h:535
int depth
Number of bits in the component.
Definition: pixdesc.h:58
SliceHeader sh
Definition: hevcdec.h:500
int no_rasl_output_flag
Definition: hevcdec.h:517
static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
Definition: hevcdec.c:3394
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:3201
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc_ps.h:159
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1634
int * offset
Definition: hevcdec.h:301
uint8_t mvd_l1_zero_flag
Definition: hevcdec.h:280
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:994
int a53_caption_size
Definition: hevcdec.h:590
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc_ps.h:145
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:277
#define FFMAX3(a, b, c)
Definition: common.h:95
int end_of_tiles_y
Definition: hevcdec.h:446
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
Definition: hevc_cabac.c:622
uint8_t slice_sample_adaptive_offset_flag[3]
Definition: hevcdec.h:279
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:812
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc_ps.h:261
int offset_sign[3][4]
sao_offset_sign
Definition: hevcdsp.h:34
void(* put_hevc_epel_bi_w[10][2][2])(uint8_t *dst, ptrdiff_t dststride, uint8_t *_src, ptrdiff_t _srcstride, int16_t *src2, int height, int denom, int wx0, int ox0, int wx1, int ox1, intptr_t mx, intptr_t my, int width)
Definition: hevcdsp.h:96
static av_cold int hevc_decode_free(AVCodecContext *avctx)
Definition: hevcdec.c:3180