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