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