FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevc.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/atomic.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/display.h"
30 #include "libavutil/internal.h"
32 #include "libavutil/md5.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/stereo3d.h"
36 
37 #include "bswapdsp.h"
38 #include "bytestream.h"
39 #include "cabac_functions.h"
40 #include "golomb.h"
41 #include "hevc.h"
42 #include "profiles.h"
43 
44 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 };
45 
46 /**
47  * NOTE: Each function hls_foo correspond to the function foo in the
48  * specification (HLS stands for High Level Syntax).
49  */
50 
51 /**
52  * Section 5.7
53  */
54 
55 /* free everything allocated by pic_arrays_init() */
57 {
58  av_freep(&s->sao);
59  av_freep(&s->deblock);
60 
61  av_freep(&s->skip_flag);
63 
64  av_freep(&s->tab_ipm);
65  av_freep(&s->cbf_luma);
66  av_freep(&s->is_pcm);
67 
68  av_freep(&s->qp_y_tab);
71 
73  av_freep(&s->vertical_bs);
74 
76  av_freep(&s->sh.size);
77  av_freep(&s->sh.offset);
78 
81 }
82 
83 /* allocate arrays that depend on frame dimensions */
84 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
85 {
86  int log2_min_cb_size = sps->log2_min_cb_size;
87  int width = sps->width;
88  int height = sps->height;
89  int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
90  ((height >> log2_min_cb_size) + 1);
91  int ctb_count = sps->ctb_width * sps->ctb_height;
92  int min_pu_size = sps->min_pu_width * sps->min_pu_height;
93 
94  s->bs_width = (width >> 2) + 1;
95  s->bs_height = (height >> 2) + 1;
96 
97  s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
98  s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
99  if (!s->sao || !s->deblock)
100  goto fail;
101 
104  if (!s->skip_flag || !s->tab_ct_depth)
105  goto fail;
106 
108  s->tab_ipm = av_mallocz(min_pu_size);
109  s->is_pcm = av_malloc_array(sps->min_pu_width + 1, sps->min_pu_height + 1);
110  if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
111  goto fail;
112 
113  s->filter_slice_edges = av_mallocz(ctb_count);
114  s->tab_slice_address = av_malloc_array(pic_size_in_ctb,
115  sizeof(*s->tab_slice_address));
116  s->qp_y_tab = av_malloc_array(pic_size_in_ctb,
117  sizeof(*s->qp_y_tab));
118  if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
119  goto fail;
120 
123  if (!s->horizontal_bs || !s->vertical_bs)
124  goto fail;
125 
126  s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
128  s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
130  if (!s->tab_mvf_pool || !s->rpl_tab_pool)
131  goto fail;
132 
133  return 0;
134 
135 fail:
136  pic_arrays_free(s);
137  return AVERROR(ENOMEM);
138 }
139 
141 {
142  int i = 0;
143  int j = 0;
144  uint8_t luma_weight_l0_flag[16];
145  uint8_t chroma_weight_l0_flag[16];
146  uint8_t luma_weight_l1_flag[16];
147  uint8_t chroma_weight_l1_flag[16];
148  int luma_log2_weight_denom;
149 
150  luma_log2_weight_denom = get_ue_golomb_long(gb);
151  if (luma_log2_weight_denom < 0 || luma_log2_weight_denom > 7)
152  av_log(s->avctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is invalid\n", luma_log2_weight_denom);
153  s->sh.luma_log2_weight_denom = av_clip_uintp2(luma_log2_weight_denom, 3);
154  if (s->ps.sps->chroma_format_idc != 0) {
155  int delta = get_se_golomb(gb);
156  s->sh.chroma_log2_weight_denom = av_clip_uintp2(s->sh.luma_log2_weight_denom + delta, 3);
157  }
158 
159  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
160  luma_weight_l0_flag[i] = get_bits1(gb);
161  if (!luma_weight_l0_flag[i]) {
162  s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
163  s->sh.luma_offset_l0[i] = 0;
164  }
165  }
166  if (s->ps.sps->chroma_format_idc != 0) {
167  for (i = 0; i < s->sh.nb_refs[L0]; i++)
168  chroma_weight_l0_flag[i] = get_bits1(gb);
169  } else {
170  for (i = 0; i < s->sh.nb_refs[L0]; i++)
171  chroma_weight_l0_flag[i] = 0;
172  }
173  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
174  if (luma_weight_l0_flag[i]) {
175  int delta_luma_weight_l0 = get_se_golomb(gb);
176  s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
177  s->sh.luma_offset_l0[i] = get_se_golomb(gb);
178  }
179  if (chroma_weight_l0_flag[i]) {
180  for (j = 0; j < 2; j++) {
181  int delta_chroma_weight_l0 = get_se_golomb(gb);
182  int delta_chroma_offset_l0 = get_se_golomb(gb);
183  s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
184  s->sh.chroma_offset_l0[i][j] = av_clip((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
185  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
186  }
187  } else {
188  s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
189  s->sh.chroma_offset_l0[i][0] = 0;
190  s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
191  s->sh.chroma_offset_l0[i][1] = 0;
192  }
193  }
194  if (s->sh.slice_type == B_SLICE) {
195  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
196  luma_weight_l1_flag[i] = get_bits1(gb);
197  if (!luma_weight_l1_flag[i]) {
198  s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
199  s->sh.luma_offset_l1[i] = 0;
200  }
201  }
202  if (s->ps.sps->chroma_format_idc != 0) {
203  for (i = 0; i < s->sh.nb_refs[L1]; i++)
204  chroma_weight_l1_flag[i] = get_bits1(gb);
205  } else {
206  for (i = 0; i < s->sh.nb_refs[L1]; i++)
207  chroma_weight_l1_flag[i] = 0;
208  }
209  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
210  if (luma_weight_l1_flag[i]) {
211  int delta_luma_weight_l1 = get_se_golomb(gb);
212  s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
213  s->sh.luma_offset_l1[i] = get_se_golomb(gb);
214  }
215  if (chroma_weight_l1_flag[i]) {
216  for (j = 0; j < 2; j++) {
217  int delta_chroma_weight_l1 = get_se_golomb(gb);
218  int delta_chroma_offset_l1 = get_se_golomb(gb);
219  s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
220  s->sh.chroma_offset_l1[i][j] = av_clip((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
221  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
222  }
223  } else {
224  s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
225  s->sh.chroma_offset_l1[i][0] = 0;
226  s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
227  s->sh.chroma_offset_l1[i][1] = 0;
228  }
229  }
230  }
231 }
232 
234 {
235  const HEVCSPS *sps = s->ps.sps;
236  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
237  int prev_delta_msb = 0;
238  unsigned int nb_sps = 0, nb_sh;
239  int i;
240 
241  rps->nb_refs = 0;
243  return 0;
244 
245  if (sps->num_long_term_ref_pics_sps > 0)
246  nb_sps = get_ue_golomb_long(gb);
247  nb_sh = get_ue_golomb_long(gb);
248 
249  if (nb_sh + (uint64_t)nb_sps > FF_ARRAY_ELEMS(rps->poc))
250  return AVERROR_INVALIDDATA;
251 
252  rps->nb_refs = nb_sh + nb_sps;
253 
254  for (i = 0; i < rps->nb_refs; i++) {
255  uint8_t delta_poc_msb_present;
256 
257  if (i < nb_sps) {
258  uint8_t lt_idx_sps = 0;
259 
260  if (sps->num_long_term_ref_pics_sps > 1)
261  lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
262 
263  rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
264  rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
265  } else {
266  rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
267  rps->used[i] = get_bits1(gb);
268  }
269 
270  delta_poc_msb_present = get_bits1(gb);
271  if (delta_poc_msb_present) {
272  int delta = get_ue_golomb_long(gb);
273 
274  if (i && i != nb_sps)
275  delta += prev_delta_msb;
276 
277  rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
278  prev_delta_msb = delta;
279  }
280  }
281 
282  return 0;
283 }
284 
285 static void export_stream_params(AVCodecContext *avctx, const HEVCParamSets *ps,
286  const HEVCSPS *sps)
287 {
288  const HEVCVPS *vps = (const HEVCVPS*)ps->vps_list[sps->vps_id]->data;
289  unsigned int num = 0, den = 0;
290 
291  avctx->pix_fmt = sps->pix_fmt;
292  avctx->coded_width = sps->width;
293  avctx->coded_height = sps->height;
294  avctx->width = sps->output_width;
295  avctx->height = sps->output_height;
297  avctx->profile = sps->ptl.general_ptl.profile_idc;
298  avctx->level = sps->ptl.general_ptl.level_idc;
299 
300  ff_set_sar(avctx, sps->vui.sar);
301 
305  else
306  avctx->color_range = AVCOL_RANGE_MPEG;
307 
309  avctx->color_primaries = sps->vui.colour_primaries;
310  avctx->color_trc = sps->vui.transfer_characteristic;
311  avctx->colorspace = sps->vui.matrix_coeffs;
312  } else {
316  }
317 
318  if (vps->vps_timing_info_present_flag) {
319  num = vps->vps_num_units_in_tick;
320  den = vps->vps_time_scale;
321  } else if (sps->vui.vui_timing_info_present_flag) {
322  num = sps->vui.vui_num_units_in_tick;
323  den = sps->vui.vui_time_scale;
324  }
325 
326  if (num != 0 && den != 0)
327  av_reduce(&avctx->framerate.den, &avctx->framerate.num,
328  num, den, 1 << 30);
329 }
330 
331 static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
332 {
333  #define HWACCEL_MAX (CONFIG_HEVC_DXVA2_HWACCEL + CONFIG_HEVC_D3D11VA_HWACCEL + CONFIG_HEVC_VAAPI_HWACCEL + CONFIG_HEVC_VDPAU_HWACCEL)
335  int ret, i;
336 
337  pic_arrays_free(s);
338  s->ps.sps = NULL;
339  s->ps.vps = NULL;
340 
341  if (!sps)
342  return 0;
343 
344  ret = pic_arrays_init(s, sps);
345  if (ret < 0)
346  goto fail;
347 
348  export_stream_params(s->avctx, &s->ps, sps);
349 
350  switch (sps->pix_fmt) {
351  case AV_PIX_FMT_YUV420P:
352  case AV_PIX_FMT_YUVJ420P:
353 #if CONFIG_HEVC_DXVA2_HWACCEL
354  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
355 #endif
356 #if CONFIG_HEVC_D3D11VA_HWACCEL
357  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
358 #endif
359 #if CONFIG_HEVC_VAAPI_HWACCEL
360  *fmt++ = AV_PIX_FMT_VAAPI;
361 #endif
362 #if CONFIG_HEVC_VDPAU_HWACCEL
363  *fmt++ = AV_PIX_FMT_VDPAU;
364 #endif
365  break;
367 #if CONFIG_HEVC_DXVA2_HWACCEL
368  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
369 #endif
370 #if CONFIG_HEVC_D3D11VA_HWACCEL
371  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
372 #endif
373  break;
374  }
375 
376  if (pix_fmt == AV_PIX_FMT_NONE) {
377  *fmt++ = sps->pix_fmt;
378  *fmt = AV_PIX_FMT_NONE;
379 
380  ret = ff_thread_get_format(s->avctx, pix_fmts);
381  if (ret < 0)
382  goto fail;
383  s->avctx->pix_fmt = ret;
384  }
385  else {
386  s->avctx->pix_fmt = pix_fmt;
387  }
388 
389  ff_hevc_pred_init(&s->hpc, sps->bit_depth);
390  ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
391  ff_videodsp_init (&s->vdsp, sps->bit_depth);
392 
393  for (i = 0; i < 3; i++) {
396  }
397 
398  if (sps->sao_enabled && !s->avctx->hwaccel) {
399  int c_count = (sps->chroma_format_idc != 0) ? 3 : 1;
400  int c_idx;
401 
402  for(c_idx = 0; c_idx < c_count; c_idx++) {
403  int w = sps->width >> sps->hshift[c_idx];
404  int h = sps->height >> sps->vshift[c_idx];
405  s->sao_pixel_buffer_h[c_idx] =
406  av_malloc((w * 2 * sps->ctb_height) <<
407  sps->pixel_shift);
408  s->sao_pixel_buffer_v[c_idx] =
409  av_malloc((h * 2 * sps->ctb_width) <<
410  sps->pixel_shift);
411  }
412  }
413 
414  s->ps.sps = sps;
415  s->ps.vps = (HEVCVPS*) s->ps.vps_list[s->ps.sps->vps_id]->data;
416 
417  return 0;
418 
419 fail:
420  pic_arrays_free(s);
421  s->ps.sps = NULL;
422  return ret;
423 }
424 
426 {
427  GetBitContext *gb = &s->HEVClc->gb;
428  SliceHeader *sh = &s->sh;
429  int i, ret;
430 
431  // Coded parameters
433  if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
434  s->seq_decode = (s->seq_decode + 1) & 0xff;
435  s->max_ra = INT_MAX;
436  if (IS_IDR(s))
438  }
440  if (IS_IRAP(s))
442 
443  sh->pps_id = get_ue_golomb_long(gb);
444  if (sh->pps_id >= MAX_PPS_COUNT || !s->ps.pps_list[sh->pps_id]) {
445  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
446  return AVERROR_INVALIDDATA;
447  }
448  if (!sh->first_slice_in_pic_flag &&
449  s->ps.pps != (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data) {
450  av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
451  return AVERROR_INVALIDDATA;
452  }
453  s->ps.pps = (HEVCPPS*)s->ps.pps_list[sh->pps_id]->data;
454  if (s->nal_unit_type == NAL_CRA_NUT && s->last_eos == 1)
456 
457  if (s->ps.sps != (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data) {
458  const HEVCSPS* last_sps = s->ps.sps;
459  s->ps.sps = (HEVCSPS*)s->ps.sps_list[s->ps.pps->sps_id]->data;
460  if (last_sps && IS_IRAP(s) && s->nal_unit_type != NAL_CRA_NUT) {
461  if (s->ps.sps->width != last_sps->width || s->ps.sps->height != last_sps->height ||
463  last_sps->temporal_layer[last_sps->max_sub_layers - 1].max_dec_pic_buffering)
465  }
467  ret = set_sps(s, s->ps.sps, AV_PIX_FMT_NONE);
468  if (ret < 0)
469  return ret;
470 
471  s->seq_decode = (s->seq_decode + 1) & 0xff;
472  s->max_ra = INT_MAX;
473  }
474 
476  if (!sh->first_slice_in_pic_flag) {
477  int slice_address_length;
478 
481 
482  slice_address_length = av_ceil_log2(s->ps.sps->ctb_width *
483  s->ps.sps->ctb_height);
484  sh->slice_segment_addr = get_bitsz(gb, slice_address_length);
485  if (sh->slice_segment_addr >= s->ps.sps->ctb_width * s->ps.sps->ctb_height) {
487  "Invalid slice segment address: %u.\n",
488  sh->slice_segment_addr);
489  return AVERROR_INVALIDDATA;
490  }
491 
492  if (!sh->dependent_slice_segment_flag) {
493  sh->slice_addr = sh->slice_segment_addr;
494  s->slice_idx++;
495  }
496  } else {
497  sh->slice_segment_addr = sh->slice_addr = 0;
498  s->slice_idx = 0;
499  s->slice_initialized = 0;
500  }
501 
502  if (!sh->dependent_slice_segment_flag) {
503  s->slice_initialized = 0;
504 
505  for (i = 0; i < s->ps.pps->num_extra_slice_header_bits; i++)
506  skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
507 
508  sh->slice_type = get_ue_golomb_long(gb);
509  if (!(sh->slice_type == I_SLICE ||
510  sh->slice_type == P_SLICE ||
511  sh->slice_type == B_SLICE)) {
512  av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
513  sh->slice_type);
514  return AVERROR_INVALIDDATA;
515  }
516  if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
517  av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
518  return AVERROR_INVALIDDATA;
519  }
520 
521  // when flag is not present, picture is inferred to be output
522  sh->pic_output_flag = 1;
524  sh->pic_output_flag = get_bits1(gb);
525 
527  sh->colour_plane_id = get_bits(gb, 2);
528 
529  if (!IS_IDR(s)) {
530  int poc, pos;
531 
534  if (!sh->first_slice_in_pic_flag && poc != s->poc) {
536  "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
538  return AVERROR_INVALIDDATA;
539  poc = s->poc;
540  }
541  s->poc = poc;
542 
544  pos = get_bits_left(gb);
546  ret = ff_hevc_decode_short_term_rps(gb, s->avctx, &sh->slice_rps, s->ps.sps, 1);
547  if (ret < 0)
548  return ret;
549 
550  sh->short_term_rps = &sh->slice_rps;
551  } else {
552  int numbits, rps_idx;
553 
554  if (!s->ps.sps->nb_st_rps) {
555  av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
556  return AVERROR_INVALIDDATA;
557  }
558 
559  numbits = av_ceil_log2(s->ps.sps->nb_st_rps);
560  rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
561  sh->short_term_rps = &s->ps.sps->st_rps[rps_idx];
562  }
564 
565  pos = get_bits_left(gb);
566  ret = decode_lt_rps(s, &sh->long_term_rps, gb);
567  if (ret < 0) {
568  av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
570  return AVERROR_INVALIDDATA;
571  }
573 
576  else
578  } else {
579  s->sh.short_term_rps = NULL;
580  s->poc = 0;
581  }
582 
583  /* 8.3.1 */
584  if (s->temporal_id == 0 &&
585  s->nal_unit_type != NAL_TRAIL_N &&
586  s->nal_unit_type != NAL_TSA_N &&
587  s->nal_unit_type != NAL_STSA_N &&
588  s->nal_unit_type != NAL_RADL_N &&
589  s->nal_unit_type != NAL_RADL_R &&
590  s->nal_unit_type != NAL_RASL_N &&
592  s->pocTid0 = s->poc;
593 
594  if (s->ps.sps->sao_enabled) {
596  if (s->ps.sps->chroma_format_idc) {
599  }
600  } else {
604  }
605 
606  sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
607  if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
608  int nb_refs;
609 
611  if (sh->slice_type == B_SLICE)
613 
614  if (get_bits1(gb)) { // num_ref_idx_active_override_flag
615  sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
616  if (sh->slice_type == B_SLICE)
617  sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
618  }
619  if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
620  av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
621  sh->nb_refs[L0], sh->nb_refs[L1]);
622  return AVERROR_INVALIDDATA;
623  }
624 
625  sh->rpl_modification_flag[0] = 0;
626  sh->rpl_modification_flag[1] = 0;
627  nb_refs = ff_hevc_frame_nb_refs(s);
628  if (!nb_refs) {
629  av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
630  return AVERROR_INVALIDDATA;
631  }
632 
633  if (s->ps.pps->lists_modification_present_flag && nb_refs > 1) {
634  sh->rpl_modification_flag[0] = get_bits1(gb);
635  if (sh->rpl_modification_flag[0]) {
636  for (i = 0; i < sh->nb_refs[L0]; i++)
637  sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
638  }
639 
640  if (sh->slice_type == B_SLICE) {
641  sh->rpl_modification_flag[1] = get_bits1(gb);
642  if (sh->rpl_modification_flag[1] == 1)
643  for (i = 0; i < sh->nb_refs[L1]; i++)
644  sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
645  }
646  }
647 
648  if (sh->slice_type == B_SLICE)
649  sh->mvd_l1_zero_flag = get_bits1(gb);
650 
652  sh->cabac_init_flag = get_bits1(gb);
653  else
654  sh->cabac_init_flag = 0;
655 
656  sh->collocated_ref_idx = 0;
658  sh->collocated_list = L0;
659  if (sh->slice_type == B_SLICE)
660  sh->collocated_list = !get_bits1(gb);
661 
662  if (sh->nb_refs[sh->collocated_list] > 1) {
664  if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
666  "Invalid collocated_ref_idx: %d.\n",
667  sh->collocated_ref_idx);
668  return AVERROR_INVALIDDATA;
669  }
670  }
671  }
672 
673  if ((s->ps.pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
674  (s->ps.pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
675  pred_weight_table(s, gb);
676  }
677 
679  if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
681  "Invalid number of merging MVP candidates: %d.\n",
682  sh->max_num_merge_cand);
683  return AVERROR_INVALIDDATA;
684  }
685  }
686 
687  sh->slice_qp_delta = get_se_golomb(gb);
688 
692  } else {
693  sh->slice_cb_qp_offset = 0;
694  sh->slice_cr_qp_offset = 0;
695  }
696 
699  else
701 
703  int deblocking_filter_override_flag = 0;
704 
706  deblocking_filter_override_flag = get_bits1(gb);
707 
708  if (deblocking_filter_override_flag) {
711  sh->beta_offset = get_se_golomb(gb) * 2;
712  sh->tc_offset = get_se_golomb(gb) * 2;
713  }
714  } else {
716  sh->beta_offset = s->ps.pps->beta_offset;
717  sh->tc_offset = s->ps.pps->tc_offset;
718  }
719  } else {
721  sh->beta_offset = 0;
722  sh->tc_offset = 0;
723  }
724 
730  } else {
732  }
733  } else if (!s->slice_initialized) {
734  av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
735  return AVERROR_INVALIDDATA;
736  }
737 
738  sh->num_entry_point_offsets = 0;
740  unsigned num_entry_point_offsets = get_ue_golomb_long(gb);
741  // It would be possible to bound this tighter but this here is simpler
742  if (num_entry_point_offsets > get_bits_left(gb)) {
743  av_log(s->avctx, AV_LOG_ERROR, "num_entry_point_offsets %d is invalid\n", num_entry_point_offsets);
744  return AVERROR_INVALIDDATA;
745  }
746 
747  sh->num_entry_point_offsets = num_entry_point_offsets;
748  if (sh->num_entry_point_offsets > 0) {
749  int offset_len = get_ue_golomb_long(gb) + 1;
750 
751  if (offset_len < 1 || offset_len > 32) {
752  sh->num_entry_point_offsets = 0;
753  av_log(s->avctx, AV_LOG_ERROR, "offset_len %d is invalid\n", offset_len);
754  return AVERROR_INVALIDDATA;
755  }
756 
758  av_freep(&sh->offset);
759  av_freep(&sh->size);
760  sh->entry_point_offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(unsigned));
761  sh->offset = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
762  sh->size = av_malloc_array(sh->num_entry_point_offsets, sizeof(int));
763  if (!sh->entry_point_offset || !sh->offset || !sh->size) {
764  sh->num_entry_point_offsets = 0;
765  av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate memory\n");
766  return AVERROR(ENOMEM);
767  }
768  for (i = 0; i < sh->num_entry_point_offsets; i++) {
769  unsigned val = get_bits_long(gb, offset_len);
770  sh->entry_point_offset[i] = val + 1; // +1; // +1 to get the size
771  }
772  if (s->threads_number > 1 && (s->ps.pps->num_tile_rows > 1 || s->ps.pps->num_tile_columns > 1)) {
773  s->enable_parallel_tiles = 0; // TODO: you can enable tiles in parallel here
774  s->threads_number = 1;
775  } else
776  s->enable_parallel_tiles = 0;
777  } else
778  s->enable_parallel_tiles = 0;
779  }
780 
782  unsigned int length = get_ue_golomb_long(gb);
783  if (length*8LL > get_bits_left(gb)) {
784  av_log(s->avctx, AV_LOG_ERROR, "too many slice_header_extension_data_bytes\n");
785  return AVERROR_INVALIDDATA;
786  }
787  for (i = 0; i < length; i++)
788  skip_bits(gb, 8); // slice_header_extension_data_byte
789  }
790 
791  // Inferred parameters
792  sh->slice_qp = 26U + s->ps.pps->pic_init_qp_minus26 + sh->slice_qp_delta;
793  if (sh->slice_qp > 51 ||
794  sh->slice_qp < -s->ps.sps->qp_bd_offset) {
796  "The slice_qp %d is outside the valid range "
797  "[%d, 51].\n",
798  sh->slice_qp,
799  -s->ps.sps->qp_bd_offset);
800  return AVERROR_INVALIDDATA;
801  }
802 
804 
806  av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
807  return AVERROR_INVALIDDATA;
808  }
809 
810  if (get_bits_left(gb) < 0) {
812  "Overread slice header by %d bits\n", -get_bits_left(gb));
813  return AVERROR_INVALIDDATA;
814  }
815 
817 
819  s->HEVClc->qp_y = s->sh.slice_qp;
820 
821  s->slice_initialized = 1;
822  s->HEVClc->tu.cu_qp_offset_cb = 0;
823  s->HEVClc->tu.cu_qp_offset_cr = 0;
824 
825  s->no_rasl_output_flag = IS_IDR(s) || IS_BLA(s) || (s->nal_unit_type == NAL_CRA_NUT && s->last_eos);
826 
827  return 0;
828 }
829 
830 #define CTB(tab, x, y) ((tab)[(y) * s->ps.sps->ctb_width + (x)])
831 
832 #define SET_SAO(elem, value) \
833 do { \
834  if (!sao_merge_up_flag && !sao_merge_left_flag) \
835  sao->elem = value; \
836  else if (sao_merge_left_flag) \
837  sao->elem = CTB(s->sao, rx-1, ry).elem; \
838  else if (sao_merge_up_flag) \
839  sao->elem = CTB(s->sao, rx, ry-1).elem; \
840  else \
841  sao->elem = 0; \
842 } while (0)
843 
844 static void hls_sao_param(HEVCContext *s, int rx, int ry)
845 {
846  HEVCLocalContext *lc = s->HEVClc;
847  int sao_merge_left_flag = 0;
848  int sao_merge_up_flag = 0;
849  SAOParams *sao = &CTB(s->sao, rx, ry);
850  int c_idx, i;
851 
854  if (rx > 0) {
855  if (lc->ctb_left_flag)
856  sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
857  }
858  if (ry > 0 && !sao_merge_left_flag) {
859  if (lc->ctb_up_flag)
860  sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
861  }
862  }
863 
864  for (c_idx = 0; c_idx < (s->ps.sps->chroma_format_idc ? 3 : 1); c_idx++) {
865  int log2_sao_offset_scale = c_idx == 0 ? s->ps.pps->log2_sao_offset_scale_luma :
867 
868  if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
869  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
870  continue;
871  }
872 
873  if (c_idx == 2) {
874  sao->type_idx[2] = sao->type_idx[1];
875  sao->eo_class[2] = sao->eo_class[1];
876  } else {
877  SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
878  }
879 
880  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
881  continue;
882 
883  for (i = 0; i < 4; i++)
884  SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
885 
886  if (sao->type_idx[c_idx] == SAO_BAND) {
887  for (i = 0; i < 4; i++) {
888  if (sao->offset_abs[c_idx][i]) {
889  SET_SAO(offset_sign[c_idx][i],
891  } else {
892  sao->offset_sign[c_idx][i] = 0;
893  }
894  }
895  SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
896  } else if (c_idx != 2) {
897  SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
898  }
899 
900  // Inferred parameters
901  sao->offset_val[c_idx][0] = 0;
902  for (i = 0; i < 4; i++) {
903  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i];
904  if (sao->type_idx[c_idx] == SAO_EDGE) {
905  if (i > 1)
906  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
907  } else if (sao->offset_sign[c_idx][i]) {
908  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
909  }
910  sao->offset_val[c_idx][i + 1] *= 1 << log2_sao_offset_scale;
911  }
912  }
913 }
914 
915 #undef SET_SAO
916 #undef CTB
917 
918 static int hls_cross_component_pred(HEVCContext *s, int idx) {
919  HEVCLocalContext *lc = s->HEVClc;
920  int log2_res_scale_abs_plus1 = ff_hevc_log2_res_scale_abs(s, idx);
921 
922  if (log2_res_scale_abs_plus1 != 0) {
923  int res_scale_sign_flag = ff_hevc_res_scale_sign_flag(s, idx);
924  lc->tu.res_scale_val = (1 << (log2_res_scale_abs_plus1 - 1)) *
925  (1 - 2 * res_scale_sign_flag);
926  } else {
927  lc->tu.res_scale_val = 0;
928  }
929 
930 
931  return 0;
932 }
933 
934 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
935  int xBase, int yBase, int cb_xBase, int cb_yBase,
936  int log2_cb_size, int log2_trafo_size,
937  int blk_idx, int cbf_luma, int *cbf_cb, int *cbf_cr)
938 {
939  HEVCLocalContext *lc = s->HEVClc;
940  const int log2_trafo_size_c = log2_trafo_size - s->ps.sps->hshift[1];
941  int i;
942 
943  if (lc->cu.pred_mode == MODE_INTRA) {
944  int trafo_size = 1 << log2_trafo_size;
945  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
946 
947  s->hpc.intra_pred[log2_trafo_size - 2](s, x0, y0, 0);
948  }
949 
950  if (cbf_luma || cbf_cb[0] || cbf_cr[0] ||
951  (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
952  int scan_idx = SCAN_DIAG;
953  int scan_idx_c = SCAN_DIAG;
954  int cbf_chroma = cbf_cb[0] || cbf_cr[0] ||
955  (s->ps.sps->chroma_format_idc == 2 &&
956  (cbf_cb[1] || cbf_cr[1]));
957 
960  if (lc->tu.cu_qp_delta != 0)
961  if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
962  lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
963  lc->tu.is_cu_qp_delta_coded = 1;
964 
965  if (lc->tu.cu_qp_delta < -(26 + s->ps.sps->qp_bd_offset / 2) ||
966  lc->tu.cu_qp_delta > (25 + s->ps.sps->qp_bd_offset / 2)) {
968  "The cu_qp_delta %d is outside the valid range "
969  "[%d, %d].\n",
970  lc->tu.cu_qp_delta,
971  -(26 + s->ps.sps->qp_bd_offset / 2),
972  (25 + s->ps.sps->qp_bd_offset / 2));
973  return AVERROR_INVALIDDATA;
974  }
975 
976  ff_hevc_set_qPy(s, cb_xBase, cb_yBase, log2_cb_size);
977  }
978 
979  if (s->sh.cu_chroma_qp_offset_enabled_flag && cbf_chroma &&
981  int cu_chroma_qp_offset_flag = ff_hevc_cu_chroma_qp_offset_flag(s);
982  if (cu_chroma_qp_offset_flag) {
983  int cu_chroma_qp_offset_idx = 0;
985  cu_chroma_qp_offset_idx = ff_hevc_cu_chroma_qp_offset_idx(s);
987  "cu_chroma_qp_offset_idx not yet tested.\n");
988  }
989  lc->tu.cu_qp_offset_cb = s->ps.pps->cb_qp_offset_list[cu_chroma_qp_offset_idx];
990  lc->tu.cu_qp_offset_cr = s->ps.pps->cr_qp_offset_list[cu_chroma_qp_offset_idx];
991  } else {
992  lc->tu.cu_qp_offset_cb = 0;
993  lc->tu.cu_qp_offset_cr = 0;
994  }
996  }
997 
998  if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
999  if (lc->tu.intra_pred_mode >= 6 &&
1000  lc->tu.intra_pred_mode <= 14) {
1001  scan_idx = SCAN_VERT;
1002  } else if (lc->tu.intra_pred_mode >= 22 &&
1003  lc->tu.intra_pred_mode <= 30) {
1004  scan_idx = SCAN_HORIZ;
1005  }
1006 
1007  if (lc->tu.intra_pred_mode_c >= 6 &&
1008  lc->tu.intra_pred_mode_c <= 14) {
1009  scan_idx_c = SCAN_VERT;
1010  } else if (lc->tu.intra_pred_mode_c >= 22 &&
1011  lc->tu.intra_pred_mode_c <= 30) {
1012  scan_idx_c = SCAN_HORIZ;
1013  }
1014  }
1015 
1016  lc->tu.cross_pf = 0;
1017 
1018  if (cbf_luma)
1019  ff_hevc_hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1020  if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1021  int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1022  int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1023  lc->tu.cross_pf = (s->ps.pps->cross_component_prediction_enabled_flag && cbf_luma &&
1024  (lc->cu.pred_mode == MODE_INTER ||
1025  (lc->tu.chroma_mode_c == 4)));
1026 
1027  if (lc->tu.cross_pf) {
1029  }
1030  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1031  if (lc->cu.pred_mode == MODE_INTRA) {
1032  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1033  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 1);
1034  }
1035  if (cbf_cb[i])
1036  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1037  log2_trafo_size_c, scan_idx_c, 1);
1038  else
1039  if (lc->tu.cross_pf) {
1040  ptrdiff_t stride = s->frame->linesize[1];
1041  int hshift = s->ps.sps->hshift[1];
1042  int vshift = s->ps.sps->vshift[1];
1043  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1044  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1045  int size = 1 << log2_trafo_size_c;
1046 
1047  uint8_t *dst = &s->frame->data[1][(y0 >> vshift) * stride +
1048  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1049  for (i = 0; i < (size * size); i++) {
1050  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1051  }
1052  s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1053  }
1054  }
1055 
1056  if (lc->tu.cross_pf) {
1058  }
1059  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1060  if (lc->cu.pred_mode == MODE_INTRA) {
1061  ff_hevc_set_neighbour_available(s, x0, y0 + (i << log2_trafo_size_c), trafo_size_h, trafo_size_v);
1062  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (i << log2_trafo_size_c), 2);
1063  }
1064  if (cbf_cr[i])
1065  ff_hevc_hls_residual_coding(s, x0, y0 + (i << log2_trafo_size_c),
1066  log2_trafo_size_c, scan_idx_c, 2);
1067  else
1068  if (lc->tu.cross_pf) {
1069  ptrdiff_t stride = s->frame->linesize[2];
1070  int hshift = s->ps.sps->hshift[2];
1071  int vshift = s->ps.sps->vshift[2];
1072  int16_t *coeffs_y = (int16_t*)lc->edge_emu_buffer;
1073  int16_t *coeffs = (int16_t*)lc->edge_emu_buffer2;
1074  int size = 1 << log2_trafo_size_c;
1075 
1076  uint8_t *dst = &s->frame->data[2][(y0 >> vshift) * stride +
1077  ((x0 >> hshift) << s->ps.sps->pixel_shift)];
1078  for (i = 0; i < (size * size); i++) {
1079  coeffs[i] = ((lc->tu.res_scale_val * coeffs_y[i]) >> 3);
1080  }
1081  s->hevcdsp.transform_add[log2_trafo_size_c-2](dst, coeffs, stride);
1082  }
1083  }
1084  } else if (s->ps.sps->chroma_format_idc && blk_idx == 3) {
1085  int trafo_size_h = 1 << (log2_trafo_size + 1);
1086  int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1087  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1088  if (lc->cu.pred_mode == MODE_INTRA) {
1089  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1090  trafo_size_h, trafo_size_v);
1091  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 1);
1092  }
1093  if (cbf_cb[i])
1094  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1095  log2_trafo_size, scan_idx_c, 1);
1096  }
1097  for (i = 0; i < (s->ps.sps->chroma_format_idc == 2 ? 2 : 1); i++) {
1098  if (lc->cu.pred_mode == MODE_INTRA) {
1099  ff_hevc_set_neighbour_available(s, xBase, yBase + (i << log2_trafo_size),
1100  trafo_size_h, trafo_size_v);
1101  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (i << log2_trafo_size), 2);
1102  }
1103  if (cbf_cr[i])
1104  ff_hevc_hls_residual_coding(s, xBase, yBase + (i << log2_trafo_size),
1105  log2_trafo_size, scan_idx_c, 2);
1106  }
1107  }
1108  } else if (s->ps.sps->chroma_format_idc && lc->cu.pred_mode == MODE_INTRA) {
1109  if (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3) {
1110  int trafo_size_h = 1 << (log2_trafo_size_c + s->ps.sps->hshift[1]);
1111  int trafo_size_v = 1 << (log2_trafo_size_c + s->ps.sps->vshift[1]);
1112  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size_h, trafo_size_v);
1113  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 1);
1114  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0, 2);
1115  if (s->ps.sps->chroma_format_idc == 2) {
1116  ff_hevc_set_neighbour_available(s, x0, y0 + (1 << log2_trafo_size_c),
1117  trafo_size_h, trafo_size_v);
1118  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 1);
1119  s->hpc.intra_pred[log2_trafo_size_c - 2](s, x0, y0 + (1 << log2_trafo_size_c), 2);
1120  }
1121  } else if (blk_idx == 3) {
1122  int trafo_size_h = 1 << (log2_trafo_size + 1);
1123  int trafo_size_v = 1 << (log2_trafo_size + s->ps.sps->vshift[1]);
1124  ff_hevc_set_neighbour_available(s, xBase, yBase,
1125  trafo_size_h, trafo_size_v);
1126  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 1);
1127  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase, 2);
1128  if (s->ps.sps->chroma_format_idc == 2) {
1129  ff_hevc_set_neighbour_available(s, xBase, yBase + (1 << (log2_trafo_size)),
1130  trafo_size_h, trafo_size_v);
1131  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 1);
1132  s->hpc.intra_pred[log2_trafo_size - 2](s, xBase, yBase + (1 << (log2_trafo_size)), 2);
1133  }
1134  }
1135  }
1136 
1137  return 0;
1138 }
1139 
1140 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1141 {
1142  int cb_size = 1 << log2_cb_size;
1143  int log2_min_pu_size = s->ps.sps->log2_min_pu_size;
1144 
1145  int min_pu_width = s->ps.sps->min_pu_width;
1146  int x_end = FFMIN(x0 + cb_size, s->ps.sps->width);
1147  int y_end = FFMIN(y0 + cb_size, s->ps.sps->height);
1148  int i, j;
1149 
1150  for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1151  for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1152  s->is_pcm[i + j * min_pu_width] = 2;
1153 }
1154 
1155 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1156  int xBase, int yBase, int cb_xBase, int cb_yBase,
1157  int log2_cb_size, int log2_trafo_size,
1158  int trafo_depth, int blk_idx,
1159  const int *base_cbf_cb, const int *base_cbf_cr)
1160 {
1161  HEVCLocalContext *lc = s->HEVClc;
1162  uint8_t split_transform_flag;
1163  int cbf_cb[2];
1164  int cbf_cr[2];
1165  int ret;
1166 
1167  cbf_cb[0] = base_cbf_cb[0];
1168  cbf_cb[1] = base_cbf_cb[1];
1169  cbf_cr[0] = base_cbf_cr[0];
1170  cbf_cr[1] = base_cbf_cr[1];
1171 
1172  if (lc->cu.intra_split_flag) {
1173  if (trafo_depth == 1) {
1174  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1175  if (s->ps.sps->chroma_format_idc == 3) {
1176  lc->tu.intra_pred_mode_c = lc->pu.intra_pred_mode_c[blk_idx];
1177  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[blk_idx];
1178  } else {
1180  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1181  }
1182  }
1183  } else {
1184  lc->tu.intra_pred_mode = lc->pu.intra_pred_mode[0];
1186  lc->tu.chroma_mode_c = lc->pu.chroma_mode_c[0];
1187  }
1188 
1189  if (log2_trafo_size <= s->ps.sps->log2_max_trafo_size &&
1190  log2_trafo_size > s->ps.sps->log2_min_tb_size &&
1191  trafo_depth < lc->cu.max_trafo_depth &&
1192  !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1193  split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1194  } else {
1195  int inter_split = s->ps.sps->max_transform_hierarchy_depth_inter == 0 &&
1196  lc->cu.pred_mode == MODE_INTER &&
1197  lc->cu.part_mode != PART_2Nx2N &&
1198  trafo_depth == 0;
1199 
1200  split_transform_flag = log2_trafo_size > s->ps.sps->log2_max_trafo_size ||
1201  (lc->cu.intra_split_flag && trafo_depth == 0) ||
1202  inter_split;
1203  }
1204 
1205  if (s->ps.sps->chroma_format_idc && (log2_trafo_size > 2 || s->ps.sps->chroma_format_idc == 3)) {
1206  if (trafo_depth == 0 || cbf_cb[0]) {
1207  cbf_cb[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1208  if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1209  cbf_cb[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1210  }
1211  }
1212 
1213  if (trafo_depth == 0 || cbf_cr[0]) {
1214  cbf_cr[0] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1215  if (s->ps.sps->chroma_format_idc == 2 && (!split_transform_flag || log2_trafo_size == 3)) {
1216  cbf_cr[1] = ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1217  }
1218  }
1219  }
1220 
1221  if (split_transform_flag) {
1222  const int trafo_size_split = 1 << (log2_trafo_size - 1);
1223  const int x1 = x0 + trafo_size_split;
1224  const int y1 = y0 + trafo_size_split;
1225 
1226 #define SUBDIVIDE(x, y, idx) \
1227 do { \
1228  ret = hls_transform_tree(s, x, y, x0, y0, cb_xBase, cb_yBase, log2_cb_size, \
1229  log2_trafo_size - 1, trafo_depth + 1, idx, \
1230  cbf_cb, cbf_cr); \
1231  if (ret < 0) \
1232  return ret; \
1233 } while (0)
1234 
1235  SUBDIVIDE(x0, y0, 0);
1236  SUBDIVIDE(x1, y0, 1);
1237  SUBDIVIDE(x0, y1, 2);
1238  SUBDIVIDE(x1, y1, 3);
1239 
1240 #undef SUBDIVIDE
1241  } else {
1242  int min_tu_size = 1 << s->ps.sps->log2_min_tb_size;
1243  int log2_min_tu_size = s->ps.sps->log2_min_tb_size;
1244  int min_tu_width = s->ps.sps->min_tb_width;
1245  int cbf_luma = 1;
1246 
1247  if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1248  cbf_cb[0] || cbf_cr[0] ||
1249  (s->ps.sps->chroma_format_idc == 2 && (cbf_cb[1] || cbf_cr[1]))) {
1250  cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1251  }
1252 
1253  ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1254  log2_cb_size, log2_trafo_size,
1255  blk_idx, cbf_luma, cbf_cb, cbf_cr);
1256  if (ret < 0)
1257  return ret;
1258  // TODO: store cbf_luma somewhere else
1259  if (cbf_luma) {
1260  int i, j;
1261  for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1262  for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1263  int x_tu = (x0 + j) >> log2_min_tu_size;
1264  int y_tu = (y0 + i) >> log2_min_tu_size;
1265  s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1266  }
1267  }
1269  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size);
1272  set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1273  }
1274  }
1275  return 0;
1276 }
1277 
1278 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1279 {
1280  HEVCLocalContext *lc = s->HEVClc;
1281  GetBitContext gb;
1282  int cb_size = 1 << log2_cb_size;
1283  int stride0 = s->frame->linesize[0];
1284  uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->ps.sps->pixel_shift)];
1285  int stride1 = s->frame->linesize[1];
1286  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)];
1287  int stride2 = s->frame->linesize[2];
1288  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)];
1289 
1290  int length = cb_size * cb_size * s->ps.sps->pcm.bit_depth +
1291  (((cb_size >> s->ps.sps->hshift[1]) * (cb_size >> s->ps.sps->vshift[1])) +
1292  ((cb_size >> s->ps.sps->hshift[2]) * (cb_size >> s->ps.sps->vshift[2]))) *
1293  s->ps.sps->pcm.bit_depth_chroma;
1294  const uint8_t *pcm = skip_bytes(&lc->cc, (length + 7) >> 3);
1295  int ret;
1296 
1298  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
1299 
1300  ret = init_get_bits(&gb, pcm, length);
1301  if (ret < 0)
1302  return ret;
1303 
1304  s->hevcdsp.put_pcm(dst0, stride0, cb_size, cb_size, &gb, s->ps.sps->pcm.bit_depth);
1305  if (s->ps.sps->chroma_format_idc) {
1306  s->hevcdsp.put_pcm(dst1, stride1,
1307  cb_size >> s->ps.sps->hshift[1],
1308  cb_size >> s->ps.sps->vshift[1],
1309  &gb, s->ps.sps->pcm.bit_depth_chroma);
1310  s->hevcdsp.put_pcm(dst2, stride2,
1311  cb_size >> s->ps.sps->hshift[2],
1312  cb_size >> s->ps.sps->vshift[2],
1313  &gb, s->ps.sps->pcm.bit_depth_chroma);
1314  }
1315 
1316  return 0;
1317 }
1318 
1319 /**
1320  * 8.5.3.2.2.1 Luma sample unidirectional interpolation process
1321  *
1322  * @param s HEVC decoding context
1323  * @param dst target buffer for block data at block position
1324  * @param dststride stride of the dst buffer
1325  * @param ref reference picture buffer at origin (0, 0)
1326  * @param mv motion vector (relative to block position) to get pixel data from
1327  * @param x_off horizontal position of block from origin (0, 0)
1328  * @param y_off vertical position of block from origin (0, 0)
1329  * @param block_w width of block
1330  * @param block_h height of block
1331  * @param luma_weight weighting factor applied to the luma prediction
1332  * @param luma_offset additive offset applied to the luma prediction value
1333  */
1334 
1335 static void luma_mc_uni(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1336  AVFrame *ref, const Mv *mv, int x_off, int y_off,
1337  int block_w, int block_h, int luma_weight, int luma_offset)
1338 {
1339  HEVCLocalContext *lc = s->HEVClc;
1340  uint8_t *src = ref->data[0];
1341  ptrdiff_t srcstride = ref->linesize[0];
1342  int pic_width = s->ps.sps->width;
1343  int pic_height = s->ps.sps->height;
1344  int mx = mv->x & 3;
1345  int my = mv->y & 3;
1346  int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1348  int idx = ff_hevc_pel_weight[block_w];
1349 
1350  x_off += mv->x >> 2;
1351  y_off += mv->y >> 2;
1352  src += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1353 
1354  if (x_off < QPEL_EXTRA_BEFORE || y_off < QPEL_EXTRA_AFTER ||
1355  x_off >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1356  y_off >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1357  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1358  int offset = QPEL_EXTRA_BEFORE * srcstride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1359  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1360 
1361  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1362  edge_emu_stride, srcstride,
1363  block_w + QPEL_EXTRA,
1364  block_h + QPEL_EXTRA,
1365  x_off - QPEL_EXTRA_BEFORE, y_off - QPEL_EXTRA_BEFORE,
1366  pic_width, pic_height);
1367  src = lc->edge_emu_buffer + buf_offset;
1368  srcstride = edge_emu_stride;
1369  }
1370 
1371  if (!weight_flag)
1372  s->hevcdsp.put_hevc_qpel_uni[idx][!!my][!!mx](dst, dststride, src, srcstride,
1373  block_h, mx, my, block_w);
1374  else
1375  s->hevcdsp.put_hevc_qpel_uni_w[idx][!!my][!!mx](dst, dststride, src, srcstride,
1376  block_h, s->sh.luma_log2_weight_denom,
1377  luma_weight, luma_offset, mx, my, block_w);
1378 }
1379 
1380 /**
1381  * 8.5.3.2.2.1 Luma sample bidirectional interpolation process
1382  *
1383  * @param s HEVC decoding context
1384  * @param dst target buffer for block data at block position
1385  * @param dststride stride of the dst buffer
1386  * @param ref0 reference picture0 buffer at origin (0, 0)
1387  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1388  * @param x_off horizontal position of block from origin (0, 0)
1389  * @param y_off vertical position of block from origin (0, 0)
1390  * @param block_w width of block
1391  * @param block_h height of block
1392  * @param ref1 reference picture1 buffer at origin (0, 0)
1393  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1394  * @param current_mv current motion vector structure
1395  */
1396  static void luma_mc_bi(HEVCContext *s, uint8_t *dst, ptrdiff_t dststride,
1397  AVFrame *ref0, const Mv *mv0, int x_off, int y_off,
1398  int block_w, int block_h, AVFrame *ref1, const Mv *mv1, struct MvField *current_mv)
1399 {
1400  HEVCLocalContext *lc = s->HEVClc;
1401  ptrdiff_t src0stride = ref0->linesize[0];
1402  ptrdiff_t src1stride = ref1->linesize[0];
1403  int pic_width = s->ps.sps->width;
1404  int pic_height = s->ps.sps->height;
1405  int mx0 = mv0->x & 3;
1406  int my0 = mv0->y & 3;
1407  int mx1 = mv1->x & 3;
1408  int my1 = mv1->y & 3;
1409  int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1411  int x_off0 = x_off + (mv0->x >> 2);
1412  int y_off0 = y_off + (mv0->y >> 2);
1413  int x_off1 = x_off + (mv1->x >> 2);
1414  int y_off1 = y_off + (mv1->y >> 2);
1415  int idx = ff_hevc_pel_weight[block_w];
1416 
1417  uint8_t *src0 = ref0->data[0] + y_off0 * src0stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1418  uint8_t *src1 = ref1->data[0] + y_off1 * src1stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1419 
1420  if (x_off0 < QPEL_EXTRA_BEFORE || y_off0 < QPEL_EXTRA_AFTER ||
1421  x_off0 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1422  y_off0 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1423  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1424  int offset = QPEL_EXTRA_BEFORE * src0stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1425  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1426 
1427  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset,
1428  edge_emu_stride, src0stride,
1429  block_w + QPEL_EXTRA,
1430  block_h + QPEL_EXTRA,
1431  x_off0 - QPEL_EXTRA_BEFORE, y_off0 - QPEL_EXTRA_BEFORE,
1432  pic_width, pic_height);
1433  src0 = lc->edge_emu_buffer + buf_offset;
1434  src0stride = edge_emu_stride;
1435  }
1436 
1437  if (x_off1 < QPEL_EXTRA_BEFORE || y_off1 < QPEL_EXTRA_AFTER ||
1438  x_off1 >= pic_width - block_w - QPEL_EXTRA_AFTER ||
1439  y_off1 >= pic_height - block_h - QPEL_EXTRA_AFTER) {
1440  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1441  int offset = QPEL_EXTRA_BEFORE * src1stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1442  int buf_offset = QPEL_EXTRA_BEFORE * edge_emu_stride + (QPEL_EXTRA_BEFORE << s->ps.sps->pixel_shift);
1443 
1444  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src1 - offset,
1445  edge_emu_stride, src1stride,
1446  block_w + QPEL_EXTRA,
1447  block_h + QPEL_EXTRA,
1448  x_off1 - QPEL_EXTRA_BEFORE, y_off1 - QPEL_EXTRA_BEFORE,
1449  pic_width, pic_height);
1450  src1 = lc->edge_emu_buffer2 + buf_offset;
1451  src1stride = edge_emu_stride;
1452  }
1453 
1454  s->hevcdsp.put_hevc_qpel[idx][!!my0][!!mx0](lc->tmp, src0, src0stride,
1455  block_h, mx0, my0, block_w);
1456  if (!weight_flag)
1457  s->hevcdsp.put_hevc_qpel_bi[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1458  block_h, mx1, my1, block_w);
1459  else
1460  s->hevcdsp.put_hevc_qpel_bi_w[idx][!!my1][!!mx1](dst, dststride, src1, src1stride, lc->tmp,
1461  block_h, s->sh.luma_log2_weight_denom,
1462  s->sh.luma_weight_l0[current_mv->ref_idx[0]],
1463  s->sh.luma_weight_l1[current_mv->ref_idx[1]],
1464  s->sh.luma_offset_l0[current_mv->ref_idx[0]],
1465  s->sh.luma_offset_l1[current_mv->ref_idx[1]],
1466  mx1, my1, block_w);
1467 
1468 }
1469 
1470 /**
1471  * 8.5.3.2.2.2 Chroma sample uniprediction interpolation process
1472  *
1473  * @param s HEVC decoding context
1474  * @param dst1 target buffer for block data at block position (U plane)
1475  * @param dst2 target buffer for block data at block position (V plane)
1476  * @param dststride stride of the dst1 and dst2 buffers
1477  * @param ref reference picture buffer at origin (0, 0)
1478  * @param mv motion vector (relative to block position) to get pixel data from
1479  * @param x_off horizontal position of block from origin (0, 0)
1480  * @param y_off vertical position of block from origin (0, 0)
1481  * @param block_w width of block
1482  * @param block_h height of block
1483  * @param chroma_weight weighting factor applied to the chroma prediction
1484  * @param chroma_offset additive offset applied to the chroma prediction value
1485  */
1486 
1487 static void chroma_mc_uni(HEVCContext *s, uint8_t *dst0,
1488  ptrdiff_t dststride, uint8_t *src0, ptrdiff_t srcstride, int reflist,
1489  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int chroma_weight, int chroma_offset)
1490 {
1491  HEVCLocalContext *lc = s->HEVClc;
1492  int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1493  int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1494  const Mv *mv = &current_mv->mv[reflist];
1495  int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1497  int idx = ff_hevc_pel_weight[block_w];
1498  int hshift = s->ps.sps->hshift[1];
1499  int vshift = s->ps.sps->vshift[1];
1500  intptr_t mx = av_mod_uintp2(mv->x, 2 + hshift);
1501  intptr_t my = av_mod_uintp2(mv->y, 2 + vshift);
1502  intptr_t _mx = mx << (1 - hshift);
1503  intptr_t _my = my << (1 - vshift);
1504 
1505  x_off += mv->x >> (2 + hshift);
1506  y_off += mv->y >> (2 + vshift);
1507  src0 += y_off * srcstride + (x_off * (1 << s->ps.sps->pixel_shift));
1508 
1509  if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1510  x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1511  y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1512  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1513  int offset0 = EPEL_EXTRA_BEFORE * (srcstride + (1 << s->ps.sps->pixel_shift));
1514  int buf_offset0 = EPEL_EXTRA_BEFORE *
1515  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1516  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src0 - offset0,
1517  edge_emu_stride, srcstride,
1518  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1519  x_off - EPEL_EXTRA_BEFORE,
1520  y_off - EPEL_EXTRA_BEFORE,
1521  pic_width, pic_height);
1522 
1523  src0 = lc->edge_emu_buffer + buf_offset0;
1524  srcstride = edge_emu_stride;
1525  }
1526  if (!weight_flag)
1527  s->hevcdsp.put_hevc_epel_uni[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1528  block_h, _mx, _my, block_w);
1529  else
1530  s->hevcdsp.put_hevc_epel_uni_w[idx][!!my][!!mx](dst0, dststride, src0, srcstride,
1531  block_h, s->sh.chroma_log2_weight_denom,
1532  chroma_weight, chroma_offset, _mx, _my, block_w);
1533 }
1534 
1535 /**
1536  * 8.5.3.2.2.2 Chroma sample bidirectional interpolation process
1537  *
1538  * @param s HEVC decoding context
1539  * @param dst target buffer for block data at block position
1540  * @param dststride stride of the dst buffer
1541  * @param ref0 reference picture0 buffer at origin (0, 0)
1542  * @param mv0 motion vector0 (relative to block position) to get pixel data from
1543  * @param x_off horizontal position of block from origin (0, 0)
1544  * @param y_off vertical position of block from origin (0, 0)
1545  * @param block_w width of block
1546  * @param block_h height of block
1547  * @param ref1 reference picture1 buffer at origin (0, 0)
1548  * @param mv1 motion vector1 (relative to block position) to get pixel data from
1549  * @param current_mv current motion vector structure
1550  * @param cidx chroma component(cb, cr)
1551  */
1552 static void chroma_mc_bi(HEVCContext *s, uint8_t *dst0, ptrdiff_t dststride, AVFrame *ref0, AVFrame *ref1,
1553  int x_off, int y_off, int block_w, int block_h, struct MvField *current_mv, int cidx)
1554 {
1555  HEVCLocalContext *lc = s->HEVClc;
1556  uint8_t *src1 = ref0->data[cidx+1];
1557  uint8_t *src2 = ref1->data[cidx+1];
1558  ptrdiff_t src1stride = ref0->linesize[cidx+1];
1559  ptrdiff_t src2stride = ref1->linesize[cidx+1];
1560  int weight_flag = (s->sh.slice_type == P_SLICE && s->ps.pps->weighted_pred_flag) ||
1562  int pic_width = s->ps.sps->width >> s->ps.sps->hshift[1];
1563  int pic_height = s->ps.sps->height >> s->ps.sps->vshift[1];
1564  Mv *mv0 = &current_mv->mv[0];
1565  Mv *mv1 = &current_mv->mv[1];
1566  int hshift = s->ps.sps->hshift[1];
1567  int vshift = s->ps.sps->vshift[1];
1568 
1569  intptr_t mx0 = av_mod_uintp2(mv0->x, 2 + hshift);
1570  intptr_t my0 = av_mod_uintp2(mv0->y, 2 + vshift);
1571  intptr_t mx1 = av_mod_uintp2(mv1->x, 2 + hshift);
1572  intptr_t my1 = av_mod_uintp2(mv1->y, 2 + vshift);
1573  intptr_t _mx0 = mx0 << (1 - hshift);
1574  intptr_t _my0 = my0 << (1 - vshift);
1575  intptr_t _mx1 = mx1 << (1 - hshift);
1576  intptr_t _my1 = my1 << (1 - vshift);
1577 
1578  int x_off0 = x_off + (mv0->x >> (2 + hshift));
1579  int y_off0 = y_off + (mv0->y >> (2 + vshift));
1580  int x_off1 = x_off + (mv1->x >> (2 + hshift));
1581  int y_off1 = y_off + (mv1->y >> (2 + vshift));
1582  int idx = ff_hevc_pel_weight[block_w];
1583  src1 += y_off0 * src1stride + (int)((unsigned)x_off0 << s->ps.sps->pixel_shift);
1584  src2 += y_off1 * src2stride + (int)((unsigned)x_off1 << s->ps.sps->pixel_shift);
1585 
1586  if (x_off0 < EPEL_EXTRA_BEFORE || y_off0 < EPEL_EXTRA_AFTER ||
1587  x_off0 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1588  y_off0 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1589  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1590  int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->ps.sps->pixel_shift));
1591  int buf_offset1 = EPEL_EXTRA_BEFORE *
1592  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1593 
1594  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1595  edge_emu_stride, src1stride,
1596  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1597  x_off0 - EPEL_EXTRA_BEFORE,
1598  y_off0 - EPEL_EXTRA_BEFORE,
1599  pic_width, pic_height);
1600 
1601  src1 = lc->edge_emu_buffer + buf_offset1;
1602  src1stride = edge_emu_stride;
1603  }
1604 
1605  if (x_off1 < EPEL_EXTRA_BEFORE || y_off1 < EPEL_EXTRA_AFTER ||
1606  x_off1 >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1607  y_off1 >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1608  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->ps.sps->pixel_shift;
1609  int offset1 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->ps.sps->pixel_shift));
1610  int buf_offset1 = EPEL_EXTRA_BEFORE *
1611  (edge_emu_stride + (1 << s->ps.sps->pixel_shift));
1612 
1613  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer2, src2 - offset1,
1614  edge_emu_stride, src2stride,
1615  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1616  x_off1 - EPEL_EXTRA_BEFORE,
1617  y_off1 - EPEL_EXTRA_BEFORE,
1618  pic_width, pic_height);
1619 
1620  src2 = lc->edge_emu_buffer2 + buf_offset1;
1621  src2stride = edge_emu_stride;
1622  }
1623 
1624  s->hevcdsp.put_hevc_epel[idx][!!my0][!!mx0](lc->tmp, src1, src1stride,
1625  block_h, _mx0, _my0, block_w);
1626  if (!weight_flag)
1627  s->hevcdsp.put_hevc_epel_bi[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1628  src2, src2stride, lc->tmp,
1629  block_h, _mx1, _my1, block_w);
1630  else
1631  s->hevcdsp.put_hevc_epel_bi_w[idx][!!my1][!!mx1](dst0, s->frame->linesize[cidx+1],
1632  src2, src2stride, lc->tmp,
1633  block_h,
1635  s->sh.chroma_weight_l0[current_mv->ref_idx[0]][cidx],
1636  s->sh.chroma_weight_l1[current_mv->ref_idx[1]][cidx],
1637  s->sh.chroma_offset_l0[current_mv->ref_idx[0]][cidx],
1638  s->sh.chroma_offset_l1[current_mv->ref_idx[1]][cidx],
1639  _mx1, _my1, block_w);
1640 }
1641 
1643  const Mv *mv, int y0, int height)
1644 {
1645  int y = FFMAX(0, (mv->y >> 2) + y0 + height + 9);
1646 
1647  if (s->threads_type == FF_THREAD_FRAME )
1648  ff_thread_await_progress(&ref->tf, y, 0);
1649 }
1650 
1651 static void hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW,
1652  int nPbH, int log2_cb_size, int part_idx,
1653  int merge_idx, MvField *mv)
1654 {
1655  HEVCLocalContext *lc = s->HEVClc;
1656  enum InterPredIdc inter_pred_idc = PRED_L0;
1657  int mvp_flag;
1658 
1659  ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1660  mv->pred_flag = 0;
1661  if (s->sh.slice_type == B_SLICE)
1662  inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1663 
1664  if (inter_pred_idc != PRED_L1) {
1665  if (s->sh.nb_refs[L0])
1666  mv->ref_idx[0]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1667 
1668  mv->pred_flag = PF_L0;
1669  ff_hevc_hls_mvd_coding(s, x0, y0, 0);
1670  mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1671  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1672  part_idx, merge_idx, mv, mvp_flag, 0);
1673  mv->mv[0].x += lc->pu.mvd.x;
1674  mv->mv[0].y += lc->pu.mvd.y;
1675  }
1676 
1677  if (inter_pred_idc != PRED_L0) {
1678  if (s->sh.nb_refs[L1])
1679  mv->ref_idx[1]= ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1680 
1681  if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1682  AV_ZERO32(&lc->pu.mvd);
1683  } else {
1684  ff_hevc_hls_mvd_coding(s, x0, y0, 1);
1685  }
1686 
1687  mv->pred_flag += PF_L1;
1688  mvp_flag = ff_hevc_mvp_lx_flag_decode(s);
1689  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1690  part_idx, merge_idx, mv, mvp_flag, 1);
1691  mv->mv[1].x += lc->pu.mvd.x;
1692  mv->mv[1].y += lc->pu.mvd.y;
1693  }
1694 }
1695 
1696 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1697  int nPbW, int nPbH,
1698  int log2_cb_size, int partIdx, int idx)
1699 {
1700 #define POS(c_idx, x, y) \
1701  &s->frame->data[c_idx][((y) >> s->ps.sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1702  (((x) >> s->ps.sps->hshift[c_idx]) << s->ps.sps->pixel_shift)]
1703  HEVCLocalContext *lc = s->HEVClc;
1704  int merge_idx = 0;
1705  struct MvField current_mv = {{{ 0 }}};
1706 
1707  int min_pu_width = s->ps.sps->min_pu_width;
1708 
1709  MvField *tab_mvf = s->ref->tab_mvf;
1710  RefPicList *refPicList = s->ref->refPicList;
1711  HEVCFrame *ref0 = NULL, *ref1 = NULL;
1712  uint8_t *dst0 = POS(0, x0, y0);
1713  uint8_t *dst1 = POS(1, x0, y0);
1714  uint8_t *dst2 = POS(2, x0, y0);
1715  int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
1716  int min_cb_width = s->ps.sps->min_cb_width;
1717  int x_cb = x0 >> log2_min_cb_size;
1718  int y_cb = y0 >> log2_min_cb_size;
1719  int x_pu, y_pu;
1720  int i, j;
1721 
1722  int skip_flag = SAMPLE_CTB(s->skip_flag, x_cb, y_cb);
1723 
1724  if (!skip_flag)
1726 
1727  if (skip_flag || lc->pu.merge_flag) {
1728  if (s->sh.max_num_merge_cand > 1)
1729  merge_idx = ff_hevc_merge_idx_decode(s);
1730  else
1731  merge_idx = 0;
1732 
1733  ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1734  partIdx, merge_idx, &current_mv);
1735  } else {
1736  hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1737  partIdx, merge_idx, &current_mv);
1738  }
1739 
1740  x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1741  y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1742 
1743  for (j = 0; j < nPbH >> s->ps.sps->log2_min_pu_size; j++)
1744  for (i = 0; i < nPbW >> s->ps.sps->log2_min_pu_size; i++)
1745  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1746 
1747  if (current_mv.pred_flag & PF_L0) {
1748  ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1749  if (!ref0)
1750  return;
1751  hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1752  }
1753  if (current_mv.pred_flag & PF_L1) {
1754  ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1755  if (!ref1)
1756  return;
1757  hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1758  }
1759 
1760  if (current_mv.pred_flag == PF_L0) {
1761  int x0_c = x0 >> s->ps.sps->hshift[1];
1762  int y0_c = y0 >> s->ps.sps->vshift[1];
1763  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1764  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1765 
1766  luma_mc_uni(s, dst0, s->frame->linesize[0], ref0->frame,
1767  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1768  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1769  s->sh.luma_offset_l0[current_mv.ref_idx[0]]);
1770 
1771  if (s->ps.sps->chroma_format_idc) {
1772  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref0->frame->data[1], ref0->frame->linesize[1],
1773  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1774  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0]);
1775  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref0->frame->data[2], ref0->frame->linesize[2],
1776  0, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1777  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1], s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1]);
1778  }
1779  } else if (current_mv.pred_flag == PF_L1) {
1780  int x0_c = x0 >> s->ps.sps->hshift[1];
1781  int y0_c = y0 >> s->ps.sps->vshift[1];
1782  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1783  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1784 
1785  luma_mc_uni(s, dst0, s->frame->linesize[0], ref1->frame,
1786  &current_mv.mv[1], x0, y0, nPbW, nPbH,
1787  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1788  s->sh.luma_offset_l1[current_mv.ref_idx[1]]);
1789 
1790  if (s->ps.sps->chroma_format_idc) {
1791  chroma_mc_uni(s, dst1, s->frame->linesize[1], ref1->frame->data[1], ref1->frame->linesize[1],
1792  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1793  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0]);
1794 
1795  chroma_mc_uni(s, dst2, s->frame->linesize[2], ref1->frame->data[2], ref1->frame->linesize[2],
1796  1, x0_c, y0_c, nPbW_c, nPbH_c, &current_mv,
1797  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1], s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1]);
1798  }
1799  } else if (current_mv.pred_flag == PF_BI) {
1800  int x0_c = x0 >> s->ps.sps->hshift[1];
1801  int y0_c = y0 >> s->ps.sps->vshift[1];
1802  int nPbW_c = nPbW >> s->ps.sps->hshift[1];
1803  int nPbH_c = nPbH >> s->ps.sps->vshift[1];
1804 
1805  luma_mc_bi(s, dst0, s->frame->linesize[0], ref0->frame,
1806  &current_mv.mv[0], x0, y0, nPbW, nPbH,
1807  ref1->frame, &current_mv.mv[1], &current_mv);
1808 
1809  if (s->ps.sps->chroma_format_idc) {
1810  chroma_mc_bi(s, dst1, s->frame->linesize[1], ref0->frame, ref1->frame,
1811  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 0);
1812 
1813  chroma_mc_bi(s, dst2, s->frame->linesize[2], ref0->frame, ref1->frame,
1814  x0_c, y0_c, nPbW_c, nPbH_c, &current_mv, 1);
1815  }
1816  }
1817 }
1818 
1819 /**
1820  * 8.4.1
1821  */
1822 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1823  int prev_intra_luma_pred_flag)
1824 {
1825  HEVCLocalContext *lc = s->HEVClc;
1826  int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1827  int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1828  int min_pu_width = s->ps.sps->min_pu_width;
1829  int size_in_pus = pu_size >> s->ps.sps->log2_min_pu_size;
1830  int x0b = av_mod_uintp2(x0, s->ps.sps->log2_ctb_size);
1831  int y0b = av_mod_uintp2(y0, s->ps.sps->log2_ctb_size);
1832 
1833  int cand_up = (lc->ctb_up_flag || y0b) ?
1834  s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1835  int cand_left = (lc->ctb_left_flag || x0b) ?
1836  s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1837 
1838  int y_ctb = (y0 >> (s->ps.sps->log2_ctb_size)) << (s->ps.sps->log2_ctb_size);
1839 
1840  MvField *tab_mvf = s->ref->tab_mvf;
1841  int intra_pred_mode;
1842  int candidate[3];
1843  int i, j;
1844 
1845  // intra_pred_mode prediction does not cross vertical CTB boundaries
1846  if ((y0 - 1) < y_ctb)
1847  cand_up = INTRA_DC;
1848 
1849  if (cand_left == cand_up) {
1850  if (cand_left < 2) {
1851  candidate[0] = INTRA_PLANAR;
1852  candidate[1] = INTRA_DC;
1853  candidate[2] = INTRA_ANGULAR_26;
1854  } else {
1855  candidate[0] = cand_left;
1856  candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1857  candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1858  }
1859  } else {
1860  candidate[0] = cand_left;
1861  candidate[1] = cand_up;
1862  if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1863  candidate[2] = INTRA_PLANAR;
1864  } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1865  candidate[2] = INTRA_DC;
1866  } else {
1867  candidate[2] = INTRA_ANGULAR_26;
1868  }
1869  }
1870 
1871  if (prev_intra_luma_pred_flag) {
1872  intra_pred_mode = candidate[lc->pu.mpm_idx];
1873  } else {
1874  if (candidate[0] > candidate[1])
1875  FFSWAP(uint8_t, candidate[0], candidate[1]);
1876  if (candidate[0] > candidate[2])
1877  FFSWAP(uint8_t, candidate[0], candidate[2]);
1878  if (candidate[1] > candidate[2])
1879  FFSWAP(uint8_t, candidate[1], candidate[2]);
1880 
1881  intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1882  for (i = 0; i < 3; i++)
1883  if (intra_pred_mode >= candidate[i])
1884  intra_pred_mode++;
1885  }
1886 
1887  /* write the intra prediction units into the mv array */
1888  if (!size_in_pus)
1889  size_in_pus = 1;
1890  for (i = 0; i < size_in_pus; i++) {
1891  memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1892  intra_pred_mode, size_in_pus);
1893 
1894  for (j = 0; j < size_in_pus; j++) {
1895  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag = PF_INTRA;
1896  }
1897  }
1898 
1899  return intra_pred_mode;
1900 }
1901 
1902 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
1903  int log2_cb_size, int ct_depth)
1904 {
1905  int length = (1 << log2_cb_size) >> s->ps.sps->log2_min_cb_size;
1906  int x_cb = x0 >> s->ps.sps->log2_min_cb_size;
1907  int y_cb = y0 >> s->ps.sps->log2_min_cb_size;
1908  int y;
1909 
1910  for (y = 0; y < length; y++)
1911  memset(&s->tab_ct_depth[(y_cb + y) * s->ps.sps->min_cb_width + x_cb],
1912  ct_depth, length);
1913 }
1914 
1915 static const uint8_t tab_mode_idx[] = {
1916  0, 1, 2, 2, 2, 2, 3, 5, 7, 8, 10, 12, 13, 15, 17, 18, 19, 20,
1917  21, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29, 30, 31};
1918 
1919 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
1920  int log2_cb_size)
1921 {
1922  HEVCLocalContext *lc = s->HEVClc;
1923  static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
1924  uint8_t prev_intra_luma_pred_flag[4];
1925  int split = lc->cu.part_mode == PART_NxN;
1926  int pb_size = (1 << log2_cb_size) >> split;
1927  int side = split + 1;
1928  int chroma_mode;
1929  int i, j;
1930 
1931  for (i = 0; i < side; i++)
1932  for (j = 0; j < side; j++)
1933  prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
1934 
1935  for (i = 0; i < side; i++) {
1936  for (j = 0; j < side; j++) {
1937  if (prev_intra_luma_pred_flag[2 * i + j])
1939  else
1941 
1942  lc->pu.intra_pred_mode[2 * i + j] =
1943  luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
1944  prev_intra_luma_pred_flag[2 * i + j]);
1945  }
1946  }
1947 
1948  if (s->ps.sps->chroma_format_idc == 3) {
1949  for (i = 0; i < side; i++) {
1950  for (j = 0; j < side; j++) {
1951  lc->pu.chroma_mode_c[2 * i + j] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1952  if (chroma_mode != 4) {
1953  if (lc->pu.intra_pred_mode[2 * i + j] == intra_chroma_table[chroma_mode])
1954  lc->pu.intra_pred_mode_c[2 * i + j] = 34;
1955  else
1956  lc->pu.intra_pred_mode_c[2 * i + j] = intra_chroma_table[chroma_mode];
1957  } else {
1958  lc->pu.intra_pred_mode_c[2 * i + j] = lc->pu.intra_pred_mode[2 * i + j];
1959  }
1960  }
1961  }
1962  } else if (s->ps.sps->chroma_format_idc == 2) {
1963  int mode_idx;
1964  lc->pu.chroma_mode_c[0] = chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1965  if (chroma_mode != 4) {
1966  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1967  mode_idx = 34;
1968  else
1969  mode_idx = intra_chroma_table[chroma_mode];
1970  } else {
1971  mode_idx = lc->pu.intra_pred_mode[0];
1972  }
1973  lc->pu.intra_pred_mode_c[0] = tab_mode_idx[mode_idx];
1974  } else if (s->ps.sps->chroma_format_idc != 0) {
1975  chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
1976  if (chroma_mode != 4) {
1977  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
1978  lc->pu.intra_pred_mode_c[0] = 34;
1979  else
1980  lc->pu.intra_pred_mode_c[0] = intra_chroma_table[chroma_mode];
1981  } else {
1982  lc->pu.intra_pred_mode_c[0] = lc->pu.intra_pred_mode[0];
1983  }
1984  }
1985 }
1986 
1988  int x0, int y0,
1989  int log2_cb_size)
1990 {
1991  HEVCLocalContext *lc = s->HEVClc;
1992  int pb_size = 1 << log2_cb_size;
1993  int size_in_pus = pb_size >> s->ps.sps->log2_min_pu_size;
1994  int min_pu_width = s->ps.sps->min_pu_width;
1995  MvField *tab_mvf = s->ref->tab_mvf;
1996  int x_pu = x0 >> s->ps.sps->log2_min_pu_size;
1997  int y_pu = y0 >> s->ps.sps->log2_min_pu_size;
1998  int j, k;
1999 
2000  if (size_in_pus == 0)
2001  size_in_pus = 1;
2002  for (j = 0; j < size_in_pus; j++)
2003  memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2004  if (lc->cu.pred_mode == MODE_INTRA)
2005  for (j = 0; j < size_in_pus; j++)
2006  for (k = 0; k < size_in_pus; k++)
2007  tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].pred_flag = PF_INTRA;
2008 }
2009 
2010 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2011 {
2012  int cb_size = 1 << log2_cb_size;
2013  HEVCLocalContext *lc = s->HEVClc;
2014  int log2_min_cb_size = s->ps.sps->log2_min_cb_size;
2015  int length = cb_size >> log2_min_cb_size;
2016  int min_cb_width = s->ps.sps->min_cb_width;
2017  int x_cb = x0 >> log2_min_cb_size;
2018  int y_cb = y0 >> log2_min_cb_size;
2019  int idx = log2_cb_size - 2;
2020  int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2021  int x, y, ret;
2022 
2023  lc->cu.x = x0;
2024  lc->cu.y = y0;
2025  lc->cu.pred_mode = MODE_INTRA;
2026  lc->cu.part_mode = PART_2Nx2N;
2027  lc->cu.intra_split_flag = 0;
2028 
2029  SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2030  for (x = 0; x < 4; x++)
2031  lc->pu.intra_pred_mode[x] = 1;
2034  if (lc->cu.cu_transquant_bypass_flag)
2035  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2036  } else
2037  lc->cu.cu_transquant_bypass_flag = 0;
2038 
2039  if (s->sh.slice_type != I_SLICE) {
2040  uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2041 
2042  x = y_cb * min_cb_width + x_cb;
2043  for (y = 0; y < length; y++) {
2044  memset(&s->skip_flag[x], skip_flag, length);
2045  x += min_cb_width;
2046  }
2047  lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2048  } else {
2049  x = y_cb * min_cb_width + x_cb;
2050  for (y = 0; y < length; y++) {
2051  memset(&s->skip_flag[x], 0, length);
2052  x += min_cb_width;
2053  }
2054  }
2055 
2056  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2057  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2058  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2059 
2061  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2062  } else {
2063  int pcm_flag = 0;
2064 
2065  if (s->sh.slice_type != I_SLICE)
2067  if (lc->cu.pred_mode != MODE_INTRA ||
2068  log2_cb_size == s->ps.sps->log2_min_cb_size) {
2069  lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2070  lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2071  lc->cu.pred_mode == MODE_INTRA;
2072  }
2073 
2074  if (lc->cu.pred_mode == MODE_INTRA) {
2075  if (lc->cu.part_mode == PART_2Nx2N && s->ps.sps->pcm_enabled_flag &&
2076  log2_cb_size >= s->ps.sps->pcm.log2_min_pcm_cb_size &&
2077  log2_cb_size <= s->ps.sps->pcm.log2_max_pcm_cb_size) {
2078  pcm_flag = ff_hevc_pcm_flag_decode(s);
2079  }
2080  if (pcm_flag) {
2081  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2082  ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2084  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2085 
2086  if (ret < 0)
2087  return ret;
2088  } else {
2089  intra_prediction_unit(s, x0, y0, log2_cb_size);
2090  }
2091  } else {
2092  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2093  switch (lc->cu.part_mode) {
2094  case PART_2Nx2N:
2095  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0, idx);
2096  break;
2097  case PART_2NxN:
2098  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0, idx);
2099  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1, idx);
2100  break;
2101  case PART_Nx2N:
2102  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0, idx - 1);
2103  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1, idx - 1);
2104  break;
2105  case PART_2NxnU:
2106  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0, idx);
2107  hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1, idx);
2108  break;
2109  case PART_2NxnD:
2110  hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0, idx);
2111  hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1, idx);
2112  break;
2113  case PART_nLx2N:
2114  hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0, idx - 2);
2115  hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1, idx - 2);
2116  break;
2117  case PART_nRx2N:
2118  hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0, idx - 2);
2119  hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1, idx - 2);
2120  break;
2121  case PART_NxN:
2122  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0, idx - 1);
2123  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1, idx - 1);
2124  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2, idx - 1);
2125  hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3, idx - 1);
2126  break;
2127  }
2128  }
2129 
2130  if (!pcm_flag) {
2131  int rqt_root_cbf = 1;
2132 
2133  if (lc->cu.pred_mode != MODE_INTRA &&
2134  !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2135  rqt_root_cbf = ff_hevc_no_residual_syntax_flag_decode(s);
2136  }
2137  if (rqt_root_cbf) {
2138  const static int cbf[2] = { 0 };
2139  lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2142  ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2143  log2_cb_size,
2144  log2_cb_size, 0, 0, cbf, cbf);
2145  if (ret < 0)
2146  return ret;
2147  } else {
2149  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size);
2150  }
2151  }
2152  }
2153 
2155  ff_hevc_set_qPy(s, x0, y0, log2_cb_size);
2156 
2157  x = y_cb * min_cb_width + x_cb;
2158  for (y = 0; y < length; y++) {
2159  memset(&s->qp_y_tab[x], lc->qp_y, length);
2160  x += min_cb_width;
2161  }
2162 
2163  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2164  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0) {
2165  lc->qPy_pred = lc->qp_y;
2166  }
2167 
2168  set_ct_depth(s, x0, y0, log2_cb_size, lc->ct_depth);
2169 
2170  return 0;
2171 }
2172 
2173 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2174  int log2_cb_size, int cb_depth)
2175 {
2176  HEVCLocalContext *lc = s->HEVClc;
2177  const int cb_size = 1 << log2_cb_size;
2178  int ret;
2179  int split_cu;
2180 
2181  lc->ct_depth = cb_depth;
2182  if (x0 + cb_size <= s->ps.sps->width &&
2183  y0 + cb_size <= s->ps.sps->height &&
2184  log2_cb_size > s->ps.sps->log2_min_cb_size) {
2185  split_cu = ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2186  } else {
2187  split_cu = (log2_cb_size > s->ps.sps->log2_min_cb_size);
2188  }
2189  if (s->ps.pps->cu_qp_delta_enabled_flag &&
2190  log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth) {
2191  lc->tu.is_cu_qp_delta_coded = 0;
2192  lc->tu.cu_qp_delta = 0;
2193  }
2194 
2196  log2_cb_size >= s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_chroma_qp_offset_depth) {
2198  }
2199 
2200  if (split_cu) {
2201  int qp_block_mask = (1<<(s->ps.sps->log2_ctb_size - s->ps.pps->diff_cu_qp_delta_depth)) - 1;
2202  const int cb_size_split = cb_size >> 1;
2203  const int x1 = x0 + cb_size_split;
2204  const int y1 = y0 + cb_size_split;
2205 
2206  int more_data = 0;
2207 
2208  more_data = hls_coding_quadtree(s, x0, y0, log2_cb_size - 1, cb_depth + 1);
2209  if (more_data < 0)
2210  return more_data;
2211 
2212  if (more_data && x1 < s->ps.sps->width) {
2213  more_data = hls_coding_quadtree(s, x1, y0, log2_cb_size - 1, cb_depth + 1);
2214  if (more_data < 0)
2215  return more_data;
2216  }
2217  if (more_data && y1 < s->ps.sps->height) {
2218  more_data = hls_coding_quadtree(s, x0, y1, log2_cb_size - 1, cb_depth + 1);
2219  if (more_data < 0)
2220  return more_data;
2221  }
2222  if (more_data && x1 < s->ps.sps->width &&
2223  y1 < s->ps.sps->height) {
2224  more_data = hls_coding_quadtree(s, x1, y1, log2_cb_size - 1, cb_depth + 1);
2225  if (more_data < 0)
2226  return more_data;
2227  }
2228 
2229  if(((x0 + (1<<log2_cb_size)) & qp_block_mask) == 0 &&
2230  ((y0 + (1<<log2_cb_size)) & qp_block_mask) == 0)
2231  lc->qPy_pred = lc->qp_y;
2232 
2233  if (more_data)
2234  return ((x1 + cb_size_split) < s->ps.sps->width ||
2235  (y1 + cb_size_split) < s->ps.sps->height);
2236  else
2237  return 0;
2238  } else {
2239  ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2240  if (ret < 0)
2241  return ret;
2242  if ((!((x0 + cb_size) %
2243  (1 << (s->ps.sps->log2_ctb_size))) ||
2244  (x0 + cb_size >= s->ps.sps->width)) &&
2245  (!((y0 + cb_size) %
2246  (1 << (s->ps.sps->log2_ctb_size))) ||
2247  (y0 + cb_size >= s->ps.sps->height))) {
2248  int end_of_slice_flag = ff_hevc_end_of_slice_flag_decode(s);
2249  return !end_of_slice_flag;
2250  } else {
2251  return 1;
2252  }
2253  }
2254 
2255  return 0;
2256 }
2257 
2258 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2259  int ctb_addr_ts)
2260 {
2261  HEVCLocalContext *lc = s->HEVClc;
2262  int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2263  int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2264  int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2265 
2266  s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2267 
2269  if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2270  lc->first_qp_group = 1;
2271  lc->end_of_tiles_x = s->ps.sps->width;
2272  } else if (s->ps.pps->tiles_enabled_flag) {
2273  if (ctb_addr_ts && s->ps.pps->tile_id[ctb_addr_ts] != s->ps.pps->tile_id[ctb_addr_ts - 1]) {
2274  int idxX = s->ps.pps->col_idxX[x_ctb >> s->ps.sps->log2_ctb_size];
2275  lc->end_of_tiles_x = x_ctb + (s->ps.pps->column_width[idxX] << s->ps.sps->log2_ctb_size);
2276  lc->first_qp_group = 1;
2277  }
2278  } else {
2279  lc->end_of_tiles_x = s->ps.sps->width;
2280  }
2281 
2282  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->ps.sps->height);
2283 
2284  lc->boundary_flags = 0;
2285  if (s->ps.pps->tiles_enabled_flag) {
2286  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]])
2288  if (x_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - 1])
2290  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]])
2292  if (y_ctb > 0 && s->tab_slice_address[ctb_addr_rs] != s->tab_slice_address[ctb_addr_rs - s->ps.sps->ctb_width])
2294  } else {
2295  if (ctb_addr_in_slice <= 0)
2297  if (ctb_addr_in_slice < s->ps.sps->ctb_width)
2299  }
2300 
2301  lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && !(lc->boundary_flags & BOUNDARY_LEFT_TILE));
2302  lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->ps.sps->ctb_width) && !(lc->boundary_flags & BOUNDARY_UPPER_TILE));
2303  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]]));
2304  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]]));
2305 }
2306 
2307 static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
2308 {
2309  HEVCContext *s = avctxt->priv_data;
2310  int ctb_size = 1 << s->ps.sps->log2_ctb_size;
2311  int more_data = 1;
2312  int x_ctb = 0;
2313  int y_ctb = 0;
2314  int ctb_addr_ts = s->ps.pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2315 
2316  if (!ctb_addr_ts && s->sh.dependent_slice_segment_flag) {
2317  av_log(s->avctx, AV_LOG_ERROR, "Impossible initial tile.\n");
2318  return AVERROR_INVALIDDATA;
2319  }
2320 
2322  int prev_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts - 1];
2323  if (s->tab_slice_address[prev_rs] != s->sh.slice_addr) {
2324  av_log(s->avctx, AV_LOG_ERROR, "Previous slice segment missing\n");
2325  return AVERROR_INVALIDDATA;
2326  }
2327  }
2328 
2329  while (more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2330  int ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2331 
2332  x_ctb = (ctb_addr_rs % ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2333  y_ctb = (ctb_addr_rs / ((s->ps.sps->width + ctb_size - 1) >> s->ps.sps->log2_ctb_size)) << s->ps.sps->log2_ctb_size;
2334  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2335 
2336  ff_hevc_cabac_init(s, ctb_addr_ts);
2337 
2338  hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2339 
2340  s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2341  s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2343 
2344  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2345  if (more_data < 0) {
2346  s->tab_slice_address[ctb_addr_rs] = -1;
2347  return more_data;
2348  }
2349 
2350 
2351  ctb_addr_ts++;
2352  ff_hevc_save_states(s, ctb_addr_ts);
2353  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2354  }
2355 
2356  if (x_ctb + ctb_size >= s->ps.sps->width &&
2357  y_ctb + ctb_size >= s->ps.sps->height)
2358  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2359 
2360  return ctb_addr_ts;
2361 }
2362 
2364 {
2365  int arg[2];
2366  int ret[2];
2367 
2368  arg[0] = 0;
2369  arg[1] = 1;
2370 
2371  s->avctx->execute(s->avctx, hls_decode_entry, arg, ret , 1, sizeof(int));
2372  return ret[0];
2373 }
2374 static int hls_decode_entry_wpp(AVCodecContext *avctxt, void *input_ctb_row, int job, int self_id)
2375 {
2376  HEVCContext *s1 = avctxt->priv_data, *s;
2377  HEVCLocalContext *lc;
2378  int ctb_size = 1<< s1->ps.sps->log2_ctb_size;
2379  int more_data = 1;
2380  int *ctb_row_p = input_ctb_row;
2381  int ctb_row = ctb_row_p[job];
2382  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);
2383  int ctb_addr_ts = s1->ps.pps->ctb_addr_rs_to_ts[ctb_addr_rs];
2384  int thread = ctb_row % s1->threads_number;
2385  int ret;
2386 
2387  s = s1->sList[self_id];
2388  lc = s->HEVClc;
2389 
2390  if(ctb_row) {
2391  ret = init_get_bits8(&lc->gb, s->data + s->sh.offset[ctb_row - 1], s->sh.size[ctb_row - 1]);
2392 
2393  if (ret < 0)
2394  return ret;
2395  ff_init_cabac_decoder(&lc->cc, s->data + s->sh.offset[(ctb_row)-1], s->sh.size[ctb_row - 1]);
2396  }
2397 
2398  while(more_data && ctb_addr_ts < s->ps.sps->ctb_size) {
2399  int x_ctb = (ctb_addr_rs % s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2400  int y_ctb = (ctb_addr_rs / s->ps.sps->ctb_width) << s->ps.sps->log2_ctb_size;
2401 
2402  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2403 
2404  ff_thread_await_progress2(s->avctx, ctb_row, thread, SHIFT_CTB_WPP);
2405 
2406  if (avpriv_atomic_int_get(&s1->wpp_err)){
2407  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2408  return 0;
2409  }
2410 
2411  ff_hevc_cabac_init(s, ctb_addr_ts);
2412  hls_sao_param(s, x_ctb >> s->ps.sps->log2_ctb_size, y_ctb >> s->ps.sps->log2_ctb_size);
2413  more_data = hls_coding_quadtree(s, x_ctb, y_ctb, s->ps.sps->log2_ctb_size, 0);
2414 
2415  if (more_data < 0) {
2416  s->tab_slice_address[ctb_addr_rs] = -1;
2417  avpriv_atomic_int_set(&s1->wpp_err, 1);
2418  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2419  return more_data;
2420  }
2421 
2422  ctb_addr_ts++;
2423 
2424  ff_hevc_save_states(s, ctb_addr_ts);
2425  ff_thread_report_progress2(s->avctx, ctb_row, thread, 1);
2426  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2427 
2428  if (!more_data && (x_ctb+ctb_size) < s->ps.sps->width && ctb_row != s->sh.num_entry_point_offsets) {
2429  avpriv_atomic_int_set(&s1->wpp_err, 1);
2430  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2431  return 0;
2432  }
2433 
2434  if ((x_ctb+ctb_size) >= s->ps.sps->width && (y_ctb+ctb_size) >= s->ps.sps->height ) {
2435  ff_hevc_hls_filter(s, x_ctb, y_ctb, ctb_size);
2436  ff_thread_report_progress2(s->avctx, ctb_row , thread, SHIFT_CTB_WPP);
2437  return ctb_addr_ts;
2438  }
2439  ctb_addr_rs = s->ps.pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2440  x_ctb+=ctb_size;
2441 
2442  if(x_ctb >= s->ps.sps->width) {
2443  break;
2444  }
2445  }
2446  ff_thread_report_progress2(s->avctx, ctb_row ,thread, SHIFT_CTB_WPP);
2447 
2448  return 0;
2449 }
2450 
2451 static int hls_slice_data_wpp(HEVCContext *s, const H2645NAL *nal)
2452 {
2453  const uint8_t *data = nal->data;
2454  int length = nal->size;
2455  HEVCLocalContext *lc = s->HEVClc;
2456  int *ret = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2457  int *arg = av_malloc_array(s->sh.num_entry_point_offsets + 1, sizeof(int));
2458  int64_t offset;
2459  int64_t startheader, cmpt = 0;
2460  int i, j, res = 0;
2461 
2462  if (!ret || !arg) {
2463  av_free(ret);
2464  av_free(arg);
2465  return AVERROR(ENOMEM);
2466  }
2467 
2469  av_log(s->avctx, AV_LOG_ERROR, "WPP ctb addresses are wrong (%d %d %d %d)\n",
2471  s->ps.sps->ctb_width, s->ps.sps->ctb_height
2472  );
2473  res = AVERROR_INVALIDDATA;
2474  goto error;
2475  }
2476 
2478 
2479  if (!s->sList[1]) {
2480  for (i = 1; i < s->threads_number; i++) {
2481  s->sList[i] = av_malloc(sizeof(HEVCContext));
2482  memcpy(s->sList[i], s, sizeof(HEVCContext));
2483  s->HEVClcList[i] = av_mallocz(sizeof(HEVCLocalContext));
2484  s->sList[i]->HEVClc = s->HEVClcList[i];
2485  }
2486  }
2487 
2488  offset = (lc->gb.index >> 3);
2489 
2490  for (j = 0, cmpt = 0, startheader = offset + s->sh.entry_point_offset[0]; j < nal->skipped_bytes; j++) {
2491  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2492  startheader--;
2493  cmpt++;
2494  }
2495  }
2496 
2497  for (i = 1; i < s->sh.num_entry_point_offsets; i++) {
2498  offset += (s->sh.entry_point_offset[i - 1] - cmpt);
2499  for (j = 0, cmpt = 0, startheader = offset
2500  + s->sh.entry_point_offset[i]; j < nal->skipped_bytes; j++) {
2501  if (nal->skipped_bytes_pos[j] >= offset && nal->skipped_bytes_pos[j] < startheader) {
2502  startheader--;
2503  cmpt++;
2504  }
2505  }
2506  s->sh.size[i - 1] = s->sh.entry_point_offset[i] - cmpt;
2507  s->sh.offset[i - 1] = offset;
2508 
2509  }
2510  if (s->sh.num_entry_point_offsets != 0) {
2511  offset += s->sh.entry_point_offset[s->sh.num_entry_point_offsets - 1] - cmpt;
2512  if (length < offset) {
2513  av_log(s->avctx, AV_LOG_ERROR, "entry_point_offset table is corrupted\n");
2514  res = AVERROR_INVALIDDATA;
2515  goto error;
2516  }
2517  s->sh.size[s->sh.num_entry_point_offsets - 1] = length - offset;
2518  s->sh.offset[s->sh.num_entry_point_offsets - 1] = offset;
2519 
2520  }
2521  s->data = data;
2522 
2523  for (i = 1; i < s->threads_number; i++) {
2524  s->sList[i]->HEVClc->first_qp_group = 1;
2525  s->sList[i]->HEVClc->qp_y = s->sList[0]->HEVClc->qp_y;
2526  memcpy(s->sList[i], s, sizeof(HEVCContext));
2527  s->sList[i]->HEVClc = s->HEVClcList[i];
2528  }
2529 
2531  ff_reset_entries(s->avctx);
2532 
2533  for (i = 0; i <= s->sh.num_entry_point_offsets; i++) {
2534  arg[i] = i;
2535  ret[i] = 0;
2536  }
2537 
2540 
2541  for (i = 0; i <= s->sh.num_entry_point_offsets; i++)
2542  res += ret[i];
2543 error:
2544  av_free(ret);
2545  av_free(arg);
2546  return res;
2547 }
2548 
2550 {
2551  AVFrame *out = s->ref->frame;
2552 
2553  if (s->sei_frame_packing_present &&
2556  s->content_interpretation_type > 0 &&
2557  s->content_interpretation_type < 3) {
2559  if (!stereo)
2560  return AVERROR(ENOMEM);
2561 
2562  switch (s->frame_packing_arrangement_type) {
2563  case 3:
2564  if (s->quincunx_subsampling)
2566  else
2567  stereo->type = AV_STEREO3D_SIDEBYSIDE;
2568  break;
2569  case 4:
2570  stereo->type = AV_STEREO3D_TOPBOTTOM;
2571  break;
2572  case 5:
2573  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2574  break;
2575  }
2576 
2577  if (s->content_interpretation_type == 2)
2578  stereo->flags = AV_STEREO3D_FLAG_INVERT;
2579  }
2580 
2582  (s->sei_anticlockwise_rotation || s->sei_hflip || s->sei_vflip)) {
2583  double angle = s->sei_anticlockwise_rotation * 360 / (double) (1 << 16);
2584  AVFrameSideData *rotation = av_frame_new_side_data(out,
2586  sizeof(int32_t) * 9);
2587  if (!rotation)
2588  return AVERROR(ENOMEM);
2589 
2590  av_display_rotation_set((int32_t *)rotation->data, angle);
2591  av_display_matrix_flip((int32_t *)rotation->data,
2592  s->sei_hflip, s->sei_vflip);
2593  }
2594 
2595  // Decrement the mastering display flag when IRAP frame has no_rasl_output_flag=1
2596  // so the side data persists for the entire coded video sequence.
2598  IS_IRAP(s) && s->no_rasl_output_flag) {
2600  }
2602  // HEVC uses a g,b,r ordering, which we convert to a more natural r,g,b
2603  const int mapping[3] = {2, 0, 1};
2604  const int chroma_den = 50000;
2605  const int luma_den = 10000;
2606  int i;
2607  AVMasteringDisplayMetadata *metadata =
2609  if (!metadata)
2610  return AVERROR(ENOMEM);
2611 
2612  for (i = 0; i < 3; i++) {
2613  const int j = mapping[i];
2614  metadata->display_primaries[i][0].num = s->display_primaries[j][0];
2615  metadata->display_primaries[i][0].den = chroma_den;
2616  metadata->display_primaries[i][1].num = s->display_primaries[j][1];
2617  metadata->display_primaries[i][1].den = chroma_den;
2618  }
2619  metadata->white_point[0].num = s->white_point[0];
2620  metadata->white_point[0].den = chroma_den;
2621  metadata->white_point[1].num = s->white_point[1];
2622  metadata->white_point[1].den = chroma_den;
2623 
2624  metadata->max_luminance.num = s->max_mastering_luminance;
2625  metadata->max_luminance.den = luma_den;
2626  metadata->min_luminance.num = s->min_mastering_luminance;
2627  metadata->min_luminance.den = luma_den;
2628  metadata->has_luminance = 1;
2629  metadata->has_primaries = 1;
2630 
2631  av_log(s->avctx, AV_LOG_DEBUG, "Mastering Display Metadata:\n");
2633  "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f)\n",
2634  av_q2d(metadata->display_primaries[0][0]),
2635  av_q2d(metadata->display_primaries[0][1]),
2636  av_q2d(metadata->display_primaries[1][0]),
2637  av_q2d(metadata->display_primaries[1][1]),
2638  av_q2d(metadata->display_primaries[2][0]),
2639  av_q2d(metadata->display_primaries[2][1]),
2640  av_q2d(metadata->white_point[0]), av_q2d(metadata->white_point[1]));
2642  "min_luminance=%f, max_luminance=%f\n",
2643  av_q2d(metadata->min_luminance), av_q2d(metadata->max_luminance));
2644  }
2645 
2646  if (s->a53_caption) {
2649  s->a53_caption_size);
2650  if (sd)
2651  memcpy(sd->data, s->a53_caption, s->a53_caption_size);
2652  av_freep(&s->a53_caption);
2653  s->a53_caption_size = 0;
2655  }
2656 
2657  return 0;
2658 }
2659 
2661 {
2662  HEVCLocalContext *lc = s->HEVClc;
2663  int pic_size_in_ctb = ((s->ps.sps->width >> s->ps.sps->log2_min_cb_size) + 1) *
2664  ((s->ps.sps->height >> s->ps.sps->log2_min_cb_size) + 1);
2665  int ret;
2666 
2667  memset(s->horizontal_bs, 0, s->bs_width * s->bs_height);
2668  memset(s->vertical_bs, 0, s->bs_width * s->bs_height);
2669  memset(s->cbf_luma, 0, s->ps.sps->min_tb_width * s->ps.sps->min_tb_height);
2670  memset(s->is_pcm, 0, (s->ps.sps->min_pu_width + 1) * (s->ps.sps->min_pu_height + 1));
2671  memset(s->tab_slice_address, -1, pic_size_in_ctb * sizeof(*s->tab_slice_address));
2672 
2673  s->is_decoded = 0;
2674  s->first_nal_type = s->nal_unit_type;
2675 
2676  if (s->ps.pps->tiles_enabled_flag)
2677  lc->end_of_tiles_x = s->ps.pps->column_width[0] << s->ps.sps->log2_ctb_size;
2678 
2679  ret = ff_hevc_set_new_ref(s, &s->frame, s->poc);
2680  if (ret < 0)
2681  goto fail;
2682 
2683  ret = ff_hevc_frame_rps(s);
2684  if (ret < 0) {
2685  av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2686  goto fail;
2687  }
2688 
2689  s->ref->frame->key_frame = IS_IRAP(s);
2690 
2691  ret = set_side_data(s);
2692  if (ret < 0)
2693  goto fail;
2694 
2695  s->frame->pict_type = 3 - s->sh.slice_type;
2696 
2697  if (!IS_IRAP(s))
2698  ff_hevc_bump_frame(s);
2699 
2701  ret = ff_hevc_output_frame(s, s->output_frame, 0);
2702  if (ret < 0)
2703  goto fail;
2704 
2705  if (!s->avctx->hwaccel)
2707 
2708  return 0;
2709 
2710 fail:
2711  if (s->ref)
2712  ff_hevc_unref_frame(s, s->ref, ~0);
2713  s->ref = NULL;
2714  return ret;
2715 }
2716 
2717 static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
2718 {
2719  HEVCLocalContext *lc = s->HEVClc;
2720  GetBitContext *gb = &lc->gb;
2721  int ctb_addr_ts, ret;
2722 
2723  *gb = nal->gb;
2724  s->nal_unit_type = nal->type;
2725  s->temporal_id = nal->temporal_id;
2726 
2727  switch (s->nal_unit_type) {
2728  case NAL_VPS:
2729  ret = ff_hevc_decode_nal_vps(gb, s->avctx, &s->ps);
2730  if (ret < 0)
2731  goto fail;
2732  break;
2733  case NAL_SPS:
2734  ret = ff_hevc_decode_nal_sps(gb, s->avctx, &s->ps,
2735  s->apply_defdispwin);
2736  if (ret < 0)
2737  goto fail;
2738  break;
2739  case NAL_PPS:
2740  ret = ff_hevc_decode_nal_pps(gb, s->avctx, &s->ps);
2741  if (ret < 0)
2742  goto fail;
2743  break;
2744  case NAL_SEI_PREFIX:
2745  case NAL_SEI_SUFFIX:
2746  ret = ff_hevc_decode_nal_sei(s);
2747  if (ret < 0)
2748  goto fail;
2749  break;
2750  case NAL_TRAIL_R:
2751  case NAL_TRAIL_N:
2752  case NAL_TSA_N:
2753  case NAL_TSA_R:
2754  case NAL_STSA_N:
2755  case NAL_STSA_R:
2756  case NAL_BLA_W_LP:
2757  case NAL_BLA_W_RADL:
2758  case NAL_BLA_N_LP:
2759  case NAL_IDR_W_RADL:
2760  case NAL_IDR_N_LP:
2761  case NAL_CRA_NUT:
2762  case NAL_RADL_N:
2763  case NAL_RADL_R:
2764  case NAL_RASL_N:
2765  case NAL_RASL_R:
2766  ret = hls_slice_header(s);
2767  if (ret < 0)
2768  return ret;
2769 
2770  if (s->max_ra == INT_MAX) {
2771  if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2772  s->max_ra = s->poc;
2773  } else {
2774  if (IS_IDR(s))
2775  s->max_ra = INT_MIN;
2776  }
2777  }
2778 
2779  if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2780  s->poc <= s->max_ra) {
2781  s->is_decoded = 0;
2782  break;
2783  } else {
2784  if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2785  s->max_ra = INT_MIN;
2786  }
2787 
2788  if (s->sh.first_slice_in_pic_flag) {
2789  ret = hevc_frame_start(s);
2790  if (ret < 0)
2791  return ret;
2792  } else if (!s->ref) {
2793  av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2794  goto fail;
2795  }
2796 
2797  if (s->nal_unit_type != s->first_nal_type) {
2799  "Non-matching NAL types of the VCL NALUs: %d %d\n",
2800  s->first_nal_type, s->nal_unit_type);
2801  return AVERROR_INVALIDDATA;
2802  }
2803 
2804  if (!s->sh.dependent_slice_segment_flag &&
2805  s->sh.slice_type != I_SLICE) {
2806  ret = ff_hevc_slice_rpl(s);
2807  if (ret < 0) {
2809  "Error constructing the reference lists for the current slice.\n");
2810  goto fail;
2811  }
2812  }
2813 
2814  if (s->sh.first_slice_in_pic_flag && s->avctx->hwaccel) {
2815  ret = s->avctx->hwaccel->start_frame(s->avctx, NULL, 0);
2816  if (ret < 0)
2817  goto fail;
2818  }
2819 
2820  if (s->avctx->hwaccel) {
2821  ret = s->avctx->hwaccel->decode_slice(s->avctx, nal->raw_data, nal->raw_size);
2822  if (ret < 0)
2823  goto fail;
2824  } else {
2825  if (s->threads_number > 1 && s->sh.num_entry_point_offsets > 0)
2826  ctb_addr_ts = hls_slice_data_wpp(s, nal);
2827  else
2828  ctb_addr_ts = hls_slice_data(s);
2829  if (ctb_addr_ts >= (s->ps.sps->ctb_width * s->ps.sps->ctb_height)) {
2830  s->is_decoded = 1;
2831  }
2832 
2833  if (ctb_addr_ts < 0) {
2834  ret = ctb_addr_ts;
2835  goto fail;
2836  }
2837  }
2838  break;
2839  case NAL_EOS_NUT:
2840  case NAL_EOB_NUT:
2841  s->seq_decode = (s->seq_decode + 1) & 0xff;
2842  s->max_ra = INT_MAX;
2843  break;
2844  case NAL_AUD:
2845  case NAL_FD_NUT:
2846  break;
2847  default:
2848  av_log(s->avctx, AV_LOG_INFO,
2849  "Skipping NAL unit %d\n", s->nal_unit_type);
2850  }
2851 
2852  return 0;
2853 fail:
2855  return ret;
2856  return 0;
2857 }
2858 
2859 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2860 {
2861  int i, ret = 0;
2862 
2863  s->ref = NULL;
2864  s->last_eos = s->eos;
2865  s->eos = 0;
2866 
2867  /* split the input packet into NAL units, so we know the upper bound on the
2868  * number of slices in the frame */
2869  ret = ff_h2645_packet_split(&s->pkt, buf, length, s->avctx, s->is_nalff,
2870  s->nal_length_size, s->avctx->codec_id);
2871  if (ret < 0) {
2873  "Error splitting the input into NAL units.\n");
2874  return ret;
2875  }
2876 
2877  for (i = 0; i < s->pkt.nb_nals; i++) {
2878  if (s->pkt.nals[i].type == NAL_EOB_NUT ||
2879  s->pkt.nals[i].type == NAL_EOS_NUT)
2880  s->eos = 1;
2881  }
2882 
2883  /* decode the NAL units */
2884  for (i = 0; i < s->pkt.nb_nals; i++) {
2885  ret = decode_nal_unit(s, &s->pkt.nals[i]);
2886  if (ret < 0) {
2888  "Error parsing NAL unit #%d.\n", i);
2889  goto fail;
2890  }
2891  }
2892 
2893 fail:
2894  if (s->ref && s->threads_type == FF_THREAD_FRAME)
2895  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2896 
2897  return ret;
2898 }
2899 
2900 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2901 {
2902  int i;
2903  for (i = 0; i < 16; i++)
2904  av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2905 }
2906 
2908 {
2910  int pixel_shift;
2911  int i, j;
2912 
2913  if (!desc)
2914  return AVERROR(EINVAL);
2915 
2916  pixel_shift = desc->comp[0].depth > 8;
2917 
2918  av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2919  s->poc);
2920 
2921  /* the checksums are LE, so we have to byteswap for >8bpp formats
2922  * on BE arches */
2923 #if HAVE_BIGENDIAN
2924  if (pixel_shift && !s->checksum_buf) {
2926  FFMAX3(frame->linesize[0], frame->linesize[1],
2927  frame->linesize[2]));
2928  if (!s->checksum_buf)
2929  return AVERROR(ENOMEM);
2930  }
2931 #endif
2932 
2933  for (i = 0; frame->data[i]; i++) {
2934  int width = s->avctx->coded_width;
2935  int height = s->avctx->coded_height;
2936  int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2937  int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2938  uint8_t md5[16];
2939 
2940  av_md5_init(s->md5_ctx);
2941  for (j = 0; j < h; j++) {
2942  const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2943 #if HAVE_BIGENDIAN
2944  if (pixel_shift) {
2945  s->bdsp.bswap16_buf((uint16_t *) s->checksum_buf,
2946  (const uint16_t *) src, w);
2947  src = s->checksum_buf;
2948  }
2949 #endif
2950  av_md5_update(s->md5_ctx, src, w << pixel_shift);
2951  }
2952  av_md5_final(s->md5_ctx, md5);
2953 
2954  if (!memcmp(md5, s->md5[i], 16)) {
2955  av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2956  print_md5(s->avctx, AV_LOG_DEBUG, md5);
2957  av_log (s->avctx, AV_LOG_DEBUG, "; ");
2958  } else {
2959  av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2960  print_md5(s->avctx, AV_LOG_ERROR, md5);
2961  av_log (s->avctx, AV_LOG_ERROR, " != ");
2962  print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2963  av_log (s->avctx, AV_LOG_ERROR, "\n");
2964  return AVERROR_INVALIDDATA;
2965  }
2966  }
2967 
2968  av_log(s->avctx, AV_LOG_DEBUG, "\n");
2969 
2970  return 0;
2971 }
2972 
2973 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2974  AVPacket *avpkt)
2975 {
2976  int ret;
2977  HEVCContext *s = avctx->priv_data;
2978 
2979  if (!avpkt->size) {
2980  ret = ff_hevc_output_frame(s, data, 1);
2981  if (ret < 0)
2982  return ret;
2983 
2984  *got_output = ret;
2985  return 0;
2986  }
2987 
2988  s->ref = NULL;
2989  ret = decode_nal_units(s, avpkt->data, avpkt->size);
2990  if (ret < 0)
2991  return ret;
2992 
2993  if (avctx->hwaccel) {
2994  if (s->ref && (ret = avctx->hwaccel->end_frame(avctx)) < 0) {
2995  av_log(avctx, AV_LOG_ERROR,
2996  "hardware accelerator failed to decode picture\n");
2997  ff_hevc_unref_frame(s, s->ref, ~0);
2998  return ret;
2999  }
3000  } else {
3001  /* verify the SEI checksum */
3002  if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
3003  s->is_md5) {
3004  ret = verify_md5(s, s->ref->frame);
3005  if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
3006  ff_hevc_unref_frame(s, s->ref, ~0);
3007  return ret;
3008  }
3009  }
3010  }
3011  s->is_md5 = 0;
3012 
3013  if (s->is_decoded) {
3014  av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
3015  s->is_decoded = 0;
3016  }
3017 
3018  if (s->output_frame->buf[0]) {
3019  av_frame_move_ref(data, s->output_frame);
3020  *got_output = 1;
3021  }
3022 
3023  return avpkt->size;
3024 }
3025 
3027 {
3028  int ret;
3029 
3030  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
3031  if (ret < 0)
3032  return ret;
3033 
3034  dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
3035  if (!dst->tab_mvf_buf)
3036  goto fail;
3037  dst->tab_mvf = src->tab_mvf;
3038 
3039  dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
3040  if (!dst->rpl_tab_buf)
3041  goto fail;
3042  dst->rpl_tab = src->rpl_tab;
3043 
3044  dst->rpl_buf = av_buffer_ref(src->rpl_buf);
3045  if (!dst->rpl_buf)
3046  goto fail;
3047 
3048  dst->poc = src->poc;
3049  dst->ctb_count = src->ctb_count;
3050  dst->window = src->window;
3051  dst->flags = src->flags;
3052  dst->sequence = src->sequence;
3053 
3054  if (src->hwaccel_picture_private) {
3056  if (!dst->hwaccel_priv_buf)
3057  goto fail;
3059  }
3060 
3061  return 0;
3062 fail:
3063  ff_hevc_unref_frame(s, dst, ~0);
3064  return AVERROR(ENOMEM);
3065 }
3066 
3068 {
3069  HEVCContext *s = avctx->priv_data;
3070  int i;
3071 
3072  pic_arrays_free(s);
3073 
3074  av_freep(&s->md5_ctx);
3075 
3076  av_freep(&s->cabac_state);
3077 
3078  for (i = 0; i < 3; i++) {
3079  av_freep(&s->sao_pixel_buffer_h[i]);
3080  av_freep(&s->sao_pixel_buffer_v[i]);
3081  }
3083 
3084  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3085  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3086  av_frame_free(&s->DPB[i].frame);
3087  }
3088 
3089  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++)
3090  av_buffer_unref(&s->ps.vps_list[i]);
3091  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++)
3092  av_buffer_unref(&s->ps.sps_list[i]);
3093  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++)
3094  av_buffer_unref(&s->ps.pps_list[i]);
3095  s->ps.sps = NULL;
3096  s->ps.pps = NULL;
3097  s->ps.vps = NULL;
3098 
3100  av_freep(&s->sh.offset);
3101  av_freep(&s->sh.size);
3102 
3103  for (i = 1; i < s->threads_number; i++) {
3104  HEVCLocalContext *lc = s->HEVClcList[i];
3105  if (lc) {
3106  av_freep(&s->HEVClcList[i]);
3107  av_freep(&s->sList[i]);
3108  }
3109  }
3110  if (s->HEVClc == s->HEVClcList[0])
3111  s->HEVClc = NULL;
3112  av_freep(&s->HEVClcList[0]);
3113 
3115 
3116  return 0;
3117 }
3118 
3120 {
3121  HEVCContext *s = avctx->priv_data;
3122  int i;
3123 
3124  s->avctx = avctx;
3125 
3126  s->HEVClc = av_mallocz(sizeof(HEVCLocalContext));
3127  if (!s->HEVClc)
3128  goto fail;
3129  s->HEVClcList[0] = s->HEVClc;
3130  s->sList[0] = s;
3131 
3133  if (!s->cabac_state)
3134  goto fail;
3135 
3137  if (!s->output_frame)
3138  goto fail;
3139 
3140  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3141  s->DPB[i].frame = av_frame_alloc();
3142  if (!s->DPB[i].frame)
3143  goto fail;
3144  s->DPB[i].tf.f = s->DPB[i].frame;
3145  }
3146 
3147  s->max_ra = INT_MAX;
3148 
3149  s->md5_ctx = av_md5_alloc();
3150  if (!s->md5_ctx)
3151  goto fail;
3152 
3153  ff_bswapdsp_init(&s->bdsp);
3154 
3155  s->context_initialized = 1;
3156  s->eos = 0;
3157 
3158  ff_hevc_reset_sei(s);
3159 
3160  return 0;
3161 
3162 fail:
3163  hevc_decode_free(avctx);
3164  return AVERROR(ENOMEM);
3165 }
3166 
3168  const AVCodecContext *src)
3169 {
3170  HEVCContext *s = dst->priv_data;
3171  HEVCContext *s0 = src->priv_data;
3172  int i, ret;
3173 
3174  if (!s->context_initialized) {
3175  ret = hevc_init_context(dst);
3176  if (ret < 0)
3177  return ret;
3178  }
3179 
3180  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3181  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3182  if (s0->DPB[i].frame->buf[0]) {
3183  ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3184  if (ret < 0)
3185  return ret;
3186  }
3187  }
3188 
3189  if (s->ps.sps != s0->ps.sps)
3190  s->ps.sps = NULL;
3191  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.vps_list); i++) {
3192  av_buffer_unref(&s->ps.vps_list[i]);
3193  if (s0->ps.vps_list[i]) {
3194  s->ps.vps_list[i] = av_buffer_ref(s0->ps.vps_list[i]);
3195  if (!s->ps.vps_list[i])
3196  return AVERROR(ENOMEM);
3197  }
3198  }
3199 
3200  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3201  av_buffer_unref(&s->ps.sps_list[i]);
3202  if (s0->ps.sps_list[i]) {
3203  s->ps.sps_list[i] = av_buffer_ref(s0->ps.sps_list[i]);
3204  if (!s->ps.sps_list[i])
3205  return AVERROR(ENOMEM);
3206  }
3207  }
3208 
3209  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.pps_list); i++) {
3210  av_buffer_unref(&s->ps.pps_list[i]);
3211  if (s0->ps.pps_list[i]) {
3212  s->ps.pps_list[i] = av_buffer_ref(s0->ps.pps_list[i]);
3213  if (!s->ps.pps_list[i])
3214  return AVERROR(ENOMEM);
3215  }
3216  }
3217 
3218  if (s->ps.sps != s0->ps.sps)
3219  if ((ret = set_sps(s, s0->ps.sps, src->pix_fmt)) < 0)
3220  return ret;
3221 
3222  s->seq_decode = s0->seq_decode;
3223  s->seq_output = s0->seq_output;
3224  s->pocTid0 = s0->pocTid0;
3225  s->max_ra = s0->max_ra;
3226  s->eos = s0->eos;
3228 
3229  s->is_nalff = s0->is_nalff;
3231 
3232  s->threads_number = s0->threads_number;
3233  s->threads_type = s0->threads_type;
3234 
3235  if (s0->eos) {
3236  s->seq_decode = (s->seq_decode + 1) & 0xff;
3237  s->max_ra = INT_MAX;
3238  }
3239 
3240  return 0;
3241 }
3242 
3244 {
3245  AVCodecContext *avctx = s->avctx;
3246  GetByteContext gb;
3247  int ret, i;
3248 
3249  bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3250 
3251  if (avctx->extradata_size > 3 &&
3252  (avctx->extradata[0] || avctx->extradata[1] ||
3253  avctx->extradata[2] > 1)) {
3254  /* It seems the extradata is encoded as hvcC format.
3255  * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3256  * is finalized. When finalized, configurationVersion will be 1 and we
3257  * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3258  int i, j, num_arrays, nal_len_size;
3259 
3260  s->is_nalff = 1;
3261 
3262  bytestream2_skip(&gb, 21);
3263  nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3264  num_arrays = bytestream2_get_byte(&gb);
3265 
3266  /* nal units in the hvcC always have length coded with 2 bytes,
3267  * so put a fake nal_length_size = 2 while parsing them */
3268  s->nal_length_size = 2;
3269 
3270  /* Decode nal units from hvcC. */
3271  for (i = 0; i < num_arrays; i++) {
3272  int type = bytestream2_get_byte(&gb) & 0x3f;
3273  int cnt = bytestream2_get_be16(&gb);
3274 
3275  for (j = 0; j < cnt; j++) {
3276  // +2 for the nal size field
3277  int nalsize = bytestream2_peek_be16(&gb) + 2;
3278  if (bytestream2_get_bytes_left(&gb) < nalsize) {
3280  "Invalid NAL unit size in extradata.\n");
3281  return AVERROR_INVALIDDATA;
3282  }
3283 
3284  ret = decode_nal_units(s, gb.buffer, nalsize);
3285  if (ret < 0) {
3286  av_log(avctx, AV_LOG_ERROR,
3287  "Decoding nal unit %d %d from hvcC failed\n",
3288  type, i);
3289  return ret;
3290  }
3291  bytestream2_skip(&gb, nalsize);
3292  }
3293  }
3294 
3295  /* Now store right nal length size, that will be used to parse
3296  * all other nals */
3297  s->nal_length_size = nal_len_size;
3298  } else {
3299  s->is_nalff = 0;
3300  ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3301  if (ret < 0)
3302  return ret;
3303  }
3304 
3305  /* export stream parameters from the first SPS */
3306  for (i = 0; i < FF_ARRAY_ELEMS(s->ps.sps_list); i++) {
3307  if (s->ps.sps_list[i]) {
3308  const HEVCSPS *sps = (const HEVCSPS*)s->ps.sps_list[i]->data;
3309  export_stream_params(s->avctx, &s->ps, sps);
3310  break;
3311  }
3312  }
3313 
3314  return 0;
3315 }
3316 
3318 {
3319  HEVCContext *s = avctx->priv_data;
3320  int ret;
3321 
3322  avctx->internal->allocate_progress = 1;
3323 
3324  ret = hevc_init_context(avctx);
3325  if (ret < 0)
3326  return ret;
3327 
3328  s->enable_parallel_tiles = 0;
3329  s->picture_struct = 0;
3330  s->eos = 1;
3331 
3332  if(avctx->active_thread_type & FF_THREAD_SLICE)
3333  s->threads_number = avctx->thread_count;
3334  else
3335  s->threads_number = 1;
3336 
3337  if (avctx->extradata_size > 0 && avctx->extradata) {
3338  ret = hevc_decode_extradata(s);
3339  if (ret < 0) {
3340  hevc_decode_free(avctx);
3341  return ret;
3342  }
3343  }
3344 
3345  if((avctx->active_thread_type & FF_THREAD_FRAME) && avctx->thread_count > 1)
3347  else
3349 
3350  return 0;
3351 }
3352 
3354 {
3355  HEVCContext *s = avctx->priv_data;
3356  int ret;
3357 
3358  memset(s, 0, sizeof(*s));
3359 
3360  ret = hevc_init_context(avctx);
3361  if (ret < 0)
3362  return ret;
3363 
3364  return 0;
3365 }
3366 
3368 {
3369  HEVCContext *s = avctx->priv_data;
3370  ff_hevc_flush_dpb(s);
3371  s->max_ra = INT_MAX;
3372  s->eos = 1;
3373 }
3374 
3375 #define OFFSET(x) offsetof(HEVCContext, x)
3376 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3377 
3378 static const AVOption options[] = {
3379  { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3380  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3381  { "strict-displaywin", "stricly apply default display window size", OFFSET(apply_defdispwin),
3382  AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, PAR },
3383  { NULL },
3384 };
3385 
3386 static const AVClass hevc_decoder_class = {
3387  .class_name = "HEVC decoder",
3388  .item_name = av_default_item_name,
3389  .option = options,
3390  .version = LIBAVUTIL_VERSION_INT,
3391 };
3392 
3394  .name = "hevc",
3395  .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3396  .type = AVMEDIA_TYPE_VIDEO,
3397  .id = AV_CODEC_ID_HEVC,
3398  .priv_data_size = sizeof(HEVCContext),
3399  .priv_class = &hevc_decoder_class,
3401  .close = hevc_decode_free,
3404  .update_thread_context = hevc_update_thread_context,
3406  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
3409 };
#define EDGE_EMU_BUFFER_STRIDE
Definition: hevc.h:78
const uint8_t ff_hevc_pel_weight[65]
Definition: hevc.c:44
int8_t cu_qp_offset_cr
Definition: hevc.h:705
int frame_packing_arrangement_type
Definition: hevc.h:904
uint8_t ctb_up_flag
Definition: hevc.h:768
const HEVCPPS * pps
Definition: hevc.h:570
AVFrame * frame
Definition: hevc.h:720
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.h:451
AVRational framerate
Definition: avcodec.h:3338
int sei_frame_packing_present
frame packing arrangement variables
Definition: hevc.h:903
const char const char void * val
Definition: avisynth_c.h:634
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:3725
uint8_t log2_sao_offset_scale_luma
Definition: hevc.h:544
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:766
HEVCPredContext hpc
Definition: hevc.h:845
const char * s
Definition: avisynth_c.h:631
#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.h:583
int short_term_ref_pic_set_sps_flag
Definition: hevc.h:591
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:124
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:541
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2222
int quincunx_subsampling
Definition: hevc.h:906
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
HEVCFrame * ref
Definition: hevc.h:831
#define EPEL_EXTRA_AFTER
Definition: hevc.h:72
Definition: hevc.h:668
int ctb_height
Definition: hevc.h:472
uint8_t is_cu_qp_delta_coded
Definition: hevc.h:702
AVOption.
Definition: opt.h:245
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static void flush(AVCodecContext *avctx)
int size
Definition: h2645_parse.h:33
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc.h:540
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:777
Definition: hevc.h:97
int ff_hevc_sao_band_position_decode(HEVCContext *s)
Definition: hevc_cabac.c:563
Definition: h264.h:123
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1851
int max_dec_pic_buffering
Definition: hevc.h:419
const char * fmt
Definition: avisynth_c.h:632
void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
Definition: hevcpred.c:43
VideoDSPContext vdsp
Definition: hevc.h:847
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevc.h:774
static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref, const Mv *mv, int y0, int height)
Definition: hevc.c:1642
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:247
Definition: hevc.h:207
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
static int init_thread_copy(AVCodecContext *avctx)
Definition: tta.c:390
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
int content_interpretation_type
Definition: hevc.h:905
AVFrame * f
Definition: thread.h:36
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:861
int8_t cb_qp_offset_list[5]
Definition: hevc.h:542
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:363
#define SHIFT_CTB_WPP
Definition: hevc.h:44
int16_t x
horizontal component of motion vector
Definition: hevc.h:664
#define HWACCEL_MAX
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
const char * desc
Definition: nvenc.c:89
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
void * hwaccel_picture_private
Definition: hevc.h:736
static int hevc_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: hevc.c:3167
uint8_t * cabac_state
Definition: hevc.h:808
#define MAX_REFS
Definition: hevc.h:41
int sei_hflip
Definition: hevc.h:911
uint8_t nb_refs
Definition: hevc.h:288
MvField * tab_mvf
Definition: hevc.h:722
int pic_init_qp_minus26
Definition: hevc.h:497
int bs_width
Definition: hevc.h:839
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:595
uint8_t intra_split_flag
IntraSplitFlag.
Definition: hevc.h:658
#define MAX_PPS_COUNT
Definition: h264.h:54
VUI vui
Definition: hevc.h:424
int rem_intra_luma_pred_mode
Definition: hevc.h:685
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2385
int vshift[3]
Definition: hevc.h:483
AVRational white_point[2]
CIE 1931 xy chromaticity coords of white point.
int num
numerator
Definition: rational.h:44
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:478
int size
Definition: avcodec.h:1581
static int decode_nal_unit(HEVCContext *s, const H2645NAL *nal)
Definition: hevc.c:2717
unsigned int slice_addr
Definition: hevc.h:579
uint32_t vui_time_scale
Definition: hevc.h:336
uint8_t weighted_bipred_flag
Definition: hevc.h:509
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)
Split an input packet into NAL units.
Definition: h2645_parse.c:248
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:31
int tc_offset
Definition: hevc.h:711
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:745
PredictionUnit pu
Definition: hevc.h:781
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1877
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static void intra_prediction_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:1919
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:522
uint8_t cabac_init_present_flag
Definition: hevc.h:493
int16_t chroma_offset_l1[16][2]
Definition: hevc.h:645
Definition: hevc.h:260
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:508
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.
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:458
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1173
HEVCParamSets ps
Definition: hevc.h:818
int x
Definition: hevc.h:651
int min_cb_height
Definition: hevc.h:475
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:555
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:495
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
struct HEVCFrame * ref[MAX_REFS]
Definition: hevc.h:292
uint8_t dependent_slice_segment_flag
Definition: hevc.h:586
CABACContext cc
Definition: hevc.h:758
ShortTermRPS slice_rps
Definition: hevc.h:593
int profile
profile
Definition: avcodec.h:3153
Views are next to each other.
Definition: stereo3d.h:45
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:563
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:431
AVCodec.
Definition: avcodec.h:3542
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
int width
Definition: hevc.h:469
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:553
uint16_t seq_decode
Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...
Definition: hevc.h:875
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
Definition: md5.c:157
uint8_t threads_type
Definition: hevc.h:802
enum NALUnitType first_nal_type
Definition: hevc.h:885
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc.h:485
#define HEVC_CONTEXTS
Definition: hevc.h:64
int pixel_shift
Definition: hevc.h:411
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:515
uint32_t min_mastering_luminance
Definition: hevc.h:923
int max_ra
Definition: hevc.h:838
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:600
static int hls_decode_entry(AVCodecContext *avctxt, void *isFilterThread)
Definition: hevc.c:2307
static int hls_slice_data(HEVCContext *s)
Definition: hevc.c:2363
int output_width
Definition: hevc.h:405
const uint8_t * data
Definition: hevc.h:881
static void hls_sao_param(HEVCContext *s, int rx, int ry)
Definition: hevc.c:844
AVBufferPool * rpl_tab_pool
candidate references for the current frame
Definition: hevc.h:821
uint8_t log2_sao_offset_scale_chroma
Definition: hevc.h:545
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2968
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 PAR
Definition: hevc.c:3376
#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:981
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.h:401
uint8_t disable_dbf
Definition: hevc.h:526
unsigned int log2_max_trafo_size
Definition: hevc.h:454
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevc.h:577
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
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:737
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
int end_of_tiles_x
Definition: hevc.h:771
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:140
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Definition: hevc_cabac.c:605
InterPredIdc
Definition: hevc.h:206
float delta
AVOptions.
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:123
static int set_side_data(HEVCContext *s)
Definition: hevc.c:2549
uint8_t ctb_up_right_flag
Definition: hevc.h:769
LongTermRPS long_term_rps
Definition: hevc.h:596
int poc[32]
Definition: hevc.h:286
uint8_t vps_timing_info_present_flag
Definition: hevc.h:384
uint8_t matrix_coeffs
Definition: hevc.h:321
static int hls_slice_header(HEVCContext *s)
Definition: hevc.c:425
int min_tb_width
Definition: hevc.h:476
int num_entry_point_offsets
Definition: hevc.h:629
AVFrame * output_frame
Definition: hevc.h:814
int apply_defdispwin
Definition: hevc.h:895
SAOParams * sao
Definition: hevc.h:827
const HEVCVPS * vps
Definition: hevc.h:568
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:496
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1764
int wpp_err
Definition: hevc.h:879
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:444
AVCodecContext * avctx
Definition: hevc.h:795
int min_cb_width
Definition: hevc.h:474
void ff_h2645_packet_uninit(H2645Packet *pkt)
Free all the allocated memory in the packet.
Definition: h2645_parse.c:367
static AVFrame * frame
static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:2010
struct AVMD5 * md5
Definition: movenc.c:56
#define avpriv_atomic_int_set
Definition: atomic_gcc.h:39
Structure to hold side data for an AVFrame.
Definition: frame.h:143
BswapDSPContext bdsp
Definition: hevc.h:848
#define height
ThreadFrame tf
Definition: hevc.h:721
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:80
uint8_t first_slice_in_pic_flag
Definition: hevc.h:585
uint8_t * data
Definition: avcodec.h:1580
uint8_t bit_depth_chroma
Definition: hevc.h:443
const uint8_t * buffer
Definition: bytestream.h:34
Definition: hevc.h:213
uint8_t ctb_up_left_flag
Definition: hevc.h:770
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:3841
uint8_t threads_number
Definition: hevc.h:803
uint8_t is_cu_chroma_qp_offset_coded
Definition: hevc.h:703
int ff_hevc_decode_nal_sei(HEVCContext *s)
Definition: hevc_sei.c:365
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:225
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: hevc.h:671
Definition: hevc.h:208
#define EPEL_EXTRA_BEFORE
Definition: hevc.h:71
int8_t * qp_y_tab
Definition: hevc.h:849
uint8_t loop_filter_disable_flag
Definition: hevc.h:446
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
Definition: hevc.c:2900
int sei_anticlockwise_rotation
Definition: hevc.h:910
ptrdiff_t size
Definition: opengl_enc.c:101
uint8_t pic_output_flag
Definition: hevc.h:587
int has_luminance
Flag indicating whether the luminance (min_ and max_) have been set.
uint8_t * tab_ct_depth
Definition: hevc.h:857
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:74
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
Definition: hevc.c:233
uint8_t cu_transquant_bypass_flag
Definition: hevc.h:660
int16_t tmp[MAX_PB_SIZE *MAX_PB_SIZE]
Definition: hevc.h:777
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...
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: hevc.c:934
Views are alternated temporally.
Definition: stereo3d.h:66
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
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:511
#define av_log(a,...)
uint8_t used[32]
Definition: hevc.h:287
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
Definition: hevc_cabac.c:583
int temporal_id
temporal_id_plus1 - 1
Definition: hevc.h:830
#define SET_SAO(elem, value)
Definition: hevc.c:832
uint8_t first_qp_group
Definition: hevc.h:755
HEVCDSPContext hevcdsp
Definition: hevc.h:846
int ctb_count
Definition: hevc.h:725
uint8_t no_output_of_prior_pics_flag
Definition: hevc.h:600
HEVCLocalContext * HEVClcList[MAX_NB_THREADS]
Definition: hevc.h:799
Definition: hevc.h:216
static void hevc_decode_flush(AVCodecContext *avctx)
Definition: hevc.c:3367
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: hevc.c:1396
const AVProfile ff_hevc_profiles[]
Definition: profiles.c:66
int8_t cr_qp_offset_list[5]
Definition: hevc.h:543
int slice_idx
number of the slice being currently decoded
Definition: hevc.h:835
Definition: h264.h:124
#define BOUNDARY_UPPER_SLICE
Definition: hevc.h:786
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:568
uint8_t intra_pred_mode[4]
Definition: hevc.h:686
uint8_t colour_plane_id
RPS coded in the slice header itself is stored here.
Definition: hevc.h:588
#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:1971
uint8_t cu_chroma_qp_offset_enabled_flag
Definition: hevc.h:619
int flags
Additional information about the frame packing.
Definition: stereo3d.h:132
static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
Definition: hevc.c:3353
int ff_hevc_cu_chroma_qp_offset_flag(HEVCContext *s)
Definition: hevc_cabac.c:650
void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int log2_trafo_size)
Definition: hevc_filter.c:715
uint8_t slice_initialized
1 if the independent slice segment header was successfully parsed
Definition: hevc.h:811
unsigned int log2_max_poc_lsb
Definition: hevc.h:414
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1404
int * skipped_bytes_pos
Definition: h2645_parse.h:59
int min_pu_height
Definition: hevc.h:479
void ff_hevc_reset_sei(HEVCContext *s)
Reset SEI values that are stored on the Context.
Definition: hevc_sei.c:377
av_default_item_name
AVBufferRef * rpl_tab_buf
Definition: hevc.h:732
#define AVERROR(e)
Definition: error.h:43
#define avpriv_atomic_int_get
Definition: atomic_gcc.h:28
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
uint8_t rpl_modification_flag[2]
Definition: hevc.h:599
int * size
Definition: hevc.h:628
int vui_timing_info_present_flag
Definition: hevc.h:334
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
Definition: hevc.h:193
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3098
RefPicList * refPicList
Definition: hevc.h:723
int16_t luma_offset_l0[16]
Definition: hevc.h:641
int bs_height
Definition: hevc.h:840
#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:57
void(* intra_pred[4])(struct HEVCContext *s, int x0, int y0, int c_idx)
Definition: hevcpred.h:32
#define s0
Definition: regdef.h:37
uint16_t display_primaries[3][2]
Definition: hevc.h:920
int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
Compute POC of the current frame and return it.
Definition: hevc_refs.c:518
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
const char * arg
Definition: jacosubdec.c:66
unsigned int log2_ctb_size
Definition: hevc.h:455
void(* transform_add[4])(uint8_t *_dst, int16_t *coeffs, ptrdiff_t _stride)
Definition: hevcdsp.h:49
int picture_struct
Definition: hevc.h:913
uint8_t * sao_pixel_buffer_h[3]
Definition: hevc.h:815
int8_t cu_qp_offset_cb
Definition: hevc.h:704
GLsizei GLsizei * length
Definition: opengl_enc.c:115
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:622
const char * name
Name of the codec implementation.
Definition: avcodec.h:3549
const ShortTermRPS * short_term_rps
Definition: hevc.h:594
uint8_t merge_flag
Definition: hevc.h:688
struct AVMD5 * md5_ctx
Definition: hevc.h:888
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:448
unsigned * entry_point_offset
Definition: hevc.h:626
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int8_t slice_qp
Definition: hevc.h:631
static int verify_md5(HEVCContext *s, AVFrame *frame)
Definition: hevc.c:2907
int ff_hevc_cu_chroma_qp_offset_idx(HEVCContext *s)
Definition: hevc_cabac.c:655
#define FFMAX(a, b)
Definition: common.h:94
static const AVClass hevc_decoder_class
Definition: hevc.c:3386
AVRational max_luminance
Max luminance of mastering display (cd/m^2).
#define fail()
Definition: checkasm.h:81
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1019
uint8_t max_trafo_depth
MaxTrafoDepth.
Definition: hevc.h:659
uint8_t edge_emu_buffer2[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevc.h:776
int raw_size
Definition: h2645_parse.h:42
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: hevc.h:742
uint8_t colour_primaries
Definition: hevc.h:319
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevc.h:601
uint8_t * vertical_bs
Definition: hevc.h:851
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
int chroma_mode_c
Definition: hevc.h:701
uint8_t tiles_enabled_flag
Definition: hevc.h:514
int ff_alloc_entries(AVCodecContext *avctx, int count)
int eo_class[3]
sao_eo_class
Definition: hevcdsp.h:38
int ct_depth
Definition: hevc.h:779
uint32_t vps_num_units_in_tick
Definition: hevc.h:385
static av_cold int hevc_init_context(AVCodecContext *avctx)
Definition: hevc.c:3119
int16_t luma_weight_l0[16]
Definition: hevc.h:636
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
int * col_idxX
Definition: hevc.h:552
struct HEVCContext * sList[MAX_NB_THREADS]
Definition: hevc.h:797
int slice_qp_delta
Definition: hevc.h:615
common internal API header
int intra_pred_mode
Definition: hevc.h:699
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:808
const HEVCSPS * sps
Definition: hevc.h:569
uint8_t lists_modification_present_flag
Definition: hevc.h:533
#define QPEL_EXTRA
Definition: hevc.h:76
uint8_t profile_idc
Definition: hevc.h:355
AVBufferRef * tab_mvf_buf
Definition: hevc.h:731
uint8_t type_idx[3]
sao_type_idx
Definition: hevcdsp.h:42
uint8_t chroma_mode_c[4]
Definition: hevc.h:690
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:621
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:258
int res_scale_val
Definition: hevc.h:696
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2936
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3090
int max_transform_hierarchy_depth_inter
Definition: hevc.h:458
#define IS_IDR(s)
Definition: hevc.h:86
#define FFMIN(a, b)
Definition: common.h:96
static const AVOption options[]
Definition: hevc.c:3378
uint8_t * sao_pixel_buffer_v[3]
Definition: hevc.h:816
int slice_cr_qp_offset
Definition: hevc.h:617
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:74
AVRational min_luminance
Min luminance of mastering display (cd/m^2).
int offset_abs[3][4]
sao_offset_abs
Definition: hevcdsp.h:33
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:517
#define width
int output_height
Definition: hevc.h:405
int width
picture width / height.
Definition: avcodec.h:1836
int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush)
Find next frame in output order and put a reference to it in frame.
Definition: hevc_refs.c:170
uint8_t * tab_ipm
Definition: hevc.h:859
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: hevc.c:1552
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
Definition: hevc.c:2859
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size)
Definition: hevc_filter.c:868
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: hevc.c:1822
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:565
int hshift[3]
Definition: hevc.h:482
static int set_sps(HEVCContext *s, const HEVCSPS *sps, enum AVPixelFormat pix_fmt)
Definition: hevc.c:331
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:690
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define OFFSET(x)
Definition: hevc.c:3375
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:2364
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:502
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:438
int sei_mastering_display_info_present
mastering display
Definition: hevc.h:919
int8_t qp_y
Definition: hevc.h:760
static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:1278
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:3091
Definition: hevc.h:134
Context Adaptive Binary Arithmetic Coder inline functions.
int level
level
Definition: avcodec.h:3242
int intra_pred_mode_c
Definition: hevc.h:700
Definition: hevc.h:209
int ctb_width
Definition: hevc.h:471
int16_t chroma_weight_l0[16][2]
Definition: hevc.h:637
void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, int nPbW, int nPbH)
Definition: hevc_mvs.c:41
int height
Definition: hevc.h:470
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2947
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
uint8_t output_flag_present_flag
Definition: hevc.h:510
uint16_t seq_output
Definition: hevc.h:876
int mpm_idx
Definition: hevc.h:684
PTLCommon general_ptl
Definition: hevc.h:365
#define src
Definition: vp9dsp.c:530
void ff_hevc_set_qPy(HEVCContext *s, int xBase, int yBase, int log2_cb_size)
Definition: hevc_filter.c:122
int16_t luma_offset_l1[16]
Definition: hevc.h:644
int16_t chroma_offset_l0[16][2]
Definition: hevc.h:642
Definition: h264.h:122
uint32_t max_mastering_luminance
Definition: hevc.h:922
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:114
int type
NAL unit type.
Definition: h2645_parse.h:50
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
static int hevc_frame_start(HEVCContext *s)
Definition: hevc.c:2660
unsigned vps_id
Definition: hevc.h:400
#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:3079
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:457
unsigned int pps_id
address (in raster order) of the first block in the current slice segment
Definition: hevc.h:574
#define IS_BLA(s)
Definition: hevc.h:87
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:507
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:85
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
Definition: hevc_cabac.c:671
uint32_t vps_time_scale
Definition: hevc.h:386
void ff_reset_entries(AVCodecContext *avctx)
Definition: hevc.h:133
int colour_description_present_flag
Definition: hevc.h:318
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1023
static const int8_t mv[256][2]
Definition: 4xm.c:77
HEVCFrame DPB[32]
Definition: hevc.h:832
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: hevc.c:1487
Definition: hevc.h:399
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:248
enum AVPixelFormat pix_fmt
Definition: hevc.h:412
Definition: hevc.h:372
RefPicListTab ** rpl_tab
Definition: hevc.h:724
void ff_hevc_hls_filter(HEVCContext *s, int x, int y, int ctb_size)
Definition: hevc_filter.c:843
int sei_display_orientation_present
display orientation
Definition: hevc.h:909
int ff_hevc_res_scale_sign_flag(HEVCContext *s, int idx)
Definition: hevc_cabac.c:890
int slice_cb_qp_offset
Definition: hevc.h:616
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition: hevcdsp.c:126
#define src1
Definition: h264pred.c:139
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:127
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define CTB(tab, x, y)
Definition: hevc.c:830
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
Definition: hevc.c:84
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: hevc.c:56
Definition: hevc.h:488
static av_cold int hevc_decode_init(AVCodecContext *avctx)
Definition: hevc.c:3317
int short_term_ref_pic_set_size
Definition: hevc.h:592
#define IS_IRAP(s)
Definition: hevc.h:89
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
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: hevc.c:1335
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:83
uint8_t is_nalff
this flag is != 0 if bitstream is encapsulated as a format defined in 14496-15
Definition: hevc.h:893
enum AVCodecID codec_id
Definition: avcodec.h:1666
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:554
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
PTL ptl
Definition: hevc.h:425
int max_sub_layers
Definition: hevc.h:417
unsigned int log2_min_pu_size
Definition: hevc.h:456
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:437
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:87
uint8_t md5[3][16]
Definition: hevc.h:889
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:489
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.h:595
main external API structure.
Definition: avcodec.h:1649
uint8_t is_md5
Definition: hevc.h:890
uint8_t sao_enabled
Definition: hevc.h:434
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
static int hevc_decode_extradata(HEVCContext *s)
Definition: hevc.c:3243
enum PredMode pred_mode
PredMode.
Definition: hevc.h:654
AVBufferRef * hwaccel_priv_buf
Definition: hevc.h:735
int num_extra_slice_header_bits
Definition: hevc.h:535
uint8_t * data
The data buffer.
Definition: buffer.h:89
int16_t y
vertical component of motion vector
Definition: hevc.h:665
uint8_t cross_pf
Definition: hevc.h:706
Definition: hevc.h:111