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