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