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