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