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