Libav
hevc.c
Go to the documentation of this file.
1 /*
2  * HEVC video decoder
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2012 - 2013 Wassim Hamidouche
8  *
9  * This file is part of Libav.
10  *
11  * Libav 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  * Libav 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 Libav; 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/internal.h"
29 #include "libavutil/md5.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/stereo3d.h"
33 
34 #include "bytestream.h"
35 #include "cabac_functions.h"
36 #include "dsputil.h"
37 #include "golomb.h"
38 #include "hevc.h"
39 
40 const uint8_t ff_hevc_qpel_extra_before[4] = { 0, 3, 3, 2 };
41 const uint8_t ff_hevc_qpel_extra_after[4] = { 0, 3, 4, 4 };
42 const uint8_t ff_hevc_qpel_extra[4] = { 0, 6, 7, 6 };
43 
44 static const uint8_t scan_1x1[1] = { 0 };
45 
46 static const uint8_t horiz_scan2x2_x[4] = { 0, 1, 0, 1 };
47 
48 static const uint8_t horiz_scan2x2_y[4] = { 0, 0, 1, 1 };
49 
50 static const uint8_t horiz_scan4x4_x[16] = {
51  0, 1, 2, 3,
52  0, 1, 2, 3,
53  0, 1, 2, 3,
54  0, 1, 2, 3,
55 };
56 
57 static const uint8_t horiz_scan4x4_y[16] = {
58  0, 0, 0, 0,
59  1, 1, 1, 1,
60  2, 2, 2, 2,
61  3, 3, 3, 3,
62 };
63 
64 static const uint8_t horiz_scan8x8_inv[8][8] = {
65  { 0, 1, 2, 3, 16, 17, 18, 19, },
66  { 4, 5, 6, 7, 20, 21, 22, 23, },
67  { 8, 9, 10, 11, 24, 25, 26, 27, },
68  { 12, 13, 14, 15, 28, 29, 30, 31, },
69  { 32, 33, 34, 35, 48, 49, 50, 51, },
70  { 36, 37, 38, 39, 52, 53, 54, 55, },
71  { 40, 41, 42, 43, 56, 57, 58, 59, },
72  { 44, 45, 46, 47, 60, 61, 62, 63, },
73 };
74 
75 static const uint8_t diag_scan2x2_x[4] = { 0, 0, 1, 1 };
76 
77 static const uint8_t diag_scan2x2_y[4] = { 0, 1, 0, 1 };
78 
79 static const uint8_t diag_scan2x2_inv[2][2] = {
80  { 0, 2, },
81  { 1, 3, },
82 };
83 
85  0, 0, 1, 0,
86  1, 2, 0, 1,
87  2, 3, 1, 2,
88  3, 2, 3, 3,
89 };
90 
92  0, 1, 0, 2,
93  1, 0, 3, 2,
94  1, 0, 3, 2,
95  1, 3, 2, 3,
96 };
97 
98 static const uint8_t diag_scan4x4_inv[4][4] = {
99  { 0, 2, 5, 9, },
100  { 1, 4, 8, 12, },
101  { 3, 7, 11, 14, },
102  { 6, 10, 13, 15, },
103 };
104 
106  0, 0, 1, 0,
107  1, 2, 0, 1,
108  2, 3, 0, 1,
109  2, 3, 4, 0,
110  1, 2, 3, 4,
111  5, 0, 1, 2,
112  3, 4, 5, 6,
113  0, 1, 2, 3,
114  4, 5, 6, 7,
115  1, 2, 3, 4,
116  5, 6, 7, 2,
117  3, 4, 5, 6,
118  7, 3, 4, 5,
119  6, 7, 4, 5,
120  6, 7, 5, 6,
121  7, 6, 7, 7,
122 };
123 
125  0, 1, 0, 2,
126  1, 0, 3, 2,
127  1, 0, 4, 3,
128  2, 1, 0, 5,
129  4, 3, 2, 1,
130  0, 6, 5, 4,
131  3, 2, 1, 0,
132  7, 6, 5, 4,
133  3, 2, 1, 0,
134  7, 6, 5, 4,
135  3, 2, 1, 7,
136  6, 5, 4, 3,
137  2, 7, 6, 5,
138  4, 3, 7, 6,
139  5, 4, 7, 6,
140  5, 7, 6, 7,
141 };
142 
143 static const uint8_t diag_scan8x8_inv[8][8] = {
144  { 0, 2, 5, 9, 14, 20, 27, 35, },
145  { 1, 4, 8, 13, 19, 26, 34, 42, },
146  { 3, 7, 12, 18, 25, 33, 41, 48, },
147  { 6, 11, 17, 24, 32, 40, 47, 53, },
148  { 10, 16, 23, 31, 39, 46, 52, 57, },
149  { 15, 22, 30, 38, 45, 51, 56, 60, },
150  { 21, 29, 37, 44, 50, 55, 59, 62, },
151  { 28, 36, 43, 49, 54, 58, 61, 63, },
152 };
153 
163 /* free everything allocated by pic_arrays_init() */
165 {
166  av_freep(&s->sao);
167  av_freep(&s->deblock);
168  av_freep(&s->split_cu_flag);
169 
170  av_freep(&s->skip_flag);
171  av_freep(&s->tab_ct_depth);
172 
173  av_freep(&s->tab_ipm);
174  av_freep(&s->cbf_luma);
175  av_freep(&s->is_pcm);
176 
177  av_freep(&s->qp_y_tab);
180 
181  av_freep(&s->horizontal_bs);
182  av_freep(&s->vertical_bs);
183 
186 }
187 
188 /* allocate arrays that depend on frame dimensions */
189 static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
190 {
191  int log2_min_cb_size = sps->log2_min_cb_size;
192  int width = sps->width;
193  int height = sps->height;
194  int pic_size = width * height;
195  int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
196  ((height >> log2_min_cb_size) + 1);
197  int ctb_count = sps->ctb_width * sps->ctb_height;
198  int min_pu_size = sps->min_pu_width * sps->min_pu_height;
199 
200  s->bs_width = width >> 3;
201  s->bs_height = height >> 3;
202 
203  s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
204  s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
205  s->split_cu_flag = av_malloc(pic_size);
206  if (!s->sao || !s->deblock || !s->split_cu_flag)
207  goto fail;
208 
209  s->skip_flag = av_malloc(pic_size_in_ctb);
211  if (!s->skip_flag || !s->tab_ct_depth)
212  goto fail;
213 
214  s->cbf_luma = av_malloc(sps->min_tb_width * sps->min_tb_height);
215  s->tab_ipm = av_mallocz(min_pu_size);
216  s->is_pcm = av_malloc(min_pu_size);
217  if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
218  goto fail;
219 
220  s->filter_slice_edges = av_malloc(ctb_count);
221  s->tab_slice_address = av_malloc(pic_size_in_ctb *
222  sizeof(*s->tab_slice_address));
223  s->qp_y_tab = av_malloc(pic_size_in_ctb *
224  sizeof(*s->qp_y_tab));
225  if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
226  goto fail;
227 
228  s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
229  s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
230  if (!s->horizontal_bs || !s->vertical_bs)
231  goto fail;
232 
233  s->tab_mvf_pool = av_buffer_pool_init(min_pu_size * sizeof(MvField),
235  s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
237  if (!s->tab_mvf_pool || !s->rpl_tab_pool)
238  goto fail;
239 
240  return 0;
241 
242 fail:
243  pic_arrays_free(s);
244  return AVERROR(ENOMEM);
245 }
246 
248 {
249  int i = 0;
250  int j = 0;
251  uint8_t luma_weight_l0_flag[16];
252  uint8_t chroma_weight_l0_flag[16];
253  uint8_t luma_weight_l1_flag[16];
254  uint8_t chroma_weight_l1_flag[16];
255 
257  if (s->sps->chroma_format_idc != 0) {
258  int delta = get_se_golomb(gb);
260  }
261 
262  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
263  luma_weight_l0_flag[i] = get_bits1(gb);
264  if (!luma_weight_l0_flag[i]) {
265  s->sh.luma_weight_l0[i] = 1 << s->sh.luma_log2_weight_denom;
266  s->sh.luma_offset_l0[i] = 0;
267  }
268  }
269  if (s->sps->chroma_format_idc != 0) { // FIXME: invert "if" and "for"
270  for (i = 0; i < s->sh.nb_refs[L0]; i++)
271  chroma_weight_l0_flag[i] = get_bits1(gb);
272  } else {
273  for (i = 0; i < s->sh.nb_refs[L0]; i++)
274  chroma_weight_l0_flag[i] = 0;
275  }
276  for (i = 0; i < s->sh.nb_refs[L0]; i++) {
277  if (luma_weight_l0_flag[i]) {
278  int delta_luma_weight_l0 = get_se_golomb(gb);
279  s->sh.luma_weight_l0[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l0;
280  s->sh.luma_offset_l0[i] = get_se_golomb(gb);
281  }
282  if (chroma_weight_l0_flag[i]) {
283  for (j = 0; j < 2; j++) {
284  int delta_chroma_weight_l0 = get_se_golomb(gb);
285  int delta_chroma_offset_l0 = get_se_golomb(gb);
286  s->sh.chroma_weight_l0[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l0;
287  s->sh.chroma_offset_l0[i][j] = av_clip_c((delta_chroma_offset_l0 - ((128 * s->sh.chroma_weight_l0[i][j])
288  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
289  }
290  } else {
291  s->sh.chroma_weight_l0[i][0] = 1 << s->sh.chroma_log2_weight_denom;
292  s->sh.chroma_offset_l0[i][0] = 0;
293  s->sh.chroma_weight_l0[i][1] = 1 << s->sh.chroma_log2_weight_denom;
294  s->sh.chroma_offset_l0[i][1] = 0;
295  }
296  }
297  if (s->sh.slice_type == B_SLICE) {
298  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
299  luma_weight_l1_flag[i] = get_bits1(gb);
300  if (!luma_weight_l1_flag[i]) {
301  s->sh.luma_weight_l1[i] = 1 << s->sh.luma_log2_weight_denom;
302  s->sh.luma_offset_l1[i] = 0;
303  }
304  }
305  if (s->sps->chroma_format_idc != 0) {
306  for (i = 0; i < s->sh.nb_refs[L1]; i++)
307  chroma_weight_l1_flag[i] = get_bits1(gb);
308  } else {
309  for (i = 0; i < s->sh.nb_refs[L1]; i++)
310  chroma_weight_l1_flag[i] = 0;
311  }
312  for (i = 0; i < s->sh.nb_refs[L1]; i++) {
313  if (luma_weight_l1_flag[i]) {
314  int delta_luma_weight_l1 = get_se_golomb(gb);
315  s->sh.luma_weight_l1[i] = (1 << s->sh.luma_log2_weight_denom) + delta_luma_weight_l1;
316  s->sh.luma_offset_l1[i] = get_se_golomb(gb);
317  }
318  if (chroma_weight_l1_flag[i]) {
319  for (j = 0; j < 2; j++) {
320  int delta_chroma_weight_l1 = get_se_golomb(gb);
321  int delta_chroma_offset_l1 = get_se_golomb(gb);
322  s->sh.chroma_weight_l1[i][j] = (1 << s->sh.chroma_log2_weight_denom) + delta_chroma_weight_l1;
323  s->sh.chroma_offset_l1[i][j] = av_clip_c((delta_chroma_offset_l1 - ((128 * s->sh.chroma_weight_l1[i][j])
324  >> s->sh.chroma_log2_weight_denom) + 128), -128, 127);
325  }
326  } else {
327  s->sh.chroma_weight_l1[i][0] = 1 << s->sh.chroma_log2_weight_denom;
328  s->sh.chroma_offset_l1[i][0] = 0;
329  s->sh.chroma_weight_l1[i][1] = 1 << s->sh.chroma_log2_weight_denom;
330  s->sh.chroma_offset_l1[i][1] = 0;
331  }
332  }
333  }
334 }
335 
337 {
338  const HEVCSPS *sps = s->sps;
339  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
340  int prev_delta_msb = 0;
341  unsigned int nb_sps = 0, nb_sh;
342  int i;
343 
344  rps->nb_refs = 0;
346  return 0;
347 
348  if (sps->num_long_term_ref_pics_sps > 0)
349  nb_sps = get_ue_golomb_long(gb);
350  nb_sh = get_ue_golomb_long(gb);
351 
352  if (nb_sh + nb_sps > FF_ARRAY_ELEMS(rps->poc))
353  return AVERROR_INVALIDDATA;
354 
355  rps->nb_refs = nb_sh + nb_sps;
356 
357  for (i = 0; i < rps->nb_refs; i++) {
358  uint8_t delta_poc_msb_present;
359 
360  if (i < nb_sps) {
361  uint8_t lt_idx_sps = 0;
362 
363  if (sps->num_long_term_ref_pics_sps > 1)
364  lt_idx_sps = get_bits(gb, av_ceil_log2(sps->num_long_term_ref_pics_sps));
365 
366  rps->poc[i] = sps->lt_ref_pic_poc_lsb_sps[lt_idx_sps];
367  rps->used[i] = sps->used_by_curr_pic_lt_sps_flag[lt_idx_sps];
368  } else {
369  rps->poc[i] = get_bits(gb, sps->log2_max_poc_lsb);
370  rps->used[i] = get_bits1(gb);
371  }
372 
373  delta_poc_msb_present = get_bits1(gb);
374  if (delta_poc_msb_present) {
375  int delta = get_ue_golomb_long(gb);
376 
377  if (i && i != nb_sps)
378  delta += prev_delta_msb;
379 
380  rps->poc[i] += s->poc - delta * max_poc_lsb - s->sh.pic_order_cnt_lsb;
381  prev_delta_msb = delta;
382  }
383  }
384 
385  return 0;
386 }
387 
388 static int set_sps(HEVCContext *s, const HEVCSPS *sps)
389 {
390  int ret;
391  unsigned int num = 0, den = 0;
392 
393  pic_arrays_free(s);
394  ret = pic_arrays_init(s, sps);
395  if (ret < 0)
396  goto fail;
397 
398  s->avctx->coded_width = sps->width;
399  s->avctx->coded_height = sps->height;
400  s->avctx->width = sps->output_width;
401  s->avctx->height = sps->output_height;
402  s->avctx->pix_fmt = sps->pix_fmt;
403  s->avctx->sample_aspect_ratio = sps->vui.sar;
405 
409  else
411 
415  s->avctx->colorspace = sps->vui.matrix_coeffs;
416  } else {
420  }
421 
422  ff_hevc_pred_init(&s->hpc, sps->bit_depth);
423  ff_hevc_dsp_init (&s->hevcdsp, sps->bit_depth);
424  ff_videodsp_init (&s->vdsp, sps->bit_depth);
425 
426  if (sps->sao_enabled) {
429  if (ret < 0)
430  goto fail;
431  s->frame = s->tmp_frame;
432  }
433 
434  s->sps = sps;
435  s->vps = (HEVCVPS*) s->vps_list[s->sps->vps_id]->data;
436 
438  num = s->vps->vps_num_units_in_tick;
439  den = s->vps->vps_time_scale;
440  } else if (sps->vui.vui_timing_info_present_flag) {
441  num = sps->vui.vui_num_units_in_tick;
442  den = sps->vui.vui_time_scale;
443  }
444 
445  if (num != 0 && den != 0)
447  num, den, 1 << 30);
448 
449  return 0;
450 
451 fail:
452  pic_arrays_free(s);
453  s->sps = NULL;
454  return ret;
455 }
456 
458 {
459  GetBitContext *gb = &s->HEVClc.gb;
460  SliceHeader *sh = &s->sh;
461  int i, ret;
462 
463  // Coded parameters
465  if ((IS_IDR(s) || IS_BLA(s)) && sh->first_slice_in_pic_flag) {
466  s->seq_decode = (s->seq_decode + 1) & 0xff;
467  s->max_ra = INT_MAX;
468  if (IS_IDR(s))
470  }
471  if (s->nal_unit_type >= 16 && s->nal_unit_type <= 23)
473 
474  sh->pps_id = get_ue_golomb_long(gb);
475  if (sh->pps_id >= MAX_PPS_COUNT || !s->pps_list[sh->pps_id]) {
476  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", sh->pps_id);
477  return AVERROR_INVALIDDATA;
478  }
479  if (!sh->first_slice_in_pic_flag &&
480  s->pps != (HEVCPPS*)s->pps_list[sh->pps_id]->data) {
481  av_log(s->avctx, AV_LOG_ERROR, "PPS changed between slices.\n");
482  return AVERROR_INVALIDDATA;
483  }
484  s->pps = (HEVCPPS*)s->pps_list[sh->pps_id]->data;
485 
486  if (s->sps != (HEVCSPS*)s->sps_list[s->pps->sps_id]->data) {
487  s->sps = (HEVCSPS*)s->sps_list[s->pps->sps_id]->data;
488 
490  ret = set_sps(s, s->sps);
491  if (ret < 0)
492  return ret;
493 
494  s->seq_decode = (s->seq_decode + 1) & 0xff;
495  s->max_ra = INT_MAX;
496  }
497 
500 
502  if (!sh->first_slice_in_pic_flag) {
503  int slice_address_length;
504 
507 
508  slice_address_length = av_ceil_log2(s->sps->ctb_width *
509  s->sps->ctb_height);
510  sh->slice_segment_addr = get_bits(gb, slice_address_length);
511  if (sh->slice_segment_addr >= s->sps->ctb_width * s->sps->ctb_height) {
513  "Invalid slice segment address: %u.\n",
514  sh->slice_segment_addr);
515  return AVERROR_INVALIDDATA;
516  }
517 
518  if (!sh->dependent_slice_segment_flag) {
519  sh->slice_addr = sh->slice_segment_addr;
520  s->slice_idx++;
521  }
522  } else {
523  sh->slice_segment_addr = sh->slice_addr = 0;
524  s->slice_idx = 0;
525  s->slice_initialized = 0;
526  }
527 
528  if (!sh->dependent_slice_segment_flag) {
529  s->slice_initialized = 0;
530 
531  for (i = 0; i < s->pps->num_extra_slice_header_bits; i++)
532  skip_bits(gb, 1); // slice_reserved_undetermined_flag[]
533 
534  sh->slice_type = get_ue_golomb_long(gb);
535  if (!(sh->slice_type == I_SLICE ||
536  sh->slice_type == P_SLICE ||
537  sh->slice_type == B_SLICE)) {
538  av_log(s->avctx, AV_LOG_ERROR, "Unknown slice type: %d.\n",
539  sh->slice_type);
540  return AVERROR_INVALIDDATA;
541  }
542  if (IS_IRAP(s) && sh->slice_type != I_SLICE) {
543  av_log(s->avctx, AV_LOG_ERROR, "Inter slices in an IRAP frame.\n");
544  return AVERROR_INVALIDDATA;
545  }
546 
548  sh->pic_output_flag = get_bits1(gb);
549 
551  sh->colour_plane_id = get_bits(gb, 2);
552 
553  if (!IS_IDR(s)) {
554  int short_term_ref_pic_set_sps_flag, poc;
555 
558  if (!sh->first_slice_in_pic_flag && poc != s->poc) {
560  "Ignoring POC change between slices: %d -> %d\n", s->poc, poc);
562  return AVERROR_INVALIDDATA;
563  poc = s->poc;
564  }
565  s->poc = poc;
566 
567  short_term_ref_pic_set_sps_flag = get_bits1(gb);
568  if (!short_term_ref_pic_set_sps_flag) {
569  ret = ff_hevc_decode_short_term_rps(s, &sh->slice_rps, s->sps, 1);
570  if (ret < 0)
571  return ret;
572 
573  sh->short_term_rps = &sh->slice_rps;
574  } else {
575  int numbits, rps_idx;
576 
577  if (!s->sps->nb_st_rps) {
578  av_log(s->avctx, AV_LOG_ERROR, "No ref lists in the SPS.\n");
579  return AVERROR_INVALIDDATA;
580  }
581 
582  numbits = av_ceil_log2(s->sps->nb_st_rps);
583  rps_idx = numbits > 0 ? get_bits(gb, numbits) : 0;
584  sh->short_term_rps = &s->sps->st_rps[rps_idx];
585  }
586 
587  ret = decode_lt_rps(s, &sh->long_term_rps, gb);
588  if (ret < 0) {
589  av_log(s->avctx, AV_LOG_WARNING, "Invalid long term RPS.\n");
591  return AVERROR_INVALIDDATA;
592  }
593 
596  else
598  } else {
599  s->sh.short_term_rps = NULL;
600  s->poc = 0;
601  }
602 
603  /* 8.3.1 */
604  if (s->temporal_id == 0 &&
605  s->nal_unit_type != NAL_TRAIL_N &&
606  s->nal_unit_type != NAL_TSA_N &&
607  s->nal_unit_type != NAL_STSA_N &&
608  s->nal_unit_type != NAL_RADL_N &&
609  s->nal_unit_type != NAL_RADL_R &&
610  s->nal_unit_type != NAL_RASL_N &&
612  s->pocTid0 = s->poc;
613 
614  if (s->sps->sao_enabled) {
618  } else {
622  }
623 
624  sh->nb_refs[L0] = sh->nb_refs[L1] = 0;
625  if (sh->slice_type == P_SLICE || sh->slice_type == B_SLICE) {
626  int nb_refs;
627 
629  if (sh->slice_type == B_SLICE)
631 
632  if (get_bits1(gb)) { // num_ref_idx_active_override_flag
633  sh->nb_refs[L0] = get_ue_golomb_long(gb) + 1;
634  if (sh->slice_type == B_SLICE)
635  sh->nb_refs[L1] = get_ue_golomb_long(gb) + 1;
636  }
637  if (sh->nb_refs[L0] > MAX_REFS || sh->nb_refs[L1] > MAX_REFS) {
638  av_log(s->avctx, AV_LOG_ERROR, "Too many refs: %d/%d.\n",
639  sh->nb_refs[L0], sh->nb_refs[L1]);
640  return AVERROR_INVALIDDATA;
641  }
642 
643  sh->rpl_modification_flag[0] = 0;
644  sh->rpl_modification_flag[1] = 0;
645  nb_refs = ff_hevc_frame_nb_refs(s);
646  if (!nb_refs) {
647  av_log(s->avctx, AV_LOG_ERROR, "Zero refs for a frame with P or B slices.\n");
648  return AVERROR_INVALIDDATA;
649  }
650 
651  if (s->pps->lists_modification_present_flag && nb_refs > 1) {
652  sh->rpl_modification_flag[0] = get_bits1(gb);
653  if (sh->rpl_modification_flag[0]) {
654  for (i = 0; i < sh->nb_refs[L0]; i++)
655  sh->list_entry_lx[0][i] = get_bits(gb, av_ceil_log2(nb_refs));
656  }
657 
658  if (sh->slice_type == B_SLICE) {
659  sh->rpl_modification_flag[1] = get_bits1(gb);
660  if (sh->rpl_modification_flag[1] == 1)
661  for (i = 0; i < sh->nb_refs[L1]; i++)
662  sh->list_entry_lx[1][i] = get_bits(gb, av_ceil_log2(nb_refs));
663  }
664  }
665 
666  if (sh->slice_type == B_SLICE)
667  sh->mvd_l1_zero_flag = get_bits1(gb);
668 
670  sh->cabac_init_flag = get_bits1(gb);
671  else
672  sh->cabac_init_flag = 0;
673 
674  sh->collocated_ref_idx = 0;
676  sh->collocated_list = L0;
677  if (sh->slice_type == B_SLICE)
678  sh->collocated_list = !get_bits1(gb);
679 
680  if (sh->nb_refs[sh->collocated_list] > 1) {
682  if (sh->collocated_ref_idx >= sh->nb_refs[sh->collocated_list]) {
684  "Invalid collocated_ref_idx: %d.\n",
685  sh->collocated_ref_idx);
686  return AVERROR_INVALIDDATA;
687  }
688  }
689  }
690 
691  if ((s->pps->weighted_pred_flag && sh->slice_type == P_SLICE) ||
692  (s->pps->weighted_bipred_flag && sh->slice_type == B_SLICE)) {
693  pred_weight_table(s, gb);
694  }
695 
697  if (sh->max_num_merge_cand < 1 || sh->max_num_merge_cand > 5) {
699  "Invalid number of merging MVP candidates: %d.\n",
700  sh->max_num_merge_cand);
701  return AVERROR_INVALIDDATA;
702  }
703  }
704 
705  sh->slice_qp_delta = get_se_golomb(gb);
706 
710  } else {
711  sh->slice_cb_qp_offset = 0;
712  sh->slice_cr_qp_offset = 0;
713  }
714 
716  int deblocking_filter_override_flag = 0;
717 
719  deblocking_filter_override_flag = get_bits1(gb);
720 
721  if (deblocking_filter_override_flag) {
724  sh->beta_offset = get_se_golomb(gb) * 2;
725  sh->tc_offset = get_se_golomb(gb) * 2;
726  }
727  } else {
729  sh->beta_offset = s->pps->beta_offset;
730  sh->tc_offset = s->pps->tc_offset;
731  }
732  } else {
734  sh->beta_offset = 0;
735  sh->tc_offset = 0;
736  }
737 
743  } else {
745  }
746  } else if (!s->slice_initialized) {
747  av_log(s->avctx, AV_LOG_ERROR, "Independent slice segment missing.\n");
748  return AVERROR_INVALIDDATA;
749  }
750 
751  sh->num_entry_point_offsets = 0;
754  if (sh->num_entry_point_offsets > 0) {
755  int offset_len = get_ue_golomb_long(gb) + 1;
756 
757  for (i = 0; i < sh->num_entry_point_offsets; i++)
758  skip_bits(gb, offset_len);
759  }
760  }
761 
763  unsigned int length = get_ue_golomb_long(gb);
764  for (i = 0; i < length; i++)
765  skip_bits(gb, 8); // slice_header_extension_data_byte
766  }
767 
768  // Inferred parameters
769  sh->slice_qp = 26 + s->pps->pic_init_qp_minus26 + sh->slice_qp_delta;
770  if (sh->slice_qp > 51 ||
771  sh->slice_qp < -s->sps->qp_bd_offset) {
773  "The slice_qp %d is outside the valid range "
774  "[%d, 51].\n",
775  sh->slice_qp,
776  -s->sps->qp_bd_offset);
777  return AVERROR_INVALIDDATA;
778  }
779 
781 
783  av_log(s->avctx, AV_LOG_ERROR, "Impossible slice segment.\n");
784  return AVERROR_INVALIDDATA;
785  }
786 
788 
789  if (!s->pps->cu_qp_delta_enabled_flag)
790  s->HEVClc.qp_y = FFUMOD(s->sh.slice_qp + 52 + 2 * s->sps->qp_bd_offset,
791  52 + s->sps->qp_bd_offset) - s->sps->qp_bd_offset;
792 
793  s->slice_initialized = 1;
794 
795  return 0;
796 }
797 
798 #define CTB(tab, x, y) ((tab)[(y) * s->sps->ctb_width + (x)])
799 
800 #define SET_SAO(elem, value) \
801 do { \
802  if (!sao_merge_up_flag && !sao_merge_left_flag) \
803  sao->elem = value; \
804  else if (sao_merge_left_flag) \
805  sao->elem = CTB(s->sao, rx-1, ry).elem; \
806  else if (sao_merge_up_flag) \
807  sao->elem = CTB(s->sao, rx, ry-1).elem; \
808  else \
809  sao->elem = 0; \
810 } while (0)
811 
812 static void hls_sao_param(HEVCContext *s, int rx, int ry)
813 {
814  HEVCLocalContext *lc = &s->HEVClc;
815  int sao_merge_left_flag = 0;
816  int sao_merge_up_flag = 0;
817  int shift = s->sps->bit_depth - FFMIN(s->sps->bit_depth, 10);
818  SAOParams *sao = &CTB(s->sao, rx, ry);
819  int c_idx, i;
820 
823  if (rx > 0) {
824  if (lc->ctb_left_flag)
825  sao_merge_left_flag = ff_hevc_sao_merge_flag_decode(s);
826  }
827  if (ry > 0 && !sao_merge_left_flag) {
828  if (lc->ctb_up_flag)
829  sao_merge_up_flag = ff_hevc_sao_merge_flag_decode(s);
830  }
831  }
832 
833  for (c_idx = 0; c_idx < 3; c_idx++) {
834  if (!s->sh.slice_sample_adaptive_offset_flag[c_idx]) {
835  sao->type_idx[c_idx] = SAO_NOT_APPLIED;
836  continue;
837  }
838 
839  if (c_idx == 2) {
840  sao->type_idx[2] = sao->type_idx[1];
841  sao->eo_class[2] = sao->eo_class[1];
842  } else {
843  SET_SAO(type_idx[c_idx], ff_hevc_sao_type_idx_decode(s));
844  }
845 
846  if (sao->type_idx[c_idx] == SAO_NOT_APPLIED)
847  continue;
848 
849  for (i = 0; i < 4; i++)
850  SET_SAO(offset_abs[c_idx][i], ff_hevc_sao_offset_abs_decode(s));
851 
852  if (sao->type_idx[c_idx] == SAO_BAND) {
853  for (i = 0; i < 4; i++) {
854  if (sao->offset_abs[c_idx][i]) {
855  SET_SAO(offset_sign[c_idx][i],
857  } else {
858  sao->offset_sign[c_idx][i] = 0;
859  }
860  }
861  SET_SAO(band_position[c_idx], ff_hevc_sao_band_position_decode(s));
862  } else if (c_idx != 2) {
863  SET_SAO(eo_class[c_idx], ff_hevc_sao_eo_class_decode(s));
864  }
865 
866  // Inferred parameters
867  sao->offset_val[c_idx][0] = 0;
868  for (i = 0; i < 4; i++) {
869  sao->offset_val[c_idx][i + 1] = sao->offset_abs[c_idx][i] << shift;
870  if (sao->type_idx[c_idx] == SAO_EDGE) {
871  if (i > 1)
872  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
873  } else if (sao->offset_sign[c_idx][i]) {
874  sao->offset_val[c_idx][i + 1] = -sao->offset_val[c_idx][i + 1];
875  }
876  }
877  }
878 }
879 
880 #undef SET_SAO
881 #undef CTB
882 
883 static void hls_residual_coding(HEVCContext *s, int x0, int y0,
884  int log2_trafo_size, enum ScanType scan_idx,
885  int c_idx)
886 {
887 #define GET_COORD(offset, n) \
888  do { \
889  x_c = (scan_x_cg[offset >> 4] << 2) + scan_x_off[n]; \
890  y_c = (scan_y_cg[offset >> 4] << 2) + scan_y_off[n]; \
891  } while (0)
892  HEVCLocalContext *lc = &s->HEVClc;
893  int transform_skip_flag = 0;
894 
895  int last_significant_coeff_x, last_significant_coeff_y;
896  int last_scan_pos;
897  int n_end;
898  int num_coeff = 0;
899  int greater1_ctx = 1;
900 
901  int num_last_subset;
902  int x_cg_last_sig, y_cg_last_sig;
903 
904  const uint8_t *scan_x_cg, *scan_y_cg, *scan_x_off, *scan_y_off;
905 
906  ptrdiff_t stride = s->frame->linesize[c_idx];
907  int hshift = s->sps->hshift[c_idx];
908  int vshift = s->sps->vshift[c_idx];
909  uint8_t *dst = &s->frame->data[c_idx][(y0 >> vshift) * stride +
910  ((x0 >> hshift) << s->sps->pixel_shift)];
911  DECLARE_ALIGNED(16, int16_t, coeffs[MAX_TB_SIZE * MAX_TB_SIZE]) = { 0 };
912  DECLARE_ALIGNED(8, uint8_t, significant_coeff_group_flag[8][8]) = { { 0 } };
913 
914  int trafo_size = 1 << log2_trafo_size;
915  int i, qp, shift, add, scale, scale_m;
916  const uint8_t level_scale[] = { 40, 45, 51, 57, 64, 72 };
917  const uint8_t *scale_matrix;
918  uint8_t dc_scale;
919 
920  // Derive QP for dequant
921  if (!lc->cu.cu_transquant_bypass_flag) {
922  static const int qp_c[] = {
923  29, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37
924  };
925 
926  static const uint8_t rem6[51 + 2 * 6 + 1] = {
927  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
928  3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
929  0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
930  };
931 
932  static const uint8_t div6[51 + 2 * 6 + 1] = {
933  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3,
934  3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
935  7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10,
936  };
937  int qp_y = lc->qp_y;
938 
939  if (c_idx == 0) {
940  qp = qp_y + s->sps->qp_bd_offset;
941  } else {
942  int qp_i, offset;
943 
944  if (c_idx == 1)
945  offset = s->pps->cb_qp_offset + s->sh.slice_cb_qp_offset;
946  else
947  offset = s->pps->cr_qp_offset + s->sh.slice_cr_qp_offset;
948 
949  qp_i = av_clip_c(qp_y + offset, -s->sps->qp_bd_offset, 57);
950  if (qp_i < 30)
951  qp = qp_i;
952  else if (qp_i > 43)
953  qp = qp_i - 6;
954  else
955  qp = qp_c[qp_i - 30];
956 
957  qp += s->sps->qp_bd_offset;
958  }
959 
960  shift = s->sps->bit_depth + log2_trafo_size - 5;
961  add = 1 << (shift - 1);
962  scale = level_scale[rem6[qp]] << (div6[qp]);
963  scale_m = 16; // default when no custom scaling lists.
964  dc_scale = 16;
965 
966  if (s->sps->scaling_list_enable_flag) {
968  &s->pps->scaling_list : &s->sps->scaling_list;
969  int matrix_id = lc->cu.pred_mode != MODE_INTRA;
970 
971  if (log2_trafo_size != 5)
972  matrix_id = 3 * matrix_id + c_idx;
973 
974  scale_matrix = sl->sl[log2_trafo_size - 2][matrix_id];
975  if (log2_trafo_size >= 4)
976  dc_scale = sl->sl_dc[log2_trafo_size - 4][matrix_id];
977  }
978  }
979 
982  log2_trafo_size == 2) {
983  transform_skip_flag = ff_hevc_transform_skip_flag_decode(s, c_idx);
984  }
985 
986  last_significant_coeff_x =
987  ff_hevc_last_significant_coeff_x_prefix_decode(s, c_idx, log2_trafo_size);
988  last_significant_coeff_y =
989  ff_hevc_last_significant_coeff_y_prefix_decode(s, c_idx, log2_trafo_size);
990 
991  if (last_significant_coeff_x > 3) {
992  int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_x);
993  last_significant_coeff_x = (1 << ((last_significant_coeff_x >> 1) - 1)) *
994  (2 + (last_significant_coeff_x & 1)) +
995  suffix;
996  }
997 
998  if (last_significant_coeff_y > 3) {
999  int suffix = ff_hevc_last_significant_coeff_suffix_decode(s, last_significant_coeff_y);
1000  last_significant_coeff_y = (1 << ((last_significant_coeff_y >> 1) - 1)) *
1001  (2 + (last_significant_coeff_y & 1)) +
1002  suffix;
1003  }
1004 
1005  if (scan_idx == SCAN_VERT)
1006  FFSWAP(int, last_significant_coeff_x, last_significant_coeff_y);
1007 
1008  x_cg_last_sig = last_significant_coeff_x >> 2;
1009  y_cg_last_sig = last_significant_coeff_y >> 2;
1010 
1011  switch (scan_idx) {
1012  case SCAN_DIAG: {
1013  int last_x_c = last_significant_coeff_x & 3;
1014  int last_y_c = last_significant_coeff_y & 3;
1015 
1016  scan_x_off = ff_hevc_diag_scan4x4_x;
1017  scan_y_off = ff_hevc_diag_scan4x4_y;
1018  num_coeff = diag_scan4x4_inv[last_y_c][last_x_c];
1019  if (trafo_size == 4) {
1020  scan_x_cg = scan_1x1;
1021  scan_y_cg = scan_1x1;
1022  } else if (trafo_size == 8) {
1023  num_coeff += diag_scan2x2_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1024  scan_x_cg = diag_scan2x2_x;
1025  scan_y_cg = diag_scan2x2_y;
1026  } else if (trafo_size == 16) {
1027  num_coeff += diag_scan4x4_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1028  scan_x_cg = ff_hevc_diag_scan4x4_x;
1029  scan_y_cg = ff_hevc_diag_scan4x4_y;
1030  } else { // trafo_size == 32
1031  num_coeff += diag_scan8x8_inv[y_cg_last_sig][x_cg_last_sig] << 4;
1032  scan_x_cg = ff_hevc_diag_scan8x8_x;
1033  scan_y_cg = ff_hevc_diag_scan8x8_y;
1034  }
1035  break;
1036  }
1037  case SCAN_HORIZ:
1038  scan_x_cg = horiz_scan2x2_x;
1039  scan_y_cg = horiz_scan2x2_y;
1040  scan_x_off = horiz_scan4x4_x;
1041  scan_y_off = horiz_scan4x4_y;
1042  num_coeff = horiz_scan8x8_inv[last_significant_coeff_y][last_significant_coeff_x];
1043  break;
1044  default: //SCAN_VERT
1045  scan_x_cg = horiz_scan2x2_y;
1046  scan_y_cg = horiz_scan2x2_x;
1047  scan_x_off = horiz_scan4x4_y;
1048  scan_y_off = horiz_scan4x4_x;
1049  num_coeff = horiz_scan8x8_inv[last_significant_coeff_x][last_significant_coeff_y];
1050  break;
1051  }
1052  num_coeff++;
1053  num_last_subset = (num_coeff - 1) >> 4;
1054 
1055  for (i = num_last_subset; i >= 0; i--) {
1056  int n, m;
1057  int x_cg, y_cg, x_c, y_c;
1058  int implicit_non_zero_coeff = 0;
1059  int64_t trans_coeff_level;
1060  int prev_sig = 0;
1061  int offset = i << 4;
1062 
1063  uint8_t significant_coeff_flag_idx[16];
1064  uint8_t nb_significant_coeff_flag = 0;
1065 
1066  x_cg = scan_x_cg[i];
1067  y_cg = scan_y_cg[i];
1068 
1069  if (i < num_last_subset && i > 0) {
1070  int ctx_cg = 0;
1071  if (x_cg < (1 << (log2_trafo_size - 2)) - 1)
1072  ctx_cg += significant_coeff_group_flag[x_cg + 1][y_cg];
1073  if (y_cg < (1 << (log2_trafo_size - 2)) - 1)
1074  ctx_cg += significant_coeff_group_flag[x_cg][y_cg + 1];
1075 
1076  significant_coeff_group_flag[x_cg][y_cg] =
1078  implicit_non_zero_coeff = 1;
1079  } else {
1080  significant_coeff_group_flag[x_cg][y_cg] =
1081  ((x_cg == x_cg_last_sig && y_cg == y_cg_last_sig) ||
1082  (x_cg == 0 && y_cg == 0));
1083  }
1084 
1085  last_scan_pos = num_coeff - offset - 1;
1086 
1087  if (i == num_last_subset) {
1088  n_end = last_scan_pos - 1;
1089  significant_coeff_flag_idx[0] = last_scan_pos;
1090  nb_significant_coeff_flag = 1;
1091  } else {
1092  n_end = 15;
1093  }
1094 
1095  if (x_cg < ((1 << log2_trafo_size) - 1) >> 2)
1096  prev_sig = significant_coeff_group_flag[x_cg + 1][y_cg];
1097  if (y_cg < ((1 << log2_trafo_size) - 1) >> 2)
1098  prev_sig += significant_coeff_group_flag[x_cg][y_cg + 1] << 1;
1099 
1100  for (n = n_end; n >= 0; n--) {
1101  GET_COORD(offset, n);
1102 
1103  if (significant_coeff_group_flag[x_cg][y_cg] &&
1104  (n > 0 || implicit_non_zero_coeff == 0)) {
1105  if (ff_hevc_significant_coeff_flag_decode(s, c_idx, x_c, y_c,
1106  log2_trafo_size,
1107  scan_idx,
1108  prev_sig) == 1) {
1109  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1110  nb_significant_coeff_flag++;
1111  implicit_non_zero_coeff = 0;
1112  }
1113  } else {
1114  int last_cg = (x_c == (x_cg << 2) && y_c == (y_cg << 2));
1115  if (last_cg && implicit_non_zero_coeff && significant_coeff_group_flag[x_cg][y_cg]) {
1116  significant_coeff_flag_idx[nb_significant_coeff_flag] = n;
1117  nb_significant_coeff_flag++;
1118  }
1119  }
1120  }
1121 
1122  n_end = nb_significant_coeff_flag;
1123 
1124  if (n_end) {
1125  int first_nz_pos_in_cg = 16;
1126  int last_nz_pos_in_cg = -1;
1127  int c_rice_param = 0;
1128  int first_greater1_coeff_idx = -1;
1129  uint8_t coeff_abs_level_greater1_flag[16] = { 0 };
1130  uint16_t coeff_sign_flag;
1131  int sum_abs = 0;
1132  int sign_hidden = 0;
1133 
1134  // initialize first elem of coeff_bas_level_greater1_flag
1135  int ctx_set = (i > 0 && c_idx == 0) ? 2 : 0;
1136 
1137  if (!(i == num_last_subset) && greater1_ctx == 0)
1138  ctx_set++;
1139  greater1_ctx = 1;
1140  last_nz_pos_in_cg = significant_coeff_flag_idx[0];
1141 
1142  for (m = 0; m < (n_end > 8 ? 8 : n_end); m++) {
1143  int n_idx = significant_coeff_flag_idx[m];
1144  int inc = (ctx_set << 2) + greater1_ctx;
1145  coeff_abs_level_greater1_flag[n_idx] =
1147  if (coeff_abs_level_greater1_flag[n_idx]) {
1148  greater1_ctx = 0;
1149  } else if (greater1_ctx > 0 && greater1_ctx < 3) {
1150  greater1_ctx++;
1151  }
1152 
1153  if (coeff_abs_level_greater1_flag[n_idx] &&
1154  first_greater1_coeff_idx == -1)
1155  first_greater1_coeff_idx = n_idx;
1156  }
1157  first_nz_pos_in_cg = significant_coeff_flag_idx[n_end - 1];
1158  sign_hidden = last_nz_pos_in_cg - first_nz_pos_in_cg >= 4 &&
1160 
1161  if (first_greater1_coeff_idx != -1) {
1162  coeff_abs_level_greater1_flag[first_greater1_coeff_idx] += ff_hevc_coeff_abs_level_greater2_flag_decode(s, c_idx, ctx_set);
1163  }
1164  if (!s->pps->sign_data_hiding_flag || !sign_hidden) {
1165  coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag) << (16 - nb_significant_coeff_flag);
1166  } else {
1167  coeff_sign_flag = ff_hevc_coeff_sign_flag(s, nb_significant_coeff_flag - 1) << (16 - (nb_significant_coeff_flag - 1));
1168  }
1169 
1170  for (m = 0; m < n_end; m++) {
1171  n = significant_coeff_flag_idx[m];
1172  GET_COORD(offset, n);
1173  trans_coeff_level = 1 + coeff_abs_level_greater1_flag[n];
1174  if (trans_coeff_level == ((m < 8) ?
1175  ((n == first_greater1_coeff_idx) ? 3 : 2) : 1)) {
1176  int last_coeff_abs_level_remaining = ff_hevc_coeff_abs_level_remaining(s, trans_coeff_level, c_rice_param);
1177 
1178  trans_coeff_level += last_coeff_abs_level_remaining;
1179  if ((trans_coeff_level) > (3 * (1 << c_rice_param)))
1180  c_rice_param = FFMIN(c_rice_param + 1, 4);
1181  }
1182  if (s->pps->sign_data_hiding_flag && sign_hidden) {
1183  sum_abs += trans_coeff_level;
1184  if (n == first_nz_pos_in_cg && ((sum_abs & 1) == 1))
1185  trans_coeff_level = -trans_coeff_level;
1186  }
1187  if (coeff_sign_flag >> 15)
1188  trans_coeff_level = -trans_coeff_level;
1189  coeff_sign_flag <<= 1;
1190  if (!lc->cu.cu_transquant_bypass_flag) {
1191  if (s->sps->scaling_list_enable_flag) {
1192  if (y_c || x_c || log2_trafo_size < 4) {
1193  int pos;
1194  switch (log2_trafo_size) {
1195  case 3: pos = (y_c << 3) + x_c; break;
1196  case 4: pos = ((y_c >> 1) << 3) + (x_c >> 1); break;
1197  case 5: pos = ((y_c >> 2) << 3) + (x_c >> 2); break;
1198  default: pos = (y_c << 2) + x_c;
1199  }
1200  scale_m = scale_matrix[pos];
1201  } else {
1202  scale_m = dc_scale;
1203  }
1204  }
1205  trans_coeff_level = (trans_coeff_level * (int64_t)scale * (int64_t)scale_m + add) >> shift;
1206  if(trans_coeff_level < 0) {
1207  if((~trans_coeff_level) & 0xFffffffffff8000)
1208  trans_coeff_level = -32768;
1209  } else {
1210  if (trans_coeff_level & 0xffffffffffff8000)
1211  trans_coeff_level = 32767;
1212  }
1213  }
1214  coeffs[y_c * trafo_size + x_c] = trans_coeff_level;
1215  }
1216  }
1217  }
1218 
1219  if (lc->cu.cu_transquant_bypass_flag) {
1220  s->hevcdsp.transquant_bypass[log2_trafo_size - 2](dst, coeffs, stride);
1221  } else {
1222  if (transform_skip_flag)
1223  s->hevcdsp.transform_skip(dst, coeffs, stride);
1224  else if (lc->cu.pred_mode == MODE_INTRA && c_idx == 0 &&
1225  log2_trafo_size == 2)
1226  s->hevcdsp.transform_4x4_luma_add(dst, coeffs, stride);
1227  else
1228  s->hevcdsp.transform_add[log2_trafo_size - 2](dst, coeffs, stride);
1229  }
1230 }
1231 
1232 static int hls_transform_unit(HEVCContext *s, int x0, int y0,
1233  int xBase, int yBase, int cb_xBase, int cb_yBase,
1234  int log2_cb_size, int log2_trafo_size,
1235  int trafo_depth, int blk_idx)
1236 {
1237  HEVCLocalContext *lc = &s->HEVClc;
1238 
1239  if (lc->cu.pred_mode == MODE_INTRA) {
1240  int trafo_size = 1 << log2_trafo_size;
1241  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1242 
1243  s->hpc.intra_pred(s, x0, y0, log2_trafo_size, 0);
1244  if (log2_trafo_size > 2) {
1245  trafo_size = trafo_size << (s->sps->hshift[1] - 1);
1246  ff_hevc_set_neighbour_available(s, x0, y0, trafo_size, trafo_size);
1247  s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 1);
1248  s->hpc.intra_pred(s, x0, y0, log2_trafo_size - 1, 2);
1249  } else if (blk_idx == 3) {
1250  trafo_size = trafo_size << s->sps->hshift[1];
1251  ff_hevc_set_neighbour_available(s, xBase, yBase,
1252  trafo_size, trafo_size);
1253  s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 1);
1254  s->hpc.intra_pred(s, xBase, yBase, log2_trafo_size, 2);
1255  }
1256  }
1257 
1258  if (lc->tt.cbf_luma ||
1259  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1260  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1261  int scan_idx = SCAN_DIAG;
1262  int scan_idx_c = SCAN_DIAG;
1263 
1266  if (lc->tu.cu_qp_delta != 0)
1267  if (ff_hevc_cu_qp_delta_sign_flag(s) == 1)
1268  lc->tu.cu_qp_delta = -lc->tu.cu_qp_delta;
1269  lc->tu.is_cu_qp_delta_coded = 1;
1270 
1271  if (lc->tu.cu_qp_delta < -(26 + s->sps->qp_bd_offset / 2) ||
1272  lc->tu.cu_qp_delta > (25 + s->sps->qp_bd_offset / 2)) {
1274  "The cu_qp_delta %d is outside the valid range "
1275  "[%d, %d].\n",
1276  lc->tu.cu_qp_delta,
1277  -(26 + s->sps->qp_bd_offset / 2),
1278  (25 + s->sps->qp_bd_offset / 2));
1279  return AVERROR_INVALIDDATA;
1280  }
1281 
1282  ff_hevc_set_qPy(s, x0, y0, cb_xBase, cb_yBase, log2_cb_size);
1283  }
1284 
1285  if (lc->cu.pred_mode == MODE_INTRA && log2_trafo_size < 4) {
1286  if (lc->tu.cur_intra_pred_mode >= 6 &&
1287  lc->tu.cur_intra_pred_mode <= 14) {
1288  scan_idx = SCAN_VERT;
1289  } else if (lc->tu.cur_intra_pred_mode >= 22 &&
1290  lc->tu.cur_intra_pred_mode <= 30) {
1291  scan_idx = SCAN_HORIZ;
1292  }
1293 
1294  if (lc->pu.intra_pred_mode_c >= 6 &&
1295  lc->pu.intra_pred_mode_c <= 14) {
1296  scan_idx_c = SCAN_VERT;
1297  } else if (lc->pu.intra_pred_mode_c >= 22 &&
1298  lc->pu.intra_pred_mode_c <= 30) {
1299  scan_idx_c = SCAN_HORIZ;
1300  }
1301  }
1302 
1303  if (lc->tt.cbf_luma)
1304  hls_residual_coding(s, x0, y0, log2_trafo_size, scan_idx, 0);
1305  if (log2_trafo_size > 2) {
1306  if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0))
1307  hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 1);
1308  if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0))
1309  hls_residual_coding(s, x0, y0, log2_trafo_size - 1, scan_idx_c, 2);
1310  } else if (blk_idx == 3) {
1311  if (SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], xBase, yBase))
1312  hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 1);
1313  if (SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], xBase, yBase))
1314  hls_residual_coding(s, xBase, yBase, log2_trafo_size, scan_idx_c, 2);
1315  }
1316  }
1317  return 0;
1318 }
1319 
1320 static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
1321 {
1322  int cb_size = 1 << log2_cb_size;
1323  int log2_min_pu_size = s->sps->log2_min_pu_size;
1324 
1325  int min_pu_width = s->sps->min_pu_width;
1326  int x_end = FFMIN(x0 + cb_size, s->sps->width);
1327  int y_end = FFMIN(y0 + cb_size, s->sps->height);
1328  int i, j;
1329 
1330  for (j = (y0 >> log2_min_pu_size); j < (y_end >> log2_min_pu_size); j++)
1331  for (i = (x0 >> log2_min_pu_size); i < (x_end >> log2_min_pu_size); i++)
1332  s->is_pcm[i + j * min_pu_width] = 2;
1333 }
1334 
1335 static int hls_transform_tree(HEVCContext *s, int x0, int y0,
1336  int xBase, int yBase, int cb_xBase, int cb_yBase,
1337  int log2_cb_size, int log2_trafo_size,
1338  int trafo_depth, int blk_idx)
1339 {
1340  HEVCLocalContext *lc = &s->HEVClc;
1341  uint8_t split_transform_flag;
1342  int ret;
1343 
1344  if (trafo_depth > 0 && log2_trafo_size == 2) {
1345  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1346  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase);
1347  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1348  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase);
1349  } else {
1350  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1351  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) = 0;
1352  }
1353 
1354  if (lc->cu.intra_split_flag) {
1355  if (trafo_depth == 1)
1356  lc->tu.cur_intra_pred_mode = lc->pu.intra_pred_mode[blk_idx];
1357  } else {
1359  }
1360 
1361  lc->tt.cbf_luma = 1;
1362 
1364  lc->cu.pred_mode == MODE_INTER &&
1365  lc->cu.part_mode != PART_2Nx2N &&
1366  trafo_depth == 0;
1367 
1368  if (log2_trafo_size <= s->sps->log2_max_trafo_size &&
1369  log2_trafo_size > s->sps->log2_min_tb_size &&
1370  trafo_depth < lc->cu.max_trafo_depth &&
1371  !(lc->cu.intra_split_flag && trafo_depth == 0)) {
1372  split_transform_flag = ff_hevc_split_transform_flag_decode(s, log2_trafo_size);
1373  } else {
1374  split_transform_flag = log2_trafo_size > s->sps->log2_max_trafo_size ||
1375  (lc->cu.intra_split_flag && trafo_depth == 0) ||
1376  lc->tt.inter_split_flag;
1377  }
1378 
1379  if (log2_trafo_size > 2) {
1380  if (trafo_depth == 0 ||
1381  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth - 1], xBase, yBase)) {
1382  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) =
1383  ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1384  }
1385 
1386  if (trafo_depth == 0 ||
1387  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth - 1], xBase, yBase)) {
1388  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0) =
1389  ff_hevc_cbf_cb_cr_decode(s, trafo_depth);
1390  }
1391  }
1392 
1393  if (split_transform_flag) {
1394  int x1 = x0 + ((1 << log2_trafo_size) >> 1);
1395  int y1 = y0 + ((1 << log2_trafo_size) >> 1);
1396 
1397  ret = hls_transform_tree(s, x0, y0, x0, y0, cb_xBase, cb_yBase,
1398  log2_cb_size, log2_trafo_size - 1,
1399  trafo_depth + 1, 0);
1400  if (ret < 0)
1401  return ret;
1402  ret = hls_transform_tree(s, x1, y0, x0, y0, cb_xBase, cb_yBase,
1403  log2_cb_size, log2_trafo_size - 1,
1404  trafo_depth + 1, 1);
1405  if (ret < 0)
1406  return ret;
1407  ret = hls_transform_tree(s, x0, y1, x0, y0, cb_xBase, cb_yBase,
1408  log2_cb_size, log2_trafo_size - 1,
1409  trafo_depth + 1, 2);
1410  if (ret < 0)
1411  return ret;
1412  ret = hls_transform_tree(s, x1, y1, x0, y0, cb_xBase, cb_yBase,
1413  log2_cb_size, log2_trafo_size - 1,
1414  trafo_depth + 1, 3);
1415  if (ret < 0)
1416  return ret;
1417  } else {
1418  int min_tu_size = 1 << s->sps->log2_min_tb_size;
1419  int log2_min_tu_size = s->sps->log2_min_tb_size;
1420  int min_tu_width = s->sps->min_tb_width;
1421 
1422  if (lc->cu.pred_mode == MODE_INTRA || trafo_depth != 0 ||
1423  SAMPLE_CBF(lc->tt.cbf_cb[trafo_depth], x0, y0) ||
1424  SAMPLE_CBF(lc->tt.cbf_cr[trafo_depth], x0, y0)) {
1425  lc->tt.cbf_luma = ff_hevc_cbf_luma_decode(s, trafo_depth);
1426  }
1427 
1428  ret = hls_transform_unit(s, x0, y0, xBase, yBase, cb_xBase, cb_yBase,
1429  log2_cb_size, log2_trafo_size, trafo_depth,
1430  blk_idx);
1431  if (ret < 0)
1432  return ret;
1433  // TODO: store cbf_luma somewhere else
1434  if (lc->tt.cbf_luma) {
1435  int i, j;
1436  for (i = 0; i < (1 << log2_trafo_size); i += min_tu_size)
1437  for (j = 0; j < (1 << log2_trafo_size); j += min_tu_size) {
1438  int x_tu = (x0 + j) >> log2_min_tu_size;
1439  int y_tu = (y0 + i) >> log2_min_tu_size;
1440  s->cbf_luma[y_tu * min_tu_width + x_tu] = 1;
1441  }
1442  }
1444  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_trafo_size,
1449  set_deblocking_bypass(s, x0, y0, log2_trafo_size);
1450  }
1451  }
1452  return 0;
1453 }
1454 
1455 static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
1456 {
1457  //TODO: non-4:2:0 support
1458  HEVCLocalContext *lc = &s->HEVClc;
1459  GetBitContext gb;
1460  int cb_size = 1 << log2_cb_size;
1461  int stride0 = s->frame->linesize[0];
1462  uint8_t *dst0 = &s->frame->data[0][y0 * stride0 + (x0 << s->sps->pixel_shift)];
1463  int stride1 = s->frame->linesize[1];
1464  uint8_t *dst1 = &s->frame->data[1][(y0 >> s->sps->vshift[1]) * stride1 + ((x0 >> s->sps->hshift[1]) << s->sps->pixel_shift)];
1465  int stride2 = s->frame->linesize[2];
1466  uint8_t *dst2 = &s->frame->data[2][(y0 >> s->sps->vshift[2]) * stride2 + ((x0 >> s->sps->hshift[2]) << s->sps->pixel_shift)];
1467 
1468  int length = cb_size * cb_size * s->sps->pcm.bit_depth + ((cb_size * cb_size) >> 1) * s->sps->pcm.bit_depth_chroma;
1469  const uint8_t *pcm = skip_bytes(&s->HEVClc.cc, (length + 7) >> 3);
1470  int ret;
1471 
1472  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
1475 
1476  ret = init_get_bits(&gb, pcm, length);
1477  if (ret < 0)
1478  return ret;
1479 
1480  s->hevcdsp.put_pcm(dst0, stride0, cb_size, &gb, s->sps->pcm.bit_depth);
1481  s->hevcdsp.put_pcm(dst1, stride1, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1482  s->hevcdsp.put_pcm(dst2, stride2, cb_size / 2, &gb, s->sps->pcm.bit_depth_chroma);
1483  return 0;
1484 }
1485 
1486 static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
1487 {
1488  HEVCLocalContext *lc = &s->HEVClc;
1491 
1492  if (x)
1494  if (y)
1496 
1497  switch (x) {
1498  case 2: lc->pu.mvd.x = ff_hevc_mvd_decode(s); break;
1499  case 1: lc->pu.mvd.x = ff_hevc_mvd_sign_flag_decode(s); break;
1500  case 0: lc->pu.mvd.x = 0; break;
1501  }
1502 
1503  switch (y) {
1504  case 2: lc->pu.mvd.y = ff_hevc_mvd_decode(s); break;
1505  case 1: lc->pu.mvd.y = ff_hevc_mvd_sign_flag_decode(s); break;
1506  case 0: lc->pu.mvd.y = 0; break;
1507  }
1508 }
1509 
1523 static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride,
1524  AVFrame *ref, const Mv *mv, int x_off, int y_off,
1525  int block_w, int block_h)
1526 {
1527  HEVCLocalContext *lc = &s->HEVClc;
1528  uint8_t *src = ref->data[0];
1529  ptrdiff_t srcstride = ref->linesize[0];
1530  int pic_width = s->sps->width;
1531  int pic_height = s->sps->height;
1532 
1533  int mx = mv->x & 3;
1534  int my = mv->y & 3;
1535  int extra_left = ff_hevc_qpel_extra_before[mx];
1536  int extra_top = ff_hevc_qpel_extra_before[my];
1537 
1538  x_off += mv->x >> 2;
1539  y_off += mv->y >> 2;
1540  src += y_off * srcstride + (x_off << s->sps->pixel_shift);
1541 
1542  if (x_off < extra_left || y_off < extra_top ||
1543  x_off >= pic_width - block_w - ff_hevc_qpel_extra_after[mx] ||
1544  y_off >= pic_height - block_h - ff_hevc_qpel_extra_after[my]) {
1545  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1546  int offset = extra_top * srcstride + (extra_left << s->sps->pixel_shift);
1547  int buf_offset = extra_top *
1548  edge_emu_stride + (extra_left << s->sps->pixel_shift);
1549 
1550  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src - offset,
1551  edge_emu_stride, srcstride,
1552  block_w + ff_hevc_qpel_extra[mx],
1553  block_h + ff_hevc_qpel_extra[my],
1554  x_off - extra_left, y_off - extra_top,
1555  pic_width, pic_height);
1556  src = lc->edge_emu_buffer + buf_offset;
1557  srcstride = edge_emu_stride;
1558  }
1559  s->hevcdsp.put_hevc_qpel[my][mx](dst, dststride, src, srcstride, block_w,
1560  block_h, lc->mc_buffer);
1561 }
1562 
1577 static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
1578  ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
1579  int x_off, int y_off, int block_w, int block_h)
1580 {
1581  HEVCLocalContext *lc = &s->HEVClc;
1582  uint8_t *src1 = ref->data[1];
1583  uint8_t *src2 = ref->data[2];
1584  ptrdiff_t src1stride = ref->linesize[1];
1585  ptrdiff_t src2stride = ref->linesize[2];
1586  int pic_width = s->sps->width >> 1;
1587  int pic_height = s->sps->height >> 1;
1588 
1589  int mx = mv->x & 7;
1590  int my = mv->y & 7;
1591 
1592  x_off += mv->x >> 3;
1593  y_off += mv->y >> 3;
1594  src1 += y_off * src1stride + (x_off << s->sps->pixel_shift);
1595  src2 += y_off * src2stride + (x_off << s->sps->pixel_shift);
1596 
1597  if (x_off < EPEL_EXTRA_BEFORE || y_off < EPEL_EXTRA_AFTER ||
1598  x_off >= pic_width - block_w - EPEL_EXTRA_AFTER ||
1599  y_off >= pic_height - block_h - EPEL_EXTRA_AFTER) {
1600  const int edge_emu_stride = EDGE_EMU_BUFFER_STRIDE << s->sps->pixel_shift;
1601  int offset1 = EPEL_EXTRA_BEFORE * (src1stride + (1 << s->sps->pixel_shift));
1602  int buf_offset1 = EPEL_EXTRA_BEFORE *
1603  (edge_emu_stride + (1 << s->sps->pixel_shift));
1604  int offset2 = EPEL_EXTRA_BEFORE * (src2stride + (1 << s->sps->pixel_shift));
1605  int buf_offset2 = EPEL_EXTRA_BEFORE *
1606  (edge_emu_stride + (1 << s->sps->pixel_shift));
1607 
1608  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src1 - offset1,
1609  edge_emu_stride, src1stride,
1610  block_w + EPEL_EXTRA, block_h + EPEL_EXTRA,
1611  x_off - EPEL_EXTRA_BEFORE,
1612  y_off - EPEL_EXTRA_BEFORE,
1613  pic_width, pic_height);
1614 
1615  src1 = lc->edge_emu_buffer + buf_offset1;
1616  src1stride = edge_emu_stride;
1617  s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1618  block_w, block_h, mx, my, lc->mc_buffer);
1619 
1620  s->vdsp.emulated_edge_mc(lc->edge_emu_buffer, src2 - offset2,
1621  edge_emu_stride, src2stride,
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  src2 = lc->edge_emu_buffer + buf_offset2;
1627  src2stride = edge_emu_stride;
1628 
1629  s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1630  block_w, block_h, mx, my,
1631  lc->mc_buffer);
1632  } else {
1633  s->hevcdsp.put_hevc_epel[!!my][!!mx](dst1, dststride, src1, src1stride,
1634  block_w, block_h, mx, my,
1635  lc->mc_buffer);
1636  s->hevcdsp.put_hevc_epel[!!my][!!mx](dst2, dststride, src2, src2stride,
1637  block_w, block_h, mx, my,
1638  lc->mc_buffer);
1639  }
1640 }
1641 
1643  const Mv *mv, int y0, int height)
1644 {
1645  int y = (mv->y >> 2) + y0 + height + 9;
1646  ff_thread_await_progress(&ref->tf, y, 0);
1647 }
1648 
1649 static void hls_prediction_unit(HEVCContext *s, int x0, int y0,
1650  int nPbW, int nPbH,
1651  int log2_cb_size, int partIdx)
1652 {
1653 #define POS(c_idx, x, y) \
1654  &s->frame->data[c_idx][((y) >> s->sps->vshift[c_idx]) * s->frame->linesize[c_idx] + \
1655  (((x) >> s->sps->hshift[c_idx]) << s->sps->pixel_shift)]
1656  HEVCLocalContext *lc = &s->HEVClc;
1657  int merge_idx = 0;
1658  struct MvField current_mv = {{{ 0 }}};
1659 
1660  int min_pu_width = s->sps->min_pu_width;
1661 
1662  MvField *tab_mvf = s->ref->tab_mvf;
1663  RefPicList *refPicList = s->ref->refPicList;
1664  HEVCFrame *ref0, *ref1;
1665 
1666  int tmpstride = MAX_PB_SIZE;
1667 
1668  uint8_t *dst0 = POS(0, x0, y0);
1669  uint8_t *dst1 = POS(1, x0, y0);
1670  uint8_t *dst2 = POS(2, x0, y0);
1671  int log2_min_cb_size = s->sps->log2_min_cb_size;
1672  int min_cb_width = s->sps->min_cb_width;
1673  int x_cb = x0 >> log2_min_cb_size;
1674  int y_cb = y0 >> log2_min_cb_size;
1675  int ref_idx[2];
1676  int mvp_flag[2];
1677  int x_pu, y_pu;
1678  int i, j;
1679 
1680  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
1681  if (s->sh.max_num_merge_cand > 1)
1682  merge_idx = ff_hevc_merge_idx_decode(s);
1683  else
1684  merge_idx = 0;
1685 
1686  ff_hevc_luma_mv_merge_mode(s, x0, y0,
1687  1 << log2_cb_size,
1688  1 << log2_cb_size,
1689  log2_cb_size, partIdx,
1690  merge_idx, &current_mv);
1691  x_pu = x0 >> s->sps->log2_min_pu_size;
1692  y_pu = y0 >> s->sps->log2_min_pu_size;
1693 
1694  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1695  for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1696  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1697  } else { /* MODE_INTER */
1699  if (lc->pu.merge_flag) {
1700  if (s->sh.max_num_merge_cand > 1)
1701  merge_idx = ff_hevc_merge_idx_decode(s);
1702  else
1703  merge_idx = 0;
1704 
1705  ff_hevc_luma_mv_merge_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1706  partIdx, merge_idx, &current_mv);
1707  x_pu = x0 >> s->sps->log2_min_pu_size;
1708  y_pu = y0 >> s->sps->log2_min_pu_size;
1709 
1710  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1711  for (j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1712  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1713  } else {
1714  enum InterPredIdc inter_pred_idc = PRED_L0;
1715  ff_hevc_set_neighbour_available(s, x0, y0, nPbW, nPbH);
1716  if (s->sh.slice_type == B_SLICE)
1717  inter_pred_idc = ff_hevc_inter_pred_idc_decode(s, nPbW, nPbH);
1718 
1719  if (inter_pred_idc != PRED_L1) {
1720  if (s->sh.nb_refs[L0]) {
1721  ref_idx[0] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L0]);
1722  current_mv.ref_idx[0] = ref_idx[0];
1723  }
1724  current_mv.pred_flag[0] = 1;
1725  hls_mvd_coding(s, x0, y0, 0);
1726  mvp_flag[0] = ff_hevc_mvp_lx_flag_decode(s);
1727  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1728  partIdx, merge_idx, &current_mv,
1729  mvp_flag[0], 0);
1730  current_mv.mv[0].x += lc->pu.mvd.x;
1731  current_mv.mv[0].y += lc->pu.mvd.y;
1732  }
1733 
1734  if (inter_pred_idc != PRED_L0) {
1735  if (s->sh.nb_refs[L1]) {
1736  ref_idx[1] = ff_hevc_ref_idx_lx_decode(s, s->sh.nb_refs[L1]);
1737  current_mv.ref_idx[1] = ref_idx[1];
1738  }
1739 
1740  if (s->sh.mvd_l1_zero_flag == 1 && inter_pred_idc == PRED_BI) {
1741  lc->pu.mvd.x = 0;
1742  lc->pu.mvd.y = 0;
1743  } else {
1744  hls_mvd_coding(s, x0, y0, 1);
1745  }
1746 
1747  current_mv.pred_flag[1] = 1;
1748  mvp_flag[1] = ff_hevc_mvp_lx_flag_decode(s);
1749  ff_hevc_luma_mv_mvp_mode(s, x0, y0, nPbW, nPbH, log2_cb_size,
1750  partIdx, merge_idx, &current_mv,
1751  mvp_flag[1], 1);
1752  current_mv.mv[1].x += lc->pu.mvd.x;
1753  current_mv.mv[1].y += lc->pu.mvd.y;
1754  }
1755 
1756  x_pu = x0 >> s->sps->log2_min_pu_size;
1757  y_pu = y0 >> s->sps->log2_min_pu_size;
1758 
1759  for (i = 0; i < nPbW >> s->sps->log2_min_pu_size; i++)
1760  for(j = 0; j < nPbH >> s->sps->log2_min_pu_size; j++)
1761  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i] = current_mv;
1762  }
1763  }
1764 
1765  if (current_mv.pred_flag[0]) {
1766  ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1767  if (!ref0)
1768  return;
1769  hevc_await_progress(s, ref0, &current_mv.mv[0], y0, nPbH);
1770  }
1771  if (current_mv.pred_flag[1]) {
1772  ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1773  if (!ref1)
1774  return;
1775  hevc_await_progress(s, ref1, &current_mv.mv[1], y0, nPbH);
1776  }
1777 
1778  if (current_mv.pred_flag[0] && !current_mv.pred_flag[1]) {
1779  DECLARE_ALIGNED(16, int16_t, tmp[MAX_PB_SIZE * MAX_PB_SIZE]);
1780  DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1781 
1782  luma_mc(s, tmp, tmpstride, ref0->frame,
1783  &current_mv.mv[0], x0, y0, nPbW, nPbH);
1784 
1785  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1786  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1788  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1789  s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1790  dst0, s->frame->linesize[0], tmp,
1791  tmpstride, nPbW, nPbH);
1792  } else {
1793  s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1794  }
1795  chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1796  &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1797 
1798  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1799  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1801  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1802  s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1803  dst1, s->frame->linesize[1], tmp, tmpstride,
1804  nPbW / 2, nPbH / 2);
1806  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1807  s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1808  dst2, s->frame->linesize[2], tmp2, tmpstride,
1809  nPbW / 2, nPbH / 2);
1810  } else {
1811  s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1812  s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1813  }
1814  } else if (!current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1815  DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1816  DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1817 
1818  if (!ref1)
1819  return;
1820 
1821  luma_mc(s, tmp, tmpstride, ref1->frame,
1822  &current_mv.mv[1], x0, y0, nPbW, nPbH);
1823 
1824  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1825  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1827  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1828  s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1829  dst0, s->frame->linesize[0], tmp, tmpstride,
1830  nPbW, nPbH);
1831  } else {
1832  s->hevcdsp.put_unweighted_pred(dst0, s->frame->linesize[0], tmp, tmpstride, nPbW, nPbH);
1833  }
1834 
1835  chroma_mc(s, tmp, tmp2, tmpstride, ref1->frame,
1836  &current_mv.mv[1], x0/2, y0/2, nPbW/2, nPbH/2);
1837 
1838  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1839  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1841  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1842  s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1843  dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1845  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1846  s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1847  dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1848  } else {
1849  s->hevcdsp.put_unweighted_pred(dst1, s->frame->linesize[1], tmp, tmpstride, nPbW/2, nPbH/2);
1850  s->hevcdsp.put_unweighted_pred(dst2, s->frame->linesize[2], tmp2, tmpstride, nPbW/2, nPbH/2);
1851  }
1852  } else if (current_mv.pred_flag[0] && current_mv.pred_flag[1]) {
1853  DECLARE_ALIGNED(16, int16_t, tmp [MAX_PB_SIZE * MAX_PB_SIZE]);
1854  DECLARE_ALIGNED(16, int16_t, tmp2[MAX_PB_SIZE * MAX_PB_SIZE]);
1855  DECLARE_ALIGNED(16, int16_t, tmp3[MAX_PB_SIZE * MAX_PB_SIZE]);
1856  DECLARE_ALIGNED(16, int16_t, tmp4[MAX_PB_SIZE * MAX_PB_SIZE]);
1857  HEVCFrame *ref0 = refPicList[0].ref[current_mv.ref_idx[0]];
1858  HEVCFrame *ref1 = refPicList[1].ref[current_mv.ref_idx[1]];
1859 
1860  if (!ref0 || !ref1)
1861  return;
1862 
1863  luma_mc(s, tmp, tmpstride, ref0->frame,
1864  &current_mv.mv[0], x0, y0, nPbW, nPbH);
1865  luma_mc(s, tmp2, tmpstride, ref1->frame,
1866  &current_mv.mv[1], x0, y0, nPbW, nPbH);
1867 
1868  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1869  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1871  s->sh.luma_weight_l0[current_mv.ref_idx[0]],
1872  s->sh.luma_weight_l1[current_mv.ref_idx[1]],
1873  s->sh.luma_offset_l0[current_mv.ref_idx[0]],
1874  s->sh.luma_offset_l1[current_mv.ref_idx[1]],
1875  dst0, s->frame->linesize[0],
1876  tmp, tmp2, tmpstride, nPbW, nPbH);
1877  } else {
1878  s->hevcdsp.put_weighted_pred_avg(dst0, s->frame->linesize[0],
1879  tmp, tmp2, tmpstride, nPbW, nPbH);
1880  }
1881 
1882  chroma_mc(s, tmp, tmp2, tmpstride, ref0->frame,
1883  &current_mv.mv[0], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1884  chroma_mc(s, tmp3, tmp4, tmpstride, ref1->frame,
1885  &current_mv.mv[1], x0 / 2, y0 / 2, nPbW / 2, nPbH / 2);
1886 
1887  if ((s->sh.slice_type == P_SLICE && s->pps->weighted_pred_flag) ||
1888  (s->sh.slice_type == B_SLICE && s->pps->weighted_bipred_flag)) {
1890  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][0],
1891  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][0],
1892  s->sh.chroma_offset_l0[current_mv.ref_idx[0]][0],
1893  s->sh.chroma_offset_l1[current_mv.ref_idx[1]][0],
1894  dst1, s->frame->linesize[1], tmp, tmp3,
1895  tmpstride, nPbW / 2, nPbH / 2);
1897  s->sh.chroma_weight_l0[current_mv.ref_idx[0]][1],
1898  s->sh.chroma_weight_l1[current_mv.ref_idx[1]][1],
1899  s->sh.chroma_offset_l0[current_mv.ref_idx[0]][1],
1900  s->sh.chroma_offset_l1[current_mv.ref_idx[1]][1],
1901  dst2, s->frame->linesize[2], tmp2, tmp4,
1902  tmpstride, nPbW / 2, nPbH / 2);
1903  } else {
1904  s->hevcdsp.put_weighted_pred_avg(dst1, s->frame->linesize[1], tmp, tmp3, tmpstride, nPbW/2, nPbH/2);
1905  s->hevcdsp.put_weighted_pred_avg(dst2, s->frame->linesize[2], tmp2, tmp4, tmpstride, nPbW/2, nPbH/2);
1906  }
1907  }
1908 }
1909 
1913 static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size,
1914  int prev_intra_luma_pred_flag)
1915 {
1916  HEVCLocalContext *lc = &s->HEVClc;
1917  int x_pu = x0 >> s->sps->log2_min_pu_size;
1918  int y_pu = y0 >> s->sps->log2_min_pu_size;
1919  int min_pu_width = s->sps->min_pu_width;
1920  int size_in_pus = pu_size >> s->sps->log2_min_pu_size;
1921  int x0b = x0 & ((1 << s->sps->log2_ctb_size) - 1);
1922  int y0b = y0 & ((1 << s->sps->log2_ctb_size) - 1);
1923 
1924  int cand_up = (lc->ctb_up_flag || y0b) ?
1925  s->tab_ipm[(y_pu - 1) * min_pu_width + x_pu] : INTRA_DC;
1926  int cand_left = (lc->ctb_left_flag || x0b) ?
1927  s->tab_ipm[y_pu * min_pu_width + x_pu - 1] : INTRA_DC;
1928 
1929  int y_ctb = (y0 >> (s->sps->log2_ctb_size)) << (s->sps->log2_ctb_size);
1930 
1931  MvField *tab_mvf = s->ref->tab_mvf;
1932  int intra_pred_mode;
1933  int candidate[3];
1934  int i, j;
1935 
1936  // intra_pred_mode prediction does not cross vertical CTB boundaries
1937  if ((y0 - 1) < y_ctb)
1938  cand_up = INTRA_DC;
1939 
1940  if (cand_left == cand_up) {
1941  if (cand_left < 2) {
1942  candidate[0] = INTRA_PLANAR;
1943  candidate[1] = INTRA_DC;
1944  candidate[2] = INTRA_ANGULAR_26;
1945  } else {
1946  candidate[0] = cand_left;
1947  candidate[1] = 2 + ((cand_left - 2 - 1 + 32) & 31);
1948  candidate[2] = 2 + ((cand_left - 2 + 1) & 31);
1949  }
1950  } else {
1951  candidate[0] = cand_left;
1952  candidate[1] = cand_up;
1953  if (candidate[0] != INTRA_PLANAR && candidate[1] != INTRA_PLANAR) {
1954  candidate[2] = INTRA_PLANAR;
1955  } else if (candidate[0] != INTRA_DC && candidate[1] != INTRA_DC) {
1956  candidate[2] = INTRA_DC;
1957  } else {
1958  candidate[2] = INTRA_ANGULAR_26;
1959  }
1960  }
1961 
1962  if (prev_intra_luma_pred_flag) {
1963  intra_pred_mode = candidate[lc->pu.mpm_idx];
1964  } else {
1965  if (candidate[0] > candidate[1])
1966  FFSWAP(uint8_t, candidate[0], candidate[1]);
1967  if (candidate[0] > candidate[2])
1968  FFSWAP(uint8_t, candidate[0], candidate[2]);
1969  if (candidate[1] > candidate[2])
1970  FFSWAP(uint8_t, candidate[1], candidate[2]);
1971 
1972  intra_pred_mode = lc->pu.rem_intra_luma_pred_mode;
1973  for (i = 0; i < 3; i++)
1974  if (intra_pred_mode >= candidate[i])
1975  intra_pred_mode++;
1976  }
1977 
1978  /* write the intra prediction units into the mv array */
1979  if (!size_in_pus)
1980  size_in_pus = 1;
1981  for (i = 0; i < size_in_pus; i++) {
1982  memset(&s->tab_ipm[(y_pu + i) * min_pu_width + x_pu],
1983  intra_pred_mode, size_in_pus);
1984 
1985  for (j = 0; j < size_in_pus; j++) {
1986  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].is_intra = 1;
1987  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[0] = 0;
1988  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].pred_flag[1] = 0;
1989  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[0] = 0;
1990  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].ref_idx[1] = 0;
1991  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].x = 0;
1992  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[0].y = 0;
1993  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].x = 0;
1994  tab_mvf[(y_pu + j) * min_pu_width + x_pu + i].mv[1].y = 0;
1995  }
1996  }
1997 
1998  return intra_pred_mode;
1999 }
2000 
2001 static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0,
2002  int log2_cb_size, int ct_depth)
2003 {
2004  int length = (1 << log2_cb_size) >> s->sps->log2_min_cb_size;
2005  int x_cb = x0 >> s->sps->log2_min_cb_size;
2006  int y_cb = y0 >> s->sps->log2_min_cb_size;
2007  int y;
2008 
2009  for (y = 0; y < length; y++)
2010  memset(&s->tab_ct_depth[(y_cb + y) * s->sps->min_cb_width + x_cb],
2011  ct_depth, length);
2012 }
2013 
2014 static void intra_prediction_unit(HEVCContext *s, int x0, int y0,
2015  int log2_cb_size)
2016 {
2017  HEVCLocalContext *lc = &s->HEVClc;
2018  static const uint8_t intra_chroma_table[4] = { 0, 26, 10, 1 };
2019  uint8_t prev_intra_luma_pred_flag[4];
2020  int split = lc->cu.part_mode == PART_NxN;
2021  int pb_size = (1 << log2_cb_size) >> split;
2022  int side = split + 1;
2023  int chroma_mode;
2024  int i, j;
2025 
2026  for (i = 0; i < side; i++)
2027  for (j = 0; j < side; j++)
2028  prev_intra_luma_pred_flag[2 * i + j] = ff_hevc_prev_intra_luma_pred_flag_decode(s);
2029 
2030  for (i = 0; i < side; i++) {
2031  for (j = 0; j < side; j++) {
2032  if (prev_intra_luma_pred_flag[2 * i + j])
2034  else
2036 
2037  lc->pu.intra_pred_mode[2 * i + j] =
2038  luma_intra_pred_mode(s, x0 + pb_size * j, y0 + pb_size * i, pb_size,
2039  prev_intra_luma_pred_flag[2 * i + j]);
2040  }
2041  }
2042 
2043  chroma_mode = ff_hevc_intra_chroma_pred_mode_decode(s);
2044  if (chroma_mode != 4) {
2045  if (lc->pu.intra_pred_mode[0] == intra_chroma_table[chroma_mode])
2046  lc->pu.intra_pred_mode_c = 34;
2047  else
2048  lc->pu.intra_pred_mode_c = intra_chroma_table[chroma_mode];
2049  } else {
2050  lc->pu.intra_pred_mode_c = lc->pu.intra_pred_mode[0];
2051  }
2052 }
2053 
2055  int x0, int y0,
2056  int log2_cb_size)
2057 {
2058  HEVCLocalContext *lc = &s->HEVClc;
2059  int pb_size = 1 << log2_cb_size;
2060  int size_in_pus = pb_size >> s->sps->log2_min_pu_size;
2061  int min_pu_width = s->sps->min_pu_width;
2062  MvField *tab_mvf = s->ref->tab_mvf;
2063  int x_pu = x0 >> s->sps->log2_min_pu_size;
2064  int y_pu = y0 >> s->sps->log2_min_pu_size;
2065  int j, k;
2066 
2067  if (size_in_pus == 0)
2068  size_in_pus = 1;
2069  for (j = 0; j < size_in_pus; j++) {
2070  memset(&s->tab_ipm[(y_pu + j) * min_pu_width + x_pu], INTRA_DC, size_in_pus);
2071  for (k = 0; k < size_in_pus; k++)
2072  tab_mvf[(y_pu + j) * min_pu_width + x_pu + k].is_intra = lc->cu.pred_mode == MODE_INTRA;
2073  }
2074 }
2075 
2076 static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
2077 {
2078  int cb_size = 1 << log2_cb_size;
2079  HEVCLocalContext *lc = &s->HEVClc;
2080  int log2_min_cb_size = s->sps->log2_min_cb_size;
2081  int length = cb_size >> log2_min_cb_size;
2082  int min_cb_width = s->sps->min_cb_width;
2083  int x_cb = x0 >> log2_min_cb_size;
2084  int y_cb = y0 >> log2_min_cb_size;
2085  int x, y, ret;
2086 
2087  lc->cu.x = x0;
2088  lc->cu.y = y0;
2089  lc->cu.rqt_root_cbf = 1;
2090  lc->cu.pred_mode = MODE_INTRA;
2091  lc->cu.part_mode = PART_2Nx2N;
2092  lc->cu.intra_split_flag = 0;
2093  lc->cu.pcm_flag = 0;
2094 
2095  SAMPLE_CTB(s->skip_flag, x_cb, y_cb) = 0;
2096  for (x = 0; x < 4; x++)
2097  lc->pu.intra_pred_mode[x] = 1;
2100  if (lc->cu.cu_transquant_bypass_flag)
2101  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2102  } else
2103  lc->cu.cu_transquant_bypass_flag = 0;
2104 
2105  if (s->sh.slice_type != I_SLICE) {
2106  uint8_t skip_flag = ff_hevc_skip_flag_decode(s, x0, y0, x_cb, y_cb);
2107 
2108  lc->cu.pred_mode = MODE_SKIP;
2109  x = y_cb * min_cb_width + x_cb;
2110  for (y = 0; y < length; y++) {
2111  memset(&s->skip_flag[x], skip_flag, length);
2112  x += min_cb_width;
2113  }
2114  lc->cu.pred_mode = skip_flag ? MODE_SKIP : MODE_INTER;
2115  }
2116 
2117  if (SAMPLE_CTB(s->skip_flag, x_cb, y_cb)) {
2118  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2119  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2120 
2122  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2125  } else {
2126  if (s->sh.slice_type != I_SLICE)
2128  if (lc->cu.pred_mode != MODE_INTRA ||
2129  log2_cb_size == s->sps->log2_min_cb_size) {
2130  lc->cu.part_mode = ff_hevc_part_mode_decode(s, log2_cb_size);
2131  lc->cu.intra_split_flag = lc->cu.part_mode == PART_NxN &&
2132  lc->cu.pred_mode == MODE_INTRA;
2133  }
2134 
2135  if (lc->cu.pred_mode == MODE_INTRA) {
2136  if (lc->cu.part_mode == PART_2Nx2N && s->sps->pcm_enabled_flag &&
2137  log2_cb_size >= s->sps->pcm.log2_min_pcm_cb_size &&
2138  log2_cb_size <= s->sps->pcm.log2_max_pcm_cb_size) {
2140  }
2141  if (lc->cu.pcm_flag) {
2142  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2143  ret = hls_pcm_sample(s, x0, y0, log2_cb_size);
2145  set_deblocking_bypass(s, x0, y0, log2_cb_size);
2146 
2147  if (ret < 0)
2148  return ret;
2149  } else {
2150  intra_prediction_unit(s, x0, y0, log2_cb_size);
2151  }
2152  } else {
2153  intra_prediction_unit_default_value(s, x0, y0, log2_cb_size);
2154  switch (lc->cu.part_mode) {
2155  case PART_2Nx2N:
2156  hls_prediction_unit(s, x0, y0, cb_size, cb_size, log2_cb_size, 0);
2157  break;
2158  case PART_2NxN:
2159  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 2, log2_cb_size, 0);
2160  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size, cb_size / 2, log2_cb_size, 1);
2161  break;
2162  case PART_Nx2N:
2163  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size, log2_cb_size, 0);
2164  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size, log2_cb_size, 1);
2165  break;
2166  case PART_2NxnU:
2167  hls_prediction_unit(s, x0, y0, cb_size, cb_size / 4, log2_cb_size, 0);
2168  hls_prediction_unit(s, x0, y0 + cb_size / 4, cb_size, cb_size * 3 / 4, log2_cb_size, 1);
2169  break;
2170  case PART_2NxnD:
2171  hls_prediction_unit(s, x0, y0, cb_size, cb_size * 3 / 4, log2_cb_size, 0);
2172  hls_prediction_unit(s, x0, y0 + cb_size * 3 / 4, cb_size, cb_size / 4, log2_cb_size, 1);
2173  break;
2174  case PART_nLx2N:
2175  hls_prediction_unit(s, x0, y0, cb_size / 4, cb_size, log2_cb_size, 0);
2176  hls_prediction_unit(s, x0 + cb_size / 4, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 1);
2177  break;
2178  case PART_nRx2N:
2179  hls_prediction_unit(s, x0, y0, cb_size * 3 / 4, cb_size, log2_cb_size, 0);
2180  hls_prediction_unit(s, x0 + cb_size * 3 / 4, y0, cb_size / 4, cb_size, log2_cb_size, 1);
2181  break;
2182  case PART_NxN:
2183  hls_prediction_unit(s, x0, y0, cb_size / 2, cb_size / 2, log2_cb_size, 0);
2184  hls_prediction_unit(s, x0 + cb_size / 2, y0, cb_size / 2, cb_size / 2, log2_cb_size, 1);
2185  hls_prediction_unit(s, x0, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 2);
2186  hls_prediction_unit(s, x0 + cb_size / 2, y0 + cb_size / 2, cb_size / 2, cb_size / 2, log2_cb_size, 3);
2187  break;
2188  }
2189  }
2190 
2191  if (!lc->cu.pcm_flag) {
2192  if (lc->cu.pred_mode != MODE_INTRA &&
2193  !(lc->cu.part_mode == PART_2Nx2N && lc->pu.merge_flag)) {
2195  }
2196  if (lc->cu.rqt_root_cbf) {
2197  lc->cu.max_trafo_depth = lc->cu.pred_mode == MODE_INTRA ?
2200  ret = hls_transform_tree(s, x0, y0, x0, y0, x0, y0,
2201  log2_cb_size,
2202  log2_cb_size, 0, 0);
2203  if (ret < 0)
2204  return ret;
2205  } else {
2207  ff_hevc_deblocking_boundary_strengths(s, x0, y0, log2_cb_size,
2210  }
2211  }
2212  }
2213 
2215  ff_hevc_set_qPy(s, x0, y0, x0, y0, log2_cb_size);
2216 
2217  x = y_cb * min_cb_width + x_cb;
2218  for (y = 0; y < length; y++) {
2219  memset(&s->qp_y_tab[x], lc->qp_y, length);
2220  x += min_cb_width;
2221  }
2222 
2223  set_ct_depth(s, x0, y0, log2_cb_size, lc->ct.depth);
2224 
2225  return 0;
2226 }
2227 
2228 static int hls_coding_quadtree(HEVCContext *s, int x0, int y0,
2229  int log2_cb_size, int cb_depth)
2230 {
2231  HEVCLocalContext *lc = &s->HEVClc;
2232  const int cb_size = 1 << log2_cb_size;
2233 
2234  lc->ct.depth = cb_depth;
2235  if (x0 + cb_size <= s->sps->width &&
2236  y0 + cb_size <= s->sps->height &&
2237  log2_cb_size > s->sps->log2_min_cb_size) {
2238  SAMPLE(s->split_cu_flag, x0, y0) =
2239  ff_hevc_split_coding_unit_flag_decode(s, cb_depth, x0, y0);
2240  } else {
2241  SAMPLE(s->split_cu_flag, x0, y0) =
2242  (log2_cb_size > s->sps->log2_min_cb_size);
2243  }
2244  if (s->pps->cu_qp_delta_enabled_flag &&
2245  log2_cb_size >= s->sps->log2_ctb_size - s->pps->diff_cu_qp_delta_depth) {
2246  lc->tu.is_cu_qp_delta_coded = 0;
2247  lc->tu.cu_qp_delta = 0;
2248  }
2249 
2250  if (SAMPLE(s->split_cu_flag, x0, y0)) {
2251  const int cb_size_split = cb_size >> 1;
2252  const int x1 = x0 + cb_size_split;
2253  const int y1 = y0 + cb_size_split;
2254 
2255  log2_cb_size--;
2256  cb_depth++;
2257 
2258 #define SUBDIVIDE(x, y) \
2259 do { \
2260  if (x < s->sps->width && y < s->sps->height) { \
2261  int ret = hls_coding_quadtree(s, x, y, log2_cb_size, cb_depth);\
2262  if (ret < 0) \
2263  return ret; \
2264  } \
2265 } while (0)
2266 
2267  SUBDIVIDE(x0, y0);
2268  SUBDIVIDE(x1, y0);
2269  SUBDIVIDE(x0, y1);
2270  SUBDIVIDE(x1, y1);
2271  } else {
2272  int ret = hls_coding_unit(s, x0, y0, log2_cb_size);
2273  if (ret < 0)
2274  return ret;
2275  }
2276 
2277  return 0;
2278 }
2279 
2280 static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb,
2281  int ctb_addr_ts)
2282 {
2283  HEVCLocalContext *lc = &s->HEVClc;
2284  int ctb_size = 1 << s->sps->log2_ctb_size;
2285  int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2286  int ctb_addr_in_slice = ctb_addr_rs - s->sh.slice_addr;
2287 
2288  int tile_left_boundary, tile_up_boundary;
2289  int slice_left_boundary, slice_up_boundary;
2290 
2291  s->tab_slice_address[ctb_addr_rs] = s->sh.slice_addr;
2292 
2294  if (x_ctb == 0 && (y_ctb & (ctb_size - 1)) == 0)
2295  lc->first_qp_group = 1;
2296  lc->end_of_tiles_x = s->sps->width;
2297  } else if (s->pps->tiles_enabled_flag) {
2298  if (ctb_addr_ts && s->pps->tile_id[ctb_addr_ts] != s->pps->tile_id[ctb_addr_ts - 1]) {
2299  int idxX = s->pps->col_idxX[x_ctb >> s->sps->log2_ctb_size];
2300  lc->start_of_tiles_x = x_ctb;
2301  lc->end_of_tiles_x = x_ctb + (s->pps->column_width[idxX] << s->sps->log2_ctb_size);
2302  lc->first_qp_group = 1;
2303  }
2304  } else {
2305  lc->end_of_tiles_x = s->sps->width;
2306  }
2307 
2308  lc->end_of_tiles_y = FFMIN(y_ctb + ctb_size, s->sps->height);
2309 
2310  if (s->pps->tiles_enabled_flag) {
2311  tile_left_boundary = x_ctb > 0 &&
2312  s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - 1]];
2313  slice_left_boundary = x_ctb > 0 &&
2314  s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - 1];
2315  tile_up_boundary = y_ctb > 0 &&
2316  s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs - s->sps->ctb_width]];
2317  slice_up_boundary = y_ctb > 0 &&
2318  s->tab_slice_address[ctb_addr_rs] == s->tab_slice_address[ctb_addr_rs - s->sps->ctb_width];
2319  } else {
2320  tile_left_boundary =
2321  tile_up_boundary = 1;
2322  slice_left_boundary = ctb_addr_in_slice > 0;
2323  slice_up_boundary = ctb_addr_in_slice >= s->sps->ctb_width;
2324  }
2325  lc->slice_or_tiles_left_boundary = (!slice_left_boundary) + (!tile_left_boundary << 1);
2326  lc->slice_or_tiles_up_boundary = (!slice_up_boundary + (!tile_up_boundary << 1));
2327  lc->ctb_left_flag = ((x_ctb > 0) && (ctb_addr_in_slice > 0) && tile_left_boundary);
2328  lc->ctb_up_flag = ((y_ctb > 0) && (ctb_addr_in_slice >= s->sps->ctb_width) && tile_up_boundary);
2329  lc->ctb_up_right_flag = ((y_ctb > 0) && (ctb_addr_in_slice+1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs+1 - s->sps->ctb_width]]));
2330  lc->ctb_up_left_flag = ((x_ctb > 0) && (y_ctb > 0) && (ctb_addr_in_slice-1 >= s->sps->ctb_width) && (s->pps->tile_id[ctb_addr_ts] == s->pps->tile_id[s->pps->ctb_addr_rs_to_ts[ctb_addr_rs-1 - s->sps->ctb_width]]));
2331 }
2332 
2334 {
2335  int ctb_size = 1 << s->sps->log2_ctb_size;
2336  int more_data = 1;
2337  int x_ctb = 0;
2338  int y_ctb = 0;
2339  int ctb_addr_ts = s->pps->ctb_addr_rs_to_ts[s->sh.slice_ctb_addr_rs];
2340  int ret;
2341 
2342  while (more_data && ctb_addr_ts < s->sps->ctb_size) {
2343  int ctb_addr_rs = s->pps->ctb_addr_ts_to_rs[ctb_addr_ts];
2344 
2345  x_ctb = (ctb_addr_rs % ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2346  y_ctb = (ctb_addr_rs / ((s->sps->width + ctb_size - 1) >> s->sps->log2_ctb_size)) << s->sps->log2_ctb_size;
2347  hls_decode_neighbour(s, x_ctb, y_ctb, ctb_addr_ts);
2348 
2349  ff_hevc_cabac_init(s, ctb_addr_ts);
2350 
2351  hls_sao_param(s, x_ctb >> s->sps->log2_ctb_size, y_ctb >> s->sps->log2_ctb_size);
2352 
2353  s->deblock[ctb_addr_rs].beta_offset = s->sh.beta_offset;
2354  s->deblock[ctb_addr_rs].tc_offset = s->sh.tc_offset;
2356 
2357  ret = hls_coding_quadtree(s, x_ctb, y_ctb, s->sps->log2_ctb_size, 0);
2358  if (ret < 0)
2359  return ret;
2360  more_data = !ff_hevc_end_of_slice_flag_decode(s);
2361 
2362  ctb_addr_ts++;
2363  ff_hevc_save_states(s, ctb_addr_ts);
2364  ff_hevc_hls_filters(s, x_ctb, y_ctb, ctb_size);
2365  }
2366 
2367  if (x_ctb + ctb_size >= s->sps->width &&
2368  y_ctb + ctb_size >= s->sps->height)
2369  ff_hevc_hls_filter(s, x_ctb, y_ctb);
2370 
2371  return ctb_addr_ts;
2372 }
2373 
2379 {
2380  GetBitContext *gb = &s->HEVClc.gb;
2381  int nuh_layer_id;
2382 
2383  if (get_bits1(gb) != 0)
2384  return AVERROR_INVALIDDATA;
2385 
2386  s->nal_unit_type = get_bits(gb, 6);
2387 
2388  nuh_layer_id = get_bits(gb, 6);
2389  s->temporal_id = get_bits(gb, 3) - 1;
2390  if (s->temporal_id < 0)
2391  return AVERROR_INVALIDDATA;
2392 
2394  "nal_unit_type: %d, nuh_layer_id: %dtemporal_id: %d\n",
2395  s->nal_unit_type, nuh_layer_id, s->temporal_id);
2396 
2397  return nuh_layer_id == 0;
2398 }
2399 
2401 {
2402  int min_pu_size = 1 << s->sps->log2_min_pu_size;
2403  int x, y, c_idx;
2404 
2405  for (c_idx = 0; c_idx < 3; c_idx++) {
2406  ptrdiff_t stride = s->frame->linesize[c_idx];
2407  int hshift = s->sps->hshift[c_idx];
2408  int vshift = s->sps->vshift[c_idx];
2409  for (y = 0; y < s->sps->min_pu_height; y++) {
2410  for (x = 0; x < s->sps->min_pu_width; x++) {
2411  if (s->is_pcm[y * s->sps->min_pu_width + x]) {
2412  int n;
2413  int len = min_pu_size >> hshift;
2414  uint8_t *src = &s->frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)];
2415  uint8_t *dst = &s->sao_frame->data[c_idx][((y << s->sps->log2_min_pu_size) >> vshift) * stride + (((x << s->sps->log2_min_pu_size) >> hshift) << s->sps->pixel_shift)];
2416  for (n = 0; n < (min_pu_size >> vshift); n++) {
2417  memcpy(dst, src, len);
2418  src += stride;
2419  dst += stride;
2420  }
2421  }
2422  }
2423  }
2424  }
2425 }
2426 
2428 {
2429  AVFrame *out = s->ref->frame;
2430 
2431  if (s->sei_frame_packing_present &&
2434  s->content_interpretation_type > 0 &&
2435  s->content_interpretation_type < 3) {
2437  if (!stereo)
2438  return AVERROR(ENOMEM);
2439 
2440  switch (s->frame_packing_arrangement_type) {
2441  case 3:
2442  if (s->quincunx_subsampling)
2444  else
2445  stereo->type = AV_STEREO3D_SIDEBYSIDE;
2446  break;
2447  case 4:
2448  stereo->type = AV_STEREO3D_TOPBOTTOM;
2449  break;
2450  case 5:
2451  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
2452  break;
2453  }
2454 
2455  if (s->content_interpretation_type == 2)
2456  stereo->flags = AV_STEREO3D_FLAG_INVERT;
2457  }
2458 
2459  return 0;
2460 }
2461 
2463 {
2464  HEVCLocalContext *lc = &s->HEVClc;
2465  int ret;
2466 
2467  memset(s->horizontal_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2468  memset(s->vertical_bs, 0, 2 * s->bs_width * (s->bs_height + 1));
2469  memset(s->cbf_luma, 0, s->sps->min_tb_width * s->sps->min_tb_height);
2470  memset(s->is_pcm, 0, s->sps->min_pu_width * s->sps->min_pu_height);
2471 
2472  lc->start_of_tiles_x = 0;
2473  s->is_decoded = 0;
2474  s->first_nal_type = s->nal_unit_type;
2475 
2476  if (s->pps->tiles_enabled_flag)
2477  lc->end_of_tiles_x = s->pps->column_width[0] << s->sps->log2_ctb_size;
2478 
2479  ret = ff_hevc_set_new_ref(s, s->sps->sao_enabled ? &s->sao_frame : &s->frame,
2480  s->poc);
2481  if (ret < 0)
2482  goto fail;
2483 
2484  ret = ff_hevc_frame_rps(s);
2485  if (ret < 0) {
2486  av_log(s->avctx, AV_LOG_ERROR, "Error constructing the frame RPS.\n");
2487  goto fail;
2488  }
2489 
2490  ret = set_side_data(s);
2491  if (ret < 0)
2492  goto fail;
2493 
2495  ret = ff_hevc_output_frame(s, s->output_frame, 0);
2496  if (ret < 0)
2497  goto fail;
2498 
2500 
2501  return 0;
2502 
2503 fail:
2504  if (s->ref)
2505  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2506  s->ref = NULL;
2507  return ret;
2508 }
2509 
2510 static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
2511 {
2512  HEVCLocalContext *lc = &s->HEVClc;
2513  GetBitContext *gb = &lc->gb;
2514  int ctb_addr_ts, ret;
2515 
2516  ret = init_get_bits8(gb, nal, length);
2517  if (ret < 0)
2518  return ret;
2519 
2520  ret = hls_nal_unit(s);
2521  if (ret < 0) {
2522  av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit %d, skipping.\n",
2523  s->nal_unit_type);
2524  goto fail;
2525  } else if (!ret)
2526  return 0;
2527 
2528  switch (s->nal_unit_type) {
2529  case NAL_VPS:
2530  ret = ff_hevc_decode_nal_vps(s);
2531  if (ret < 0)
2532  goto fail;
2533  break;
2534  case NAL_SPS:
2535  ret = ff_hevc_decode_nal_sps(s);
2536  if (ret < 0)
2537  goto fail;
2538  break;
2539  case NAL_PPS:
2540  ret = ff_hevc_decode_nal_pps(s);
2541  if (ret < 0)
2542  goto fail;
2543  break;
2544  case NAL_SEI_PREFIX:
2545  case NAL_SEI_SUFFIX:
2546  ret = ff_hevc_decode_nal_sei(s);
2547  if (ret < 0)
2548  goto fail;
2549  break;
2550  case NAL_TRAIL_R:
2551  case NAL_TRAIL_N:
2552  case NAL_TSA_N:
2553  case NAL_TSA_R:
2554  case NAL_STSA_N:
2555  case NAL_STSA_R:
2556  case NAL_BLA_W_LP:
2557  case NAL_BLA_W_RADL:
2558  case NAL_BLA_N_LP:
2559  case NAL_IDR_W_RADL:
2560  case NAL_IDR_N_LP:
2561  case NAL_CRA_NUT:
2562  case NAL_RADL_N:
2563  case NAL_RADL_R:
2564  case NAL_RASL_N:
2565  case NAL_RASL_R:
2566  ret = hls_slice_header(s);
2567  if (ret < 0)
2568  return ret;
2569 
2570  if (s->max_ra == INT_MAX) {
2571  if (s->nal_unit_type == NAL_CRA_NUT || IS_BLA(s)) {
2572  s->max_ra = s->poc;
2573  } else {
2574  if (IS_IDR(s))
2575  s->max_ra = INT_MIN;
2576  }
2577  }
2578 
2579  if ((s->nal_unit_type == NAL_RASL_R || s->nal_unit_type == NAL_RASL_N) &&
2580  s->poc <= s->max_ra) {
2581  s->is_decoded = 0;
2582  break;
2583  } else {
2584  if (s->nal_unit_type == NAL_RASL_R && s->poc > s->max_ra)
2585  s->max_ra = INT_MIN;
2586  }
2587 
2588  if (s->sh.first_slice_in_pic_flag) {
2589  ret = hevc_frame_start(s);
2590  if (ret < 0)
2591  return ret;
2592  } else if (!s->ref) {
2593  av_log(s->avctx, AV_LOG_ERROR, "First slice in a frame missing.\n");
2594  goto fail;
2595  }
2596 
2597  if (s->nal_unit_type != s->first_nal_type) {
2599  "Non-matching NAL types of the VCL NALUs: %d %d\n",
2600  s->first_nal_type, s->nal_unit_type);
2601  return AVERROR_INVALIDDATA;
2602  }
2603 
2604  if (!s->sh.dependent_slice_segment_flag &&
2605  s->sh.slice_type != I_SLICE) {
2606  ret = ff_hevc_slice_rpl(s);
2607  if (ret < 0) {
2609  "Error constructing the reference lists for the current slice.\n");
2610  goto fail;
2611  }
2612  }
2613 
2614  ctb_addr_ts = hls_slice_data(s);
2615  if (ctb_addr_ts >= (s->sps->ctb_width * s->sps->ctb_height)) {
2616  s->is_decoded = 1;
2619  s->sps->sao_enabled)
2620  restore_tqb_pixels(s);
2621  }
2622 
2623  if (ctb_addr_ts < 0) {
2624  ret = ctb_addr_ts;
2625  goto fail;
2626  }
2627  break;
2628  case NAL_EOS_NUT:
2629  case NAL_EOB_NUT:
2630  s->seq_decode = (s->seq_decode + 1) & 0xff;
2631  s->max_ra = INT_MAX;
2632  break;
2633  case NAL_AUD:
2634  case NAL_FD_NUT:
2635  break;
2636  default:
2637  av_log(s->avctx, AV_LOG_INFO,
2638  "Skipping NAL unit %d\n", s->nal_unit_type);
2639  }
2640 
2641  return 0;
2642 fail:
2644  return ret;
2645  return 0;
2646 }
2647 
2648 /* FIXME: This is adapted from ff_h264_decode_nal, avoiding duplication
2649  * between these functions would be nice. */
2650 static int extract_rbsp(const uint8_t *src, int length,
2651  HEVCNAL *nal)
2652 {
2653  int i, si, di;
2654  uint8_t *dst;
2655 
2656 #define STARTCODE_TEST \
2657  if (i + 2 < length && src[i + 1] == 0 && src[i + 2] <= 3) { \
2658  if (src[i + 2] != 3) { \
2659  /* startcode, so we must be past the end */ \
2660  length = i; \
2661  } \
2662  break; \
2663  }
2664 #if HAVE_FAST_UNALIGNED
2665 #define FIND_FIRST_ZERO \
2666  if (i > 0 && !src[i]) \
2667  i--; \
2668  while (src[i]) \
2669  i++
2670 #if HAVE_FAST_64BIT
2671  for (i = 0; i + 1 < length; i += 9) {
2672  if (!((~AV_RN64A(src + i) &
2673  (AV_RN64A(src + i) - 0x0100010001000101ULL)) &
2674  0x8000800080008080ULL))
2675  continue;
2676  FIND_FIRST_ZERO;
2678  i -= 7;
2679  }
2680 #else
2681  for (i = 0; i + 1 < length; i += 5) {
2682  if (!((~AV_RN32A(src + i) &
2683  (AV_RN32A(src + i) - 0x01000101U)) &
2684  0x80008080U))
2685  continue;
2686  FIND_FIRST_ZERO;
2688  i -= 3;
2689  }
2690 #endif /* HAVE_FAST_64BIT */
2691 #else
2692  for (i = 0; i + 1 < length; i += 2) {
2693  if (src[i])
2694  continue;
2695  if (i > 0 && src[i - 1] == 0)
2696  i--;
2698  }
2699 #endif /* HAVE_FAST_UNALIGNED */
2700 
2701  if (i >= length - 1) { // no escaped 0
2702  nal->data = src;
2703  nal->size = length;
2704  return length;
2705  }
2706 
2708  length + FF_INPUT_BUFFER_PADDING_SIZE);
2709  if (!nal->rbsp_buffer)
2710  return AVERROR(ENOMEM);
2711 
2712  dst = nal->rbsp_buffer;
2713 
2714  memcpy(dst, src, i);
2715  si = di = i;
2716  while (si + 2 < length) {
2717  // remove escapes (very rare 1:2^22)
2718  if (src[si + 2] > 3) {
2719  dst[di++] = src[si++];
2720  dst[di++] = src[si++];
2721  } else if (src[si] == 0 && src[si + 1] == 0) {
2722  if (src[si + 2] == 3) { // escape
2723  dst[di++] = 0;
2724  dst[di++] = 0;
2725  si += 3;
2726 
2727  continue;
2728  } else // next start code
2729  goto nsc;
2730  }
2731 
2732  dst[di++] = src[si++];
2733  }
2734  while (si < length)
2735  dst[di++] = src[si++];
2736 
2737 nsc:
2738  memset(dst + di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2739 
2740  nal->data = dst;
2741  nal->size = di;
2742  return si;
2743 }
2744 
2745 static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
2746 {
2747  int i, consumed, ret = 0;
2748 
2749  s->ref = NULL;
2750  s->eos = 0;
2751 
2752  /* split the input packet into NAL units, so we know the upper bound on the
2753  * number of slices in the frame */
2754  s->nb_nals = 0;
2755  while (length >= 4) {
2756  HEVCNAL *nal;
2757  int extract_length = 0;
2758 
2759  if (s->is_nalff) {
2760  int i;
2761  for (i = 0; i < s->nal_length_size; i++)
2762  extract_length = (extract_length << 8) | buf[i];
2763  buf += s->nal_length_size;
2764  length -= s->nal_length_size;
2765 
2766  if (extract_length > length) {
2767  av_log(s->avctx, AV_LOG_ERROR, "Invalid NAL unit size.\n");
2768  ret = AVERROR_INVALIDDATA;
2769  goto fail;
2770  }
2771  } else {
2772  if (buf[2] == 0) {
2773  length--;
2774  buf++;
2775  continue;
2776  }
2777  if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) {
2778  ret = AVERROR_INVALIDDATA;
2779  goto fail;
2780  }
2781 
2782  buf += 3;
2783  length -= 3;
2784  extract_length = length;
2785  }
2786 
2787  if (s->nals_allocated < s->nb_nals + 1) {
2788  int new_size = s->nals_allocated + 1;
2789  HEVCNAL *tmp = av_realloc_array(s->nals, new_size, sizeof(*tmp));
2790  if (!tmp) {
2791  ret = AVERROR(ENOMEM);
2792  goto fail;
2793  }
2794  s->nals = tmp;
2795  memset(s->nals + s->nals_allocated, 0,
2796  (new_size - s->nals_allocated) * sizeof(*tmp));
2797  s->nals_allocated = new_size;
2798  }
2799  nal = &s->nals[s->nb_nals++];
2800 
2801  consumed = extract_rbsp(buf, extract_length, nal);
2802  if (consumed < 0) {
2803  ret = consumed;
2804  goto fail;
2805  }
2806 
2807  ret = init_get_bits8(&s->HEVClc.gb, nal->data, nal->size);
2808  if (ret < 0)
2809  goto fail;
2810  hls_nal_unit(s);
2811 
2812  if (s->nal_unit_type == NAL_EOB_NUT ||
2813  s->nal_unit_type == NAL_EOS_NUT)
2814  s->eos = 1;
2815 
2816  buf += consumed;
2817  length -= consumed;
2818  }
2819 
2820  /* parse the NAL units */
2821  for (i = 0; i < s->nb_nals; i++) {
2822  int ret = decode_nal_unit(s, s->nals[i].data, s->nals[i].size);
2823  if (ret < 0) {
2825  "Error parsing NAL unit #%d.\n", i);
2826  goto fail;
2827  }
2828  }
2829 
2830 fail:
2831  if (s->ref)
2832  ff_thread_report_progress(&s->ref->tf, INT_MAX, 0);
2833 
2834  return ret;
2835 }
2836 
2837 static void print_md5(void *log_ctx, int level, uint8_t md5[16])
2838 {
2839  int i;
2840  for (i = 0; i < 16; i++)
2841  av_log(log_ctx, level, "%02"PRIx8, md5[i]);
2842 }
2843 
2844 static int verify_md5(HEVCContext *s, AVFrame *frame)
2845 {
2846  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
2847  int pixel_shift;
2848  int i, j;
2849 
2850  if (!desc)
2851  return AVERROR(EINVAL);
2852 
2853  pixel_shift = desc->comp[0].depth_minus1 > 7;
2854 
2855  av_log(s->avctx, AV_LOG_DEBUG, "Verifying checksum for frame with POC %d: ",
2856  s->poc);
2857 
2858  /* the checksums are LE, so we have to byteswap for >8bpp formats
2859  * on BE arches */
2860 #if HAVE_BIGENDIAN
2861  if (pixel_shift && !s->checksum_buf) {
2863  FFMAX3(frame->linesize[0], frame->linesize[1],
2864  frame->linesize[2]));
2865  if (!s->checksum_buf)
2866  return AVERROR(ENOMEM);
2867  }
2868 #endif
2869 
2870  for (i = 0; frame->data[i]; i++) {
2871  int width = s->avctx->coded_width;
2872  int height = s->avctx->coded_height;
2873  int w = (i == 1 || i == 2) ? (width >> desc->log2_chroma_w) : width;
2874  int h = (i == 1 || i == 2) ? (height >> desc->log2_chroma_h) : height;
2875  uint8_t md5[16];
2876 
2877  av_md5_init(s->md5_ctx);
2878  for (j = 0; j < h; j++) {
2879  const uint8_t *src = frame->data[i] + j * frame->linesize[i];
2880 #if HAVE_BIGENDIAN
2881  if (pixel_shift) {
2882  s->dsp.bswap16_buf((uint16_t*)s->checksum_buf,
2883  (const uint16_t*)src, w);
2884  src = s->checksum_buf;
2885  }
2886 #endif
2887  av_md5_update(s->md5_ctx, src, w << pixel_shift);
2888  }
2889  av_md5_final(s->md5_ctx, md5);
2890 
2891  if (!memcmp(md5, s->md5[i], 16)) {
2892  av_log (s->avctx, AV_LOG_DEBUG, "plane %d - correct ", i);
2893  print_md5(s->avctx, AV_LOG_DEBUG, md5);
2894  av_log (s->avctx, AV_LOG_DEBUG, "; ");
2895  } else {
2896  av_log (s->avctx, AV_LOG_ERROR, "mismatching checksum of plane %d - ", i);
2897  print_md5(s->avctx, AV_LOG_ERROR, md5);
2898  av_log (s->avctx, AV_LOG_ERROR, " != ");
2899  print_md5(s->avctx, AV_LOG_ERROR, s->md5[i]);
2900  av_log (s->avctx, AV_LOG_ERROR, "\n");
2901  return AVERROR_INVALIDDATA;
2902  }
2903  }
2904 
2905  av_log(s->avctx, AV_LOG_DEBUG, "\n");
2906 
2907  return 0;
2908 }
2909 
2910 static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
2911  AVPacket *avpkt)
2912 {
2913  int ret;
2914  HEVCContext *s = avctx->priv_data;
2915 
2916  if (!avpkt->size) {
2917  ret = ff_hevc_output_frame(s, data, 1);
2918  if (ret < 0)
2919  return ret;
2920 
2921  *got_output = ret;
2922  return 0;
2923  }
2924 
2925  s->ref = NULL;
2926  ret = decode_nal_units(s, avpkt->data, avpkt->size);
2927  if (ret < 0)
2928  return ret;
2929 
2930  /* verify the SEI checksum */
2931  if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
2932  s->is_md5) {
2933  ret = verify_md5(s, s->ref->frame);
2934  if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE) {
2935  ff_hevc_unref_frame(s, s->ref, ~0);
2936  return ret;
2937  }
2938  }
2939  s->is_md5 = 0;
2940 
2941  if (s->is_decoded) {
2942  av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
2943  s->is_decoded = 0;
2944  }
2945 
2946  if (s->output_frame->buf[0]) {
2947  av_frame_move_ref(data, s->output_frame);
2948  *got_output = 1;
2949  }
2950 
2951  return avpkt->size;
2952 }
2953 
2954 static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
2955 {
2956  int ret = ff_thread_ref_frame(&dst->tf, &src->tf);
2957  if (ret < 0)
2958  return ret;
2959 
2960  dst->tab_mvf_buf = av_buffer_ref(src->tab_mvf_buf);
2961  if (!dst->tab_mvf_buf)
2962  goto fail;
2963  dst->tab_mvf = src->tab_mvf;
2964 
2965  dst->rpl_tab_buf = av_buffer_ref(src->rpl_tab_buf);
2966  if (!dst->rpl_tab_buf)
2967  goto fail;
2968  dst->rpl_tab = src->rpl_tab;
2969 
2970  dst->rpl_buf = av_buffer_ref(src->rpl_buf);
2971  if (!dst->rpl_buf)
2972  goto fail;
2973 
2974  dst->poc = src->poc;
2975  dst->ctb_count = src->ctb_count;
2976  dst->window = src->window;
2977  dst->flags = src->flags;
2978  dst->sequence = src->sequence;
2979 
2980  return 0;
2981 fail:
2982  ff_hevc_unref_frame(s, dst, ~0);
2983  return AVERROR(ENOMEM);
2984 }
2985 
2987 {
2988  HEVCContext *s = avctx->priv_data;
2989  int i;
2990 
2991  pic_arrays_free(s);
2992 
2993  av_freep(&s->md5_ctx);
2994 
2995  av_frame_free(&s->tmp_frame);
2997 
2998  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
2999  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3000  av_frame_free(&s->DPB[i].frame);
3001  }
3002 
3003  for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++)
3004  av_buffer_unref(&s->vps_list[i]);
3005  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
3006  av_buffer_unref(&s->sps_list[i]);
3007  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
3008  av_buffer_unref(&s->pps_list[i]);
3009 
3010  for (i = 0; i < s->nals_allocated; i++)
3011  av_freep(&s->nals[i].rbsp_buffer);
3012  av_freep(&s->nals);
3013  s->nals_allocated = 0;
3014 
3015  return 0;
3016 }
3017 
3019 {
3020  HEVCContext *s = avctx->priv_data;
3021  int i;
3022 
3023  s->avctx = avctx;
3024 
3025  s->tmp_frame = av_frame_alloc();
3026  if (!s->tmp_frame)
3027  goto fail;
3028 
3030  if (!s->output_frame)
3031  goto fail;
3032 
3033  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3034  s->DPB[i].frame = av_frame_alloc();
3035  if (!s->DPB[i].frame)
3036  goto fail;
3037  s->DPB[i].tf.f = s->DPB[i].frame;
3038  }
3039 
3040  s->max_ra = INT_MAX;
3041 
3042  s->md5_ctx = av_md5_alloc();
3043  if (!s->md5_ctx)
3044  goto fail;
3045 
3046  ff_dsputil_init(&s->dsp, avctx);
3047 
3048  s->context_initialized = 1;
3049 
3050  return 0;
3051 
3052 fail:
3053  hevc_decode_free(avctx);
3054  return AVERROR(ENOMEM);
3055 }
3056 
3058  const AVCodecContext *src)
3059 {
3060  HEVCContext *s = dst->priv_data;
3061  HEVCContext *s0 = src->priv_data;
3062  int i, ret;
3063 
3064  if (!s->context_initialized) {
3065  ret = hevc_init_context(dst);
3066  if (ret < 0)
3067  return ret;
3068  }
3069 
3070  for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) {
3071  ff_hevc_unref_frame(s, &s->DPB[i], ~0);
3072  if (s0->DPB[i].frame->buf[0]) {
3073  ret = hevc_ref_frame(s, &s->DPB[i], &s0->DPB[i]);
3074  if (ret < 0)
3075  return ret;
3076  }
3077  }
3078 
3079  for (i = 0; i < FF_ARRAY_ELEMS(s->vps_list); i++) {
3080  av_buffer_unref(&s->vps_list[i]);
3081  if (s0->vps_list[i]) {
3082  s->vps_list[i] = av_buffer_ref(s0->vps_list[i]);
3083  if (!s->vps_list[i])
3084  return AVERROR(ENOMEM);
3085  }
3086  }
3087 
3088  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++) {
3089  av_buffer_unref(&s->sps_list[i]);
3090  if (s0->sps_list[i]) {
3091  s->sps_list[i] = av_buffer_ref(s0->sps_list[i]);
3092  if (!s->sps_list[i])
3093  return AVERROR(ENOMEM);
3094  }
3095  }
3096 
3097  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
3098  av_buffer_unref(&s->pps_list[i]);
3099  if (s0->pps_list[i]) {
3100  s->pps_list[i] = av_buffer_ref(s0->pps_list[i]);
3101  if (!s->pps_list[i])
3102  return AVERROR(ENOMEM);
3103  }
3104  }
3105 
3106  if (s->sps != s0->sps)
3107  ret = set_sps(s, s0->sps);
3108 
3109  s->seq_decode = s0->seq_decode;
3110  s->seq_output = s0->seq_output;
3111  s->pocTid0 = s0->pocTid0;
3112  s->max_ra = s0->max_ra;
3113 
3114  s->is_nalff = s0->is_nalff;
3116 
3117  if (s0->eos) {
3118  s->seq_decode = (s->seq_decode + 1) & 0xff;
3119  s->max_ra = INT_MAX;
3120  }
3121 
3122  return 0;
3123 }
3124 
3126 {
3127  AVCodecContext *avctx = s->avctx;
3128  GetByteContext gb;
3129  int ret;
3130 
3131  bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
3132 
3133  if (avctx->extradata_size > 3 &&
3134  (avctx->extradata[0] || avctx->extradata[1] ||
3135  avctx->extradata[2] > 1)) {
3136  /* It seems the extradata is encoded as hvcC format.
3137  * Temporarily, we support configurationVersion==0 until 14496-15 3rd
3138  * is finalized. When finalized, configurationVersion will be 1 and we
3139  * can recognize hvcC by checking if avctx->extradata[0]==1 or not. */
3140  int i, j, num_arrays, nal_len_size;
3141 
3142  s->is_nalff = 1;
3143 
3144  bytestream2_skip(&gb, 21);
3145  nal_len_size = (bytestream2_get_byte(&gb) & 3) + 1;
3146  num_arrays = bytestream2_get_byte(&gb);
3147 
3148  /* nal units in the hvcC always have length coded with 2 bytes,
3149  * so put a fake nal_length_size = 2 while parsing them */
3150  s->nal_length_size = 2;
3151 
3152  /* Decode nal units from hvcC. */
3153  for (i = 0; i < num_arrays; i++) {
3154  int type = bytestream2_get_byte(&gb) & 0x3f;
3155  int cnt = bytestream2_get_be16(&gb);
3156 
3157  for (j = 0; j < cnt; j++) {
3158  // +2 for the nal size field
3159  int nalsize = bytestream2_peek_be16(&gb) + 2;
3160  if (bytestream2_get_bytes_left(&gb) < nalsize) {
3162  "Invalid NAL unit size in extradata.\n");
3163  return AVERROR_INVALIDDATA;
3164  }
3165 
3166  ret = decode_nal_units(s, gb.buffer, nalsize);
3167  if (ret < 0) {
3168  av_log(avctx, AV_LOG_ERROR,
3169  "Decoding nal unit %d %d from hvcC failed\n",
3170  type, i);
3171  return ret;
3172  }
3173  bytestream2_skip(&gb, nalsize);
3174  }
3175  }
3176 
3177  /* Now store right nal length size, that will be used to parse
3178  * all other nals */
3179  s->nal_length_size = nal_len_size;
3180  } else {
3181  s->is_nalff = 0;
3182  ret = decode_nal_units(s, avctx->extradata, avctx->extradata_size);
3183  if (ret < 0)
3184  return ret;
3185  }
3186  return 0;
3187 }
3188 
3190 {
3191  HEVCContext *s = avctx->priv_data;
3192  int ret;
3193 
3195 
3196  avctx->internal->allocate_progress = 1;
3197 
3198  ret = hevc_init_context(avctx);
3199  if (ret < 0)
3200  return ret;
3201 
3202  if (avctx->extradata_size > 0 && avctx->extradata) {
3203  ret = hevc_decode_extradata(s);
3204  if (ret < 0) {
3205  hevc_decode_free(avctx);
3206  return ret;
3207  }
3208  }
3209 
3210  return 0;
3211 }
3212 
3214 {
3215  HEVCContext *s = avctx->priv_data;
3216  int ret;
3217 
3218  memset(s, 0, sizeof(*s));
3219 
3220  ret = hevc_init_context(avctx);
3221  if (ret < 0)
3222  return ret;
3223 
3224  return 0;
3225 }
3226 
3228 {
3229  HEVCContext *s = avctx->priv_data;
3230  ff_hevc_flush_dpb(s);
3231  s->max_ra = INT_MAX;
3232 }
3233 
3234 #define OFFSET(x) offsetof(HEVCContext, x)
3235 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
3236 
3237 static const AVProfile profiles[] = {
3238  { FF_PROFILE_HEVC_MAIN, "Main" },
3239  { FF_PROFILE_HEVC_MAIN_10, "Main 10" },
3240  { FF_PROFILE_HEVC_MAIN_STILL_PICTURE, "Main Still Picture" },
3241  { FF_PROFILE_UNKNOWN },
3242 };
3243 
3244 static const AVOption options[] = {
3245  { "apply_defdispwin", "Apply default display window from VUI", OFFSET(apply_defdispwin),
3246  AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, PAR },
3247  { NULL },
3248 };
3249 
3250 static const AVClass hevc_decoder_class = {
3251  .class_name = "HEVC decoder",
3252  .item_name = av_default_item_name,
3253  .option = options,
3254  .version = LIBAVUTIL_VERSION_INT,
3255 };
3256 
3258  .name = "hevc",
3259  .long_name = NULL_IF_CONFIG_SMALL("HEVC (High Efficiency Video Coding)"),
3260  .type = AVMEDIA_TYPE_VIDEO,
3261  .id = AV_CODEC_ID_HEVC,
3262  .priv_data_size = sizeof(HEVCContext),
3263  .priv_class = &hevc_decoder_class,
3268  .update_thread_context = hevc_update_thread_context,
3269  .init_thread_copy = hevc_init_thread_copy,
3270  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3272  .profiles = NULL_IF_CONFIG_SMALL(profiles),
3273 };
int nals_allocated
Definition: hevc.h:842
#define EDGE_EMU_BUFFER_STRIDE
Definition: hevc.h:74
static const uint8_t horiz_scan2x2_x[4]
Definition: hevc.c:46
int frame_packing_arrangement_type
Definition: hevc.h:861
uint8_t ctb_up_flag
Definition: hevc.h:743
AVFrame * frame
Definition: hevc.h:677
unsigned int log2_min_cb_size
Definition: hevc.h:436
int sei_frame_packing_present
frame packing arrangement variables
Definition: hevc.h:860
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
static const int16_t coeffs[28]
TransformTree tt
Definition: hevc.h:735
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2440
int ff_hevc_merge_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:619
HEVCPredContext hpc
Definition: hevc.h:806
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define SAMPLE_CBF(tab, x, y)
Definition: hevc.h:81
int pic_order_cnt_lsb
Definition: hevc.h:540
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:105
int ff_hevc_frame_nb_refs(HEVCContext *s)
Get the number of candidate references for the current frame.
Definition: hevc_refs.c:470
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1507
int quincunx_subsampling
Definition: hevc.h:863
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
HEVCFrame * ref
Definition: hevc.h:794
static void restore_tqb_pixels(HEVCContext *s)
Definition: hevc.c:2400
#define EPEL_EXTRA_AFTER
Definition: hevc.h:71
Definition: hevc.h:625
void(* put_hevc_epel[2][2])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int width, int height, int mx, int my, int16_t *mcbuffer)
Definition: hevcdsp.h:64
int ctb_height
Definition: hevc.h:450
void(* put_pcm)(uint8_t *dst, ptrdiff_t stride, int size, GetBitContext *gb, int pcm_bit_depth)
Definition: hevcdsp.h:42
uint8_t is_cu_qp_delta_coded
Definition: hevc.h:664
static void hls_mvd_coding(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:1486
AVOption.
Definition: opt.h:233
Views are alternated temporally.
Definition: stereo3d.h:63
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:179
int ff_hevc_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:630
Definition: hevc.h:97
int ff_hevc_sao_band_position_decode(HEVCContext *s)
Definition: hevc_cabac.c:432
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1227
VideoDSPContext vdsp
Definition: hevc.h:808
uint8_t edge_emu_buffer[(MAX_PB_SIZE+7)*EDGE_EMU_BUFFER_STRIDE *2]
Definition: hevc.h:750
static void hevc_await_progress(HEVCContext *s, HEVCFrame *ref, const Mv *mv, int y0, int height)
Definition: hevc.c:1642
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
int ff_hevc_decode_nal_sps(HEVCContext *s)
Definition: hevc_ps.c:608
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:84
Definition: hevc.h:201
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
int content_interpretation_type
Definition: hevc.h:862
AVFrame * f
Definition: thread.h:36
int ff_hevc_cbf_luma_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:712
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:365
int vps_id
Definition: hevc.h:385
int16_t x
horizontal component of motion vector
Definition: hevc.h:621
static int hevc_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: hevc.c:3057
#define MAX_REFS
Definition: hevc.h:42
uint8_t nb_refs
Definition: hevc.h:273
MvField * tab_mvf
Definition: hevc.h:679
int pic_init_qp_minus26
Definition: hevc.h:474
static int set_sps(HEVCContext *s, const HEVCSPS *sps)
Definition: hevc.c:388
int bs_width
Definition: hevc.h:801
int ff_hevc_end_of_slice_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:464
uint8_t intra_split_flag
IntraSplitFlag.
Definition: hevc.h:615
#define MAX_PPS_COUNT
Definition: h264.h:43
VUI vui
Definition: hevc.h:409
AVFrame * sao_frame
Definition: hevc.h:772
int rem_intra_luma_pred_mode
Definition: hevc.h:643
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1754
int vshift[3]
Definition: hevc.h:460
void(* put_hevc_qpel[4][4])(int16_t *dst, ptrdiff_t dststride, uint8_t *src, ptrdiff_t srcstride, int width, int height, int16_t *mcbuffer)
Definition: hevcdsp.h:61
struct HEVCSPS::@24 pcm
int num
numerator
Definition: rational.h:44
void ff_hevc_luma_mv_merge_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv)
Definition: hevc_mvs.c:528
int size
Definition: avcodec.h:974
int ff_hevc_significant_coeff_group_flag_decode(HEVCContext *s, int c_idx, int ctx_cg)
Definition: hevc_cabac.c:763
unsigned int slice_addr
Definition: hevc.h:536
uint32_t vui_time_scale
Definition: hevc.h:321
int nb_nals
Definition: hevc.h:841
uint8_t weighted_bipred_flag
Definition: hevc.h:486
void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
Definition: hevc_refs.c:30
int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:73
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
#define MAX_PB_SIZE
Definition: hevc.h:58
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1422
int tc_offset
Definition: hevc.h:669
int ff_hevc_rem_intra_luma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:598
void(* put_unweighted_pred)(uint8_t *dst, ptrdiff_t dststride, int16_t *src, ptrdiff_t srcstride, int width, int height)
Definition: hevcdsp.h:68
PredictionUnit pu
Definition: hevc.h:753
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1247
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
static void intra_prediction_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:2014
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:499
uint8_t cabac_init_present_flag
Definition: hevc.h:470
int16_t chroma_offset_l1[16][2]
Definition: hevc.h:594
void ff_hevc_hls_filter(HEVCContext *s, int x, int y)
Definition: hevc_filter.c:728
Definition: hevc.h:247
uint8_t cbf_cb[MAX_TRANSFORM_DEPTH][MAX_CU_SIZE *MAX_CU_SIZE]
Definition: hevc.h:651
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everythnig contained in src to dst and reset src.
Definition: frame.c:292
int ff_hevc_frame_rps(HEVCContext *s)
Construct the reference picture sets for the current frame.
Definition: hevc_refs.c:388
#define FF_ARRAY_ELEMS(a)
int x
Definition: hevc.h:604
int ff_hevc_coeff_abs_level_greater2_flag_decode(HEVCContext *s, int c_idx, int inc)
Definition: hevc_cabac.c:831
int min_cb_height
Definition: hevc.h:453
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:523
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:472
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
struct HEVCFrame * ref[MAX_REFS]
Definition: hevc.h:277
uint8_t dependent_slice_segment_flag
Definition: hevc.h:543
CABACContext cc
Definition: hevc.h:734
ShortTermRPS slice_rps
Definition: hevc.h:548
int profile
profile
Definition: avcodec.h:2596
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:416
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2755
int width
Definition: hevc.h:447
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:68
static const uint8_t rem6[QP_MAX_NUM+1]
Definition: h264.c:53
int ff_hevc_sao_type_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:422
uint16_t seq_decode
Sequence counters for decoded and output frames, so that old frames are output first after a POC rese...
Definition: hevc.h:837
#define SAMPLE(tab, x, y)
Value of the luma sample at position (x, y) in the 2D array tab.
Definition: hevc.h:79
enum NALUnitType first_nal_type
Definition: hevc.h:844
Macro definitions for various function/variable attributes.
int qp_bd_offset
Definition: hevc.h:462
int pixel_shift
Definition: hevc.h:396
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1173
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:492
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
int max_ra
Definition: hevc.h:800
static const uint8_t div6[QP_MAX_NUM+1]
Definition: h264.c:59
int ff_hevc_cu_transquant_bypass_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:469
static int hls_slice_data(HEVCContext *s)
Definition: hevc.c:2333
int output_width
Definition: hevc.h:390
const uint8_t ff_hevc_qpel_extra_before[4]
Definition: hevc.c:40
static void hls_sao_param(HEVCContext *s, int rx, int ry)
Definition: hevc.c:812
#define AV_RN32A(p)
Definition: intreadwrite.h:446
AVBufferPool * rpl_tab_pool
candidate references for the current frame
Definition: hevc.h:784
CodingTree ct
Definition: hevc.h:751
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:38
#define PAR
Definition: hevc.c:3235
int ff_hevc_last_significant_coeff_y_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
Definition: hevc_cabac.c:745
int chroma_format_idc
Definition: hevc.h:386
uint8_t disable_dbf
Definition: hevc.h:503
unsigned int log2_max_trafo_size
Definition: hevc.h:439
unsigned int slice_segment_addr
address (in raster order) of the first block in the current slice
Definition: hevc.h:534
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
struct AVMD5 * av_md5_alloc(void)
Definition: md5.c:49
int ff_hevc_mpm_idx_decode(HEVCContext *s)
Definition: hevc_cabac.c:590
int ff_hevc_coeff_abs_level_greater1_flag_decode(HEVCContext *s, int c_idx, int ctx_set)
Definition: hevc_cabac.c:822
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:85
int end_of_tiles_x
Definition: hevc.h:747
uint8_t
#define av_cold
Definition: attributes.h:66
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:43
int ff_hevc_skip_flag_decode(HEVCContext *s, int x0, int y0, int x_cb, int y_cb)
Definition: hevc_cabac.c:474
InterPredIdc
Definition: hevc.h:200
float delta
AVOptions.
Definition: h264.h:110
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:120
#define SUBDIVIDE(x, y)
static int set_side_data(HEVCContext *s)
Definition: hevc.c:2427
uint8_t ctb_up_right_flag
Definition: hevc.h:744
LongTermRPS long_term_rps
Definition: hevc.h:550
const uint8_t * data
Definition: hevc.h:709
int poc[32]
Definition: hevc.h:271
uint8_t vps_timing_info_present_flag
Definition: hevc.h:369
int ff_hevc_abs_mvd_greater0_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:671
uint8_t matrix_coeffs
Definition: hevc.h:306
static int hls_slice_header(HEVCContext *s)
Definition: hevc.c:457
int min_tb_width
Definition: hevc.h:454
int depth
ctDepth
Definition: hevc.h:600
uint8_t * rbsp_buffer
Definition: hevc.h:705
int num_entry_point_offsets
Definition: hevc.h:578
Definition: h264.h:108
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2670
AVFrame * output_frame
Definition: hevc.h:774
SAOParams * sao
Definition: hevc.h:790
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:473
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1162
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:429
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
AVCodecContext * avctx
Definition: hevc.h:762
static int hls_transform_unit(HEVCContext *s, int x0, int y0, int xBase, int yBase, int cb_xBase, int cb_yBase, int log2_cb_size, int log2_trafo_size, int trafo_depth, int blk_idx)
Definition: hevc.c:1232
int min_cb_width
Definition: hevc.h:452
static void luma_mc(HEVCContext *s, int16_t *dst, ptrdiff_t dststride, AVFrame *ref, const Mv *mv, int x_off, int y_off, int block_w, int block_h)
8.5.3.2.2.1 Luma sample interpolation process
Definition: hevc.c:1523
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:711
static int hls_coding_unit(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:2076
const char data[16]
Definition: mxf.c:66
uint8_t scaling_list_data_present_flag
Definition: hevc.h:507
HEVCNAL * nals
Definition: hevc.h:840
ThreadFrame tf
Definition: hevc.h:678
uint8_t first_slice_in_pic_flag
Definition: hevc.h:542
uint8_t * data
Definition: avcodec.h:973
uint8_t bit_depth_chroma
Definition: hevc.h:428
const uint8_t * buffer
Definition: bytestream.h:33
uint8_t ctb_up_left_flag
Definition: hevc.h:745
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:2237
#define STARTCODE_TEST
#define MAX_TB_SIZE
Definition: hevc.h:57
int ff_hevc_decode_nal_sei(HEVCContext *s)
Definition: hevc_sei.c:117
void(* put_weighted_pred_avg)(uint8_t *dst, ptrdiff_t dststride, int16_t *src1, int16_t *src2, ptrdiff_t srcstride, int width, int height)
Definition: hevcdsp.h:70
uint8_t cbf_cr[MAX_TRANSFORM_DEPTH][MAX_CU_SIZE *MAX_CU_SIZE]
Definition: hevc.h:652
Definition: hevc.h:202
#define EPEL_EXTRA_BEFORE
Definition: hevc.h:70
int8_t * qp_y_tab
Definition: hevc.h:810
uint8_t loop_filter_disable_flag
Definition: hevc.h:431
int ff_hevc_mvd_decode(HEVCContext *s)
Definition: hevc_cabac.c:681
static void print_md5(void *log_ctx, int level, uint8_t md5[16])
Definition: hevc.c:2837
uint8_t pic_output_flag
Definition: hevc.h:544
uint8_t * tab_ct_depth
Definition: hevc.h:819
void ff_hevc_flush_dpb(HEVCContext *s)
Drop all frames currently in DPB.
Definition: hevc_refs.c:75
static int decode_lt_rps(HEVCContext *s, LongTermRPS *rps, GetBitContext *gb)
Definition: hevc.c:336
uint8_t cu_transquant_bypass_flag
Definition: hevc.h:617
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2671
static av_unused const uint8_t * skip_bytes(CABACContext *c, int n)
Skip n bytes and reset the decoder.
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:488
#define FFUMOD(a, b)
Definition: hevc.h:89
uint8_t used[32]
Definition: hevc.h:272
int ff_hevc_sao_offset_sign_decode(HEVCContext *s)
Definition: hevc_cabac.c:452
int temporal_id
temporal_id_plus1 - 1
Definition: hevc.h:793
#define SET_SAO(elem, value)
Definition: hevc.c:800
uint8_t first_qp_group
Definition: hevc.h:731
HEVCDSPContext hevcdsp
Definition: hevc.h:807
int ctb_count
Definition: hevc.h:682
uint8_t no_output_of_prior_pics_flag
Definition: hevc.h:554
static void hevc_decode_flush(AVCodecContext *avctx)
Definition: hevc.c:3227
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)
Definition: hevc.c:1335
int slice_idx
number of the slice being currently decoded
Definition: hevc.h:798
uint8_t intra_pred_mode[4]
Definition: hevc.h:644
const HEVCSPS * sps
Definition: hevc.h:777
uint8_t colour_plane_id
RPS coded in the slice header itself is stored here.
Definition: hevc.h:545
uint16_t depth_minus1
number of bits in the component minus 1
Definition: pixdesc.h:45
void av_md5_update(AVMD5 *ctx, const uint8_t *src, const int len)
Definition: md5.c:144
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1332
int flags
Additional information about the frame packing.
Definition: stereo3d.h:129
static av_cold int hevc_init_thread_copy(AVCodecContext *avctx)
Definition: hevc.c:3213
uint8_t slice_initialized
1 if the independent slice segment header was successfully parsed
Definition: hevc.h:769
static int extract_rbsp(const uint8_t *src, int length, HEVCNAL *nal)
Definition: hevc.c:2650
unsigned int log2_max_poc_lsb
Definition: hevc.h:399
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:77
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: dsputil.h:203
void(* transform_add[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
Definition: hevcdsp.h:51
int min_pu_height
Definition: hevc.h:457
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:779
static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2, ptrdiff_t dststride, AVFrame *ref, const Mv *mv, int x_off, int y_off, int block_w, int block_h)
8.5.3.2.2.2 Chroma sample interpolation process
Definition: hevc.c:1577
#define 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:740
AVBufferRef * rpl_tab_buf
Definition: hevc.h:689
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:55
uint8_t rpl_modification_flag[2]
Definition: hevc.h:553
int vui_timing_info_present_flag
Definition: hevc.h:319
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
Definition: hevc.h:187
RefPicList * refPicList
Definition: hevc.h:680
int16_t luma_offset_l0[16]
Definition: hevc.h:590
HEVCLocalContext HEVClc
Definition: hevc.h:764
static av_always_inline av_const int av_clip_c(int a, int amin, int amax)
Clip a signed integer value into the amin-amax range.
Definition: common.h:93
int bs_height
Definition: hevc.h:802
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
int ff_hevc_compute_poc(HEVCContext *s, int poc_lsb)
Compute POC of the current frame and return it.
Definition: hevc_refs.c:447
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:149
unsigned int log2_ctb_size
Definition: hevc.h:440
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:574
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
const ShortTermRPS * short_term_rps
Definition: hevc.h:549
uint8_t merge_flag
Definition: hevc.h:646
void(* weighted_pred)(uint8_t denom, int16_t wlxFlag, int16_t olxFlag, uint8_t *dst, ptrdiff_t dststride, int16_t *src, ptrdiff_t srcstride, int width, int height)
Definition: hevcdsp.h:73
void ff_init_cabac_states(void)
Definition: cabac.c:124
void(* transquant_bypass[4])(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
Definition: hevcdsp.h:45
struct AVMD5 * md5_ctx
Definition: hevc.h:847
void ff_hevc_save_states(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:326
uint8_t cbf_luma
Definition: hevc.h:653
int8_t slice_qp
Definition: hevc.h:580
static int verify_md5(HEVCContext *s, AVFrame *frame)
Definition: hevc.c:2844
static const AVClass hevc_decoder_class
Definition: hevc.c:3250
uint8_t max_trafo_depth
MaxTrafoDepth.
Definition: hevc.h:616
uint16_t sequence
A sequence counter, so that old frames are output first after a POC reset.
Definition: hevc.h:696
uint8_t colour_primaries
Definition: hevc.h:304
uint8_t slice_temporal_mvp_enabled_flag
Definition: hevc.h:555
uint8_t * vertical_bs
Definition: hevc.h:813
static char * split(char *message, char delim)
Definition: af_channelmap.c:86
uint8_t tiles_enabled_flag
Definition: hevc.h:491
int ff_hevc_decode_nal_vps(HEVCContext *s)
Definition: hevc_ps.c:322
int eo_class[3]
sao_eo_class
Definition: hevcdsp.h:34
the normal 2^n-1 "JPEG" YUV ranges
Definition: avcodec.h:596
uint32_t vps_num_units_in_tick
Definition: hevc.h:370
static av_cold int hevc_init_context(AVCodecContext *avctx)
Definition: hevc.c:3018
int16_t luma_weight_l0[16]
Definition: hevc.h:585
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
const HEVCPPS * pps
Definition: hevc.h:778
int * col_idxX
Definition: hevc.h:520
int ff_hevc_mvd_sign_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:697
int slice_qp_delta
Definition: hevc.h:569
common internal API header
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:509
int ff_hevc_mvp_lx_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:661
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: avcodec.h:595
uint8_t is_intra
Definition: hevc.h:629
uint8_t lists_modification_present_flag
Definition: hevc.h:510
uint8_t profile_idc
Definition: hevc.h:340
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:37
AVBufferRef * tab_mvf_buf
Definition: hevc.h:688
int ff_hevc_coeff_abs_level_remaining(HEVCContext *s, int base_level, int rc_rice_param)
Definition: hevc_cabac.c:839
uint8_t type_idx[3]
sao_type_idx
Definition: hevcdsp.h:38
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:573
const uint8_t ff_hevc_qpel_extra[4]
Definition: hevc.c:42
int ff_hevc_transform_skip_flag_decode(HEVCContext *s, int c_idx)
Definition: hevc_cabac.c:717
const uint8_t ff_hevc_qpel_extra_after[4]
Definition: hevc.c:41
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2390
int max_transform_hierarchy_depth_inter
Definition: hevc.h:443
#define IS_IDR(s)
Definition: hevc.h:83
#define FFMIN(a, b)
Definition: common.h:57
void(* weighted_pred_avg)(uint8_t denom, int16_t wl0Flag, int16_t wl1Flag, int16_t ol0Flag, int16_t ol1Flag, uint8_t *dst, ptrdiff_t dststride, int16_t *src1, int16_t *src2, ptrdiff_t srcstride, int width, int height)
Definition: hevcdsp.h:76
int16_t mc_buffer[(64+7)*64]
Definition: hevc.h:728
static const AVOption options[]
Definition: hevc.c:3244
int rbsp_buffer_size
Definition: hevc.h:706
int slice_cr_qp_offset
Definition: hevc.h:571
int offset_abs[3][4]
sao_offset_abs
Definition: hevcdsp.h:29
int output_height
Definition: hevc.h:390
int width
picture width / height.
Definition: avcodec.h:1217
int ff_hevc_output_frame(HEVCContext *s, AVFrame *frame, int flush)
Find next frame in output order and put a reference to it in frame.
Definition: hevc_refs.c:154
uint8_t * tab_ipm
Definition: hevc.h:821
int size
Definition: hevc.h:708
static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
Definition: hevc.c:2745
void ff_hevc_hls_filters(HEVCContext *s, int x_ctb, int y_ctb, int ctb_size)
Definition: hevc_filter.c:735
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2597
static int luma_intra_pred_mode(HEVCContext *s, int x0, int y0, int pu_size, int prev_intra_luma_pred_flag)
8.4.1
Definition: hevc.c:1913
int hshift[3]
Definition: hevc.h:459
int ff_hevc_part_mode_decode(HEVCContext *s, int log2_cb_size)
Definition: hevc_cabac.c:543
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2672
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define OFFSET(x)
Definition: hevc.c:3234
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:780
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:111
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1733
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:479
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:423
int8_t qp_y
Definition: hevc.h:737
static int hls_pcm_sample(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:1455
Definition: hevc.h:134
Context Adaptive Binary Arithmetic Coder inline functions.
int level
level
Definition: avcodec.h:2679
Definition: hevc.h:203
int ctb_width
Definition: hevc.h:449
int16_t chroma_weight_l0[16][2]
Definition: hevc.h:586
void ff_hevc_set_neighbour_available(HEVCContext *s, int x0, int y0, int nPbW, int nPbH)
Definition: hevc_mvs.c:41
uint8_t sl_dc[2][6]
Definition: hevc.h:381
uint8_t sign_data_hiding_flag
Definition: hevc.h:468
int height
Definition: hevc.h:448
#define AV_EF_EXPLODE
Definition: avcodec.h:2401
uint8_t output_flag_present_flag
Definition: hevc.h:487
uint16_t seq_output
Definition: hevc.h:838
int mpm_idx
Definition: hevc.h:642
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc.c:91
PTLCommon general_ptl
Definition: hevc.h:350
int16_t luma_offset_l1[16]
Definition: hevc.h:593
int offset_val[3][5]
SaoOffsetVal.
Definition: hevcdsp.h:36
int16_t chroma_offset_l0[16][2]
Definition: hevc.h:591
LIBAVUTIL_VERSION_INT
Definition: eval.c:55
static int hevc_frame_start(HEVCContext *s)
Definition: hevc.c:2462
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:781
unsigned int pps_id
address (in raster order) of the first block in the current slice segment
Definition: hevc.h:531
#define IS_BLA(s)
Definition: hevc.h:84
if(ac->has_optimized_func)
uint8_t sl[4][6][64]
Definition: hevc.h:380
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:484
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:81
int ff_hevc_split_coding_unit_flag_decode(HEVCContext *s, int ct_depth, int x0, int y0)
Definition: hevc_cabac.c:524
uint32_t vps_time_scale
Definition: hevc.h:371
Definition: hevc.h:133
int colour_description_present_flag
Definition: hevc.h:303
static const int8_t mv[256][2]
Definition: 4xm.c:72
HEVCFrame DPB[32]
Definition: hevc.h:795
Definition: hevc.h:384
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:158
static void hls_prediction_unit(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int partIdx)
Definition: hevc.c:1649
enum AVPixelFormat pix_fmt
Definition: hevc.h:397
Definition: hevc.h:357
RefPicListTab ** rpl_tab
Definition: hevc.h:681
NULL
Definition: eval.c:55
int slice_cb_qp_offset
Definition: hevc.h:570
void ff_hevc_dsp_init(HEVCDSPContext *hevcdsp, int bit_depth)
Definition: hevcdsp.c:114
static int width
Definition: utils.c:156
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:124
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
#define CTB(tab, x, y)
Definition: hevc.c:798
static int pic_arrays_init(HEVCContext *s, const HEVCSPS *sps)
Definition: hevc.c:189
static void pic_arrays_free(HEVCContext *s)
NOTE: Each function hls_foo correspond to the function foo in the specification (HLS stands for High ...
Definition: hevc.c:164
Definition: hevc.h:465
uint8_t transform_skip_enabled_flag
Definition: hevc.h:477
static av_cold int hevc_decode_init(AVCodecContext *avctx)
Definition: hevc.c:3189
#define IS_IRAP(s)
Definition: hevc.h:86
Definition: hevc.h:704
int ff_hevc_significant_coeff_flag_decode(HEVCContext *s, int c_idx, int x_c, int y_c, int log2_trafo_size, int scan_idx, int prev_sig)
Definition: hevc_cabac.c:772
Definition: h264.h:109
uint8_t is_nalff
this flag is != 0 if bitstream is encapsulated as a format defined in 14496-15
Definition: hevc.h:852
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:522
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:65
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:125
PTL ptl
Definition: hevc.h:410
int max_sub_layers
Definition: hevc.h:402
unsigned int log2_min_pu_size
Definition: hevc.h:441
int ff_hevc_decode_nal_pps(HEVCContext *s)
Definition: hevc_ps.c:984
int ff_hevc_abs_mvd_greater1_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:676
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:408
av_default_item_name
Definition: dnxhdenc.c:45
int8_t pred_flag[2]
Definition: hevc.h:628
uint8_t md5[3][16]
Definition: hevc.h:848
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:466
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
ScalingList scaling_list
Definition: hevc.h:508
main external API structure.
Definition: avcodec.h:1054
uint8_t is_md5
Definition: hevc.h:849
uint8_t sao_enabled
Definition: hevc.h:419
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:489
static int hevc_decode_extradata(HEVCContext *s)
Definition: hevc.c:3125
enum PredMode pred_mode
PredMode.
Definition: hevc.h:607
void(* transform_skip)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
Definition: hevcdsp.h:48
int num_extra_slice_header_bits
Definition: hevc.h:512
uint8_t * data
The data buffer.
Definition: buffer.h:89
int16_t y
vertical component of motion vector
Definition: hevc.h:622
Definition: hevc.h:111
void ff_hevc_clear_refs(HEVCContext *s)
Mark all frames in DPB as unused for reference.
Definition: hevc_refs.c:66
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:575
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:424
const HEVCVPS * vps
Definition: hevc.h:776
void av_md5_init(AVMD5 *ctx)
Definition: md5.c:134
TransformUnit tu
Definition: hevc.h:740
static void hls_decode_neighbour(HEVCContext *s, int x_ctb, int y_ctb, int ctb_addr_ts)
Definition: hevc.c:2280
void(* transform_4x4_luma_add)(uint8_t *dst, int16_t *coeffs, ptrdiff_t stride)
Definition: hevcdsp.h:49
uint32_t vui_num_units_in_tick
Definition: hevc.h:320
int extradata_size
Definition: avcodec.h:1163
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:81
uint8_t ctb_left_flag
Definition: hevc.h:742
int y
Definition: hevc.h:605
AVCodec ff_hevc_decoder
Definition: hevc.c:3257
uint8_t deblocking_filter_control_present_flag
Definition: hevc.h:501
int cu_qp_delta
Definition: hevc.h:660
uint8_t * is_pcm
Definition: hevc.h:824
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
void ff_hevc_pred_init(HEVCPredContext *hpc, int bit_depth)
Definition: hevcpred.c:37
uint8_t * checksum_buf
used on BE to byteswap the lines for checksumming
Definition: hevc.h:830
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:433
unsigned int nb_st_rps
Definition: hevc.h:415
int coded_height
Definition: avcodec.h:1227
AVFrame * tmp_frame
Definition: hevc.h:773
uint8_t cabac_init_flag
Definition: hevc.h:562
Describe the class of an AVClass context structure.
Definition: log.h:33
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
#define POS(c_idx, x, y)
int poc
Definition: hevc.h:683
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:226
static av_always_inline void set_ct_depth(HEVCContext *s, int x0, int y0, int log2_cb_size, int ct_depth)
Definition: hevc.c:2001
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1747
static void pred_weight_table(HEVCContext *s, GetBitContext *gb)
Definition: hevc.c:247
DSPContext dsp
Definition: hevc.h:809
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1740
#define EPEL_EXTRA
Definition: hevc.h:72
AVFrame * frame
Definition: hevc.h:771
void(* intra_pred)(struct HEVCContext *s, int x0, int y0, int log2_size, int c_idx)
Definition: hevc.h:715
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
int ff_hevc_sao_eo_class_decode(HEVCContext *s)
Definition: hevc_cabac.c:457
unsigned int max_num_merge_cand
5 - 5_minus_max_num_merge_cand
Definition: hevc.h:576
static const uint8_t diag_scan2x2_inv[2][2]
Definition: hevc.c:79
int checksum_buf_size
Definition: hevc.h:831
DBParams * deblock
Definition: hevc.h:791
GetBitContext gb
Definition: hevc.h:733
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
Definition: avcodec.h:2398
unsigned int log2_min_tb_size
Definition: hevc.h:438
int poc
Definition: hevc.h:796
#define L0
Definition: hevc.h:67
enum PartMode part_mode
PartMode.
Definition: hevc.h:608
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:422
int ff_hevc_slice_rpl(HEVCContext *s)
Construct the reference picture list(s) for the current slice.
Definition: hevc_refs.c:232
static int hls_nal_unit(HEVCContext *s)
Definition: hevc.c:2378
static const uint8_t horiz_scan4x4_x[16]
Definition: hevc.c:50
enum NALUnitType nal_unit_type
Definition: hevc.h:792
int start_of_tiles_x
Definition: hevc.h:746
Definition: hevc.h:620
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Definition: md5.c:160
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:79
HEVCWindow window
Definition: hevc.h:686
uint8_t scaling_list_enable_flag
Definition: hevc.h:412
int * tile_id
TileId.
Definition: hevc.h:524
static void set_deblocking_bypass(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:1320
static const uint8_t horiz_scan4x4_y[16]
Definition: hevc.c:57
int16_t luma_weight_l1[16]
Definition: hevc.h:588
int16_t chroma_log2_weight_denom
Definition: hevc.h:583
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:505
uint8_t transfer_characteristic
Definition: hevc.h:305
int pocTid0
Definition: hevc.h:797
uint8_t flags
A combination of HEVC_FRAME_FLAG_*.
Definition: hevc.h:701
Views are on top of each other.
Definition: stereo3d.h:52
Definition: hevc.h:208
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:273
int cr_qp_offset
Definition: hevc.h:483
ScalingList scaling_list
Definition: hevc.h:413
int ff_hevc_inter_pred_idc_decode(HEVCContext *s, int nPbW, int nPbH)
Definition: hevc_cabac.c:635
int ff_hevc_cbf_cb_cr_decode(HEVCContext *s, int trafo_depth)
Definition: hevc_cabac.c:707
static const uint16_t scale[4]
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:31
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:113
int ff_hevc_ref_idx_lx_decode(HEVCContext *s, int num_ref_idx_lx)
Definition: hevc_cabac.c:645
uint8_t level
Definition: svq3.c:143
uint8_t * split_cu_flag
Definition: hevc.h:811
uint8_t intra_pred_mode_c
Definition: hevc.h:647
static int hls_coding_quadtree(HEVCContext *s, int x0, int y0, int log2_cb_size, int cb_depth)
Definition: hevc.c:2228
uint8_t level_idc
Definition: hevc.h:342
int eos
current packet contains an EOS/EOB NAL
Definition: hevc.h:799
struct HEVCSPS::@23 temporal_layer[MAX_SUB_LAYERS]
int height
Definition: gxfenc.c:72
void ff_hevc_deblocking_boundary_strengths(HEVCContext *s, int x0, int y0, int log2_trafo_size, int slice_or_tiles_up_boundary, int slice_or_tiles_left_boundary)
Definition: hevc_filter.c:585
Views are next to each other.
Definition: stereo3d.h:42
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc.c:105
int ff_hevc_intra_chroma_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:608
int max_transform_hierarchy_depth_intra
coded frame dimension in various units
Definition: hevc.h:444
Mv mv[2]
Definition: hevc.h:626
int ff_hevc_no_residual_syntax_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:666
uint8_t * skip_flag
Definition: hevc.h:818
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:368
int8_t ref_idx[2]
Definition: hevc.h:627
static void hls_residual_coding(HEVCContext *s, int x0, int y0, int log2_trafo_size, enum ScanType scan_idx, int c_idx)
Definition: hevc.c:883
common internal and external API header
uint8_t slice_or_tiles_up_boundary
Definition: hevc.h:757
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:196
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:782
uint8_t weighted_pred_flag
Definition: hevc.h:485
uint8_t * horizontal_bs
Definition: hevc.h:812
Definition: hevc.h:246
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:1766
unsigned int nb_refs[2]
Definition: hevc.h:557
int32_t * tab_slice_address
Definition: hevc.h:815
uint8_t disable_deblocking_filter_flag
slice_header_disable_deblocking_filter_flag
Definition: hevc.h:563
static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: hevc.c:2910
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:516
static const uint8_t diag_scan2x2_x[4]
Definition: hevc.c:75
Definition: hevc.h:98
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:91
AVProfile.
Definition: avcodec.h:2743
uint8_t * filter_slice_edges
Definition: hevc.h:827
uint8_t slice_header_extension_present_flag
Definition: hevc.h:513
uint8_t collocated_list
Definition: hevc.h:565
static int decode_nal_unit(HEVCContext *s, const uint8_t *nal, int length)
Definition: hevc.c:2510
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:160
int ff_hevc_coeff_sign_flag(HEVCContext *s, uint8_t nb)
Definition: hevc_cabac.c:864
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: hevc.h:856
int den
denominator
Definition: rational.h:45
int slice_ctb_addr_rs
Definition: hevc.h:596
void ff_hevc_luma_mv_mvp_mode(HEVCContext *s, int x0, int y0, int nPbW, int nPbH, int log2_cb_size, int part_idx, int merge_idx, MvField *mv, int mvp_lx_flag, int LX)
Definition: hevc_mvs.c:626
AVBufferPool * tab_mvf_pool
Definition: hevc.h:783
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:498
int video_full_range_flag
Definition: hevc.h:302
int ff_hevc_cu_qp_delta_abs(HEVCContext *s)
Definition: hevc_cabac.c:489
DSP utils.
AVRational sar
Definition: hevc.h:295
uint8_t slice_loop_filter_across_slices_enabled_flag
Definition: hevc.h:564
void ff_hevc_cabac_init(HEVCContext *s, int ctb_addr_ts)
Definition: hevc_cabac.c:377
void * priv_data
Definition: avcodec.h:1090
uint8_t inter_split_flag
Definition: hevc.h:656
int ff_hevc_split_transform_flag_decode(HEVCContext *s, int log2_trafo_size)
Definition: hevc_cabac.c:702
unsigned int collocated_ref_idx
Definition: hevc.h:567
#define GET_COORD(offset, n)
uint8_t pcm_flag
Definition: hevc.h:612
CodingUnit cu
Definition: hevc.h:752
int len
int min_pu_width
Definition: hevc.h:456
static const uint8_t horiz_scan8x8_inv[8][8]
Definition: hevc.c:64
int ff_hevc_pred_mode_decode(HEVCContext *s)
Definition: hevc_cabac.c:519
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1098
int beta_offset
Definition: hevc.h:668
int ff_hevc_cu_qp_delta_sign_flag(HEVCContext *s)
Definition: hevc_cabac.c:514
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc.c:84
int ff_hevc_prev_intra_luma_pred_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:585
void ff_hevc_set_qPy(HEVCContext *s, int xC, int yC, int xBase, int yBase, int log2_cb_size)
Definition: hevc_filter.c:154
unsigned int list_entry_lx[2][32]
Definition: hevc.h:551
uint8_t luma_log2_weight_denom
Definition: hevc.h:582
static const uint8_t diag_scan4x4_inv[4][4]
Definition: hevc.c:98
int16_t chroma_weight_l1[16][2]
Definition: hevc.h:587
uint8_t slice_or_tiles_left_boundary
Definition: hevc.h:756
int ff_hevc_last_significant_coeff_suffix_decode(HEVCContext *s, int last_significant_coeff_prefix)
Definition: hevc_cabac.c:751
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:421
Definition: hevc.h:132
static void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.h:205
int ff_hevc_set_new_ref(HEVCContext *s, AVFrame **frame, int poc)
Definition: hevc_refs.c:122
static const uint8_t scan_1x1[1]
Definition: hevc.c:44
int ff_hevc_last_significant_coeff_x_prefix_decode(HEVCContext *s, int c_idx, int log2_size)
Definition: hevc_cabac.c:739
int diff_cu_qp_delta_depth
Definition: hevc.h:480
int ff_hevc_sao_offset_abs_decode(HEVCContext *s)
Definition: hevc_cabac.c:442
int cur_intra_pred_mode
Definition: hevc.h:663
int ff_hevc_pcm_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:580
int num_reorder_pics
Definition: hevc.h:405
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc.c:124
#define av_always_inline
Definition: attributes.h:40
int cb_qp_offset
Definition: hevc.h:482
uint8_t context_initialized
Definition: hevc.h:851
AVBufferRef * rpl_buf
Definition: hevc.h:690
int is_decoded
Definition: hevc.h:804
int video_signal_type_present_flag
Definition: hevc.h:300
#define FFSWAP(type, a, b)
Definition: common.h:60
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:502
int bit_depth
Definition: hevc.h:395
enum SliceType slice_type
Definition: hevc.h:538
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:504
int min_tb_height
Definition: hevc.h:455
static const uint8_t horiz_scan2x2_y[4]
Definition: hevc.c:48
static const uint8_t diag_scan2x2_y[4]
Definition: hevc.c:77
#define L1
Definition: hevc.h:68
uint8_t * cbf_luma
Definition: hevc.h:823
int ff_hevc_sao_merge_flag_decode(HEVCContext *s)
Definition: hevc_cabac.c:417
#define AV_RN64A(p)
Definition: intreadwrite.h:450
SliceHeader sh
Definition: hevc.h:789
ScanType
Definition: hevc.h:257
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:400
static av_cold int hevc_decode_free(AVCodecContext *avctx)
Definition: hevc.c:2986
This structure stores compressed data.
Definition: avcodec.h:950
uint8_t mvd_l1_zero_flag
Definition: hevc.h:560
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:877
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t buf_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:52
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
static int hevc_ref_frame(HEVCContext *s, HEVCFrame *dst, HEVCFrame *src)
Definition: hevc.c:2954
static const uint8_t diag_scan8x8_inv[8][8]
Definition: hevc.c:143
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:387
static const AVProfile profiles[]
Definition: hevc.c:3237
#define FFMAX3(a, b, c)
Definition: common.h:56
int end_of_tiles_y
Definition: hevc.h:748
uint8_t rqt_root_cbf
Definition: hevc.h:610
static void intra_prediction_unit_default_value(HEVCContext *s, int x0, int y0, int log2_cb_size)
Definition: hevc.c:2054
uint8_t slice_sample_adaptive_offset_flag[3]
Definition: hevc.h:559
#define SAMPLE_CTB(tab, x, y)
Definition: hevc.h:80
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:490
int offset_sign[3][4]
sao_offset_sign
Definition: hevcdsp.h:30