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