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