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