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