FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevc_ps.c
Go to the documentation of this file.
1 /*
2  * HEVC Parameter Set decoding
3  *
4  * Copyright (C) 2012 - 2103 Guillaume Martres
5  * Copyright (C) 2012 - 2103 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2013 Vittorio Giovara
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/imgutils.h"
27 #include "golomb.h"
28 #include "hevc.h"
29 
31  16, 16, 16, 16, 17, 18, 21, 24,
32  16, 16, 16, 16, 17, 19, 22, 25,
33  16, 16, 17, 18, 20, 22, 25, 29,
34  16, 16, 18, 21, 24, 27, 31, 36,
35  17, 17, 20, 24, 30, 35, 41, 47,
36  18, 19, 22, 27, 35, 44, 54, 65,
37  21, 22, 25, 31, 41, 54, 70, 88,
38  24, 25, 29, 36, 47, 65, 88, 115
39 };
40 
42  16, 16, 16, 16, 17, 18, 20, 24,
43  16, 16, 16, 17, 18, 20, 24, 25,
44  16, 16, 17, 18, 20, 24, 25, 28,
45  16, 17, 18, 20, 24, 25, 28, 33,
46  17, 18, 20, 24, 25, 28, 33, 41,
47  18, 20, 24, 25, 28, 33, 41, 54,
48  20, 24, 25, 28, 33, 41, 54, 71,
49  24, 25, 28, 33, 41, 54, 71, 91
50 };
51 
52 static const AVRational vui_sar[] = {
53  { 0, 1 },
54  { 1, 1 },
55  { 12, 11 },
56  { 10, 11 },
57  { 16, 11 },
58  { 40, 33 },
59  { 24, 11 },
60  { 20, 11 },
61  { 32, 11 },
62  { 80, 33 },
63  { 18, 11 },
64  { 15, 11 },
65  { 64, 33 },
66  { 160, 99 },
67  { 4, 3 },
68  { 3, 2 },
69  { 2, 1 },
70 };
71 
72 static void remove_pps(HEVCParamSets *s, int id)
73 {
74  if (s->pps_list[id] && s->pps == (const HEVCPPS*)s->pps_list[id]->data)
75  s->pps = NULL;
76  av_buffer_unref(&s->pps_list[id]);
77 }
78 
79 static void remove_sps(HEVCParamSets *s, int id)
80 {
81  int i;
82  if (s->sps_list[id]) {
83  if (s->sps == (const HEVCSPS*)s->sps_list[id]->data)
84  s->sps = NULL;
85 
86  /* drop all PPS that depend on this SPS */
87  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
88  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == id)
89  remove_pps(s, i);
90 
91  av_assert0(!(s->sps_list[id] && s->sps == (HEVCSPS*)s->sps_list[id]->data));
92  }
93  av_buffer_unref(&s->sps_list[id]);
94 }
95 
96 static void remove_vps(HEVCParamSets *s, int id)
97 {
98  int i;
99  if (s->vps_list[id]) {
100  if (s->vps == (const HEVCVPS*)s->vps_list[id]->data)
101  s->vps = NULL;
102 
103  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
104  if (s->sps_list[i] && ((HEVCSPS*)s->sps_list[i]->data)->vps_id == id)
105  remove_sps(s, i);
106  }
107  av_buffer_unref(&s->vps_list[id]);
108 }
109 
111  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
112 {
113  uint8_t rps_predict = 0;
114  int delta_poc;
115  int k0 = 0;
116  int k1 = 0;
117  int k = 0;
118  int i;
119 
120  if (rps != sps->st_rps && sps->nb_st_rps)
121  rps_predict = get_bits1(gb);
122 
123  if (rps_predict) {
124  const ShortTermRPS *rps_ridx;
125  int delta_rps;
126  unsigned abs_delta_rps;
127  uint8_t use_delta_flag = 0;
128  uint8_t delta_rps_sign;
129 
130  if (is_slice_header) {
131  unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
132  if (delta_idx > sps->nb_st_rps) {
133  av_log(avctx, AV_LOG_ERROR,
134  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
135  delta_idx, sps->nb_st_rps);
136  return AVERROR_INVALIDDATA;
137  }
138  rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
139  rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
140  } else
141  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
142 
143  delta_rps_sign = get_bits1(gb);
144  abs_delta_rps = get_ue_golomb_long(gb) + 1;
145  if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
146  av_log(avctx, AV_LOG_ERROR,
147  "Invalid value of abs_delta_rps: %d\n",
148  abs_delta_rps);
149  return AVERROR_INVALIDDATA;
150  }
151  delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
152  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
153  int used = rps->used[k] = get_bits1(gb);
154 
155  if (!used)
156  use_delta_flag = get_bits1(gb);
157 
158  if (used || use_delta_flag) {
159  if (i < rps_ridx->num_delta_pocs)
160  delta_poc = delta_rps + rps_ridx->delta_poc[i];
161  else
162  delta_poc = delta_rps;
163  rps->delta_poc[k] = delta_poc;
164  if (delta_poc < 0)
165  k0++;
166  else
167  k1++;
168  k++;
169  }
170  }
171 
172  rps->num_delta_pocs = k;
173  rps->num_negative_pics = k0;
174  // sort in increasing order (smallest first)
175  if (rps->num_delta_pocs != 0) {
176  int used, tmp;
177  for (i = 1; i < rps->num_delta_pocs; i++) {
178  delta_poc = rps->delta_poc[i];
179  used = rps->used[i];
180  for (k = i - 1; k >= 0; k--) {
181  tmp = rps->delta_poc[k];
182  if (delta_poc < tmp) {
183  rps->delta_poc[k + 1] = tmp;
184  rps->used[k + 1] = rps->used[k];
185  rps->delta_poc[k] = delta_poc;
186  rps->used[k] = used;
187  }
188  }
189  }
190  }
191  if ((rps->num_negative_pics >> 1) != 0) {
192  int used;
193  k = rps->num_negative_pics - 1;
194  // flip the negative values to largest first
195  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
196  delta_poc = rps->delta_poc[i];
197  used = rps->used[i];
198  rps->delta_poc[i] = rps->delta_poc[k];
199  rps->used[i] = rps->used[k];
200  rps->delta_poc[k] = delta_poc;
201  rps->used[k] = used;
202  k--;
203  }
204  }
205  } else {
206  unsigned int prev, nb_positive_pics;
208  nb_positive_pics = get_ue_golomb_long(gb);
209 
210  if (rps->num_negative_pics >= MAX_REFS ||
211  nb_positive_pics >= MAX_REFS) {
212  av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
213  return AVERROR_INVALIDDATA;
214  }
215 
216  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
217  if (rps->num_delta_pocs) {
218  prev = 0;
219  for (i = 0; i < rps->num_negative_pics; i++) {
220  delta_poc = get_ue_golomb_long(gb) + 1;
221  prev -= delta_poc;
222  rps->delta_poc[i] = prev;
223  rps->used[i] = get_bits1(gb);
224  }
225  prev = 0;
226  for (i = 0; i < nb_positive_pics; i++) {
227  delta_poc = get_ue_golomb_long(gb) + 1;
228  prev += delta_poc;
229  rps->delta_poc[rps->num_negative_pics + i] = prev;
230  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
231  }
232  }
233  }
234  return 0;
235 }
236 
237 
239  PTLCommon *ptl)
240 {
241  int i;
242 
243  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
244  return -1;
245 
246  ptl->profile_space = get_bits(gb, 2);
247  ptl->tier_flag = get_bits1(gb);
248  ptl->profile_idc = get_bits(gb, 5);
249  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
250  av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
251  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
252  av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
254  av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
255  else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
256  av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
257  else
258  av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
259 
260  for (i = 0; i < 32; i++) {
262 
263  if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i])
264  ptl->profile_idc = i;
265  }
270 
271  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
272  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
273  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
274 
275  return 0;
276 }
277 
278 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
279  PTL *ptl, int max_num_sub_layers)
280 {
281  int i;
282  if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
283  get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
284  av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
285  return -1;
286  }
287 
288  ptl->general_ptl.level_idc = get_bits(gb, 8);
289 
290  for (i = 0; i < max_num_sub_layers - 1; i++) {
293  }
294 
295  if (max_num_sub_layers - 1> 0)
296  for (i = max_num_sub_layers - 1; i < 8; i++)
297  skip_bits(gb, 2); // reserved_zero_2bits[i]
298  for (i = 0; i < max_num_sub_layers - 1; i++) {
299  if (ptl->sub_layer_profile_present_flag[i] &&
300  decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
301  av_log(avctx, AV_LOG_ERROR,
302  "PTL information for sublayer %i too short\n", i);
303  return -1;
304  }
305  if (ptl->sub_layer_level_present_flag[i]) {
306  if (get_bits_left(gb) < 8) {
307  av_log(avctx, AV_LOG_ERROR,
308  "Not enough data for sublayer %i level_idc\n", i);
309  return -1;
310  } else
311  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
312  }
313  }
314 
315  return 0;
316 }
317 
318 static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
319  int subpic_params_present)
320 {
321  int i;
322 
323  for (i = 0; i < nb_cpb; i++) {
324  get_ue_golomb_long(gb); // bit_rate_value_minus1
325  get_ue_golomb_long(gb); // cpb_size_value_minus1
326 
327  if (subpic_params_present) {
328  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
329  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
330  }
331  skip_bits1(gb); // cbr_flag
332  }
333 }
334 
335 static int decode_hrd(GetBitContext *gb, int common_inf_present,
336  int max_sublayers)
337 {
338  int nal_params_present = 0, vcl_params_present = 0;
339  int subpic_params_present = 0;
340  int i;
341 
342  if (common_inf_present) {
343  nal_params_present = get_bits1(gb);
344  vcl_params_present = get_bits1(gb);
345 
346  if (nal_params_present || vcl_params_present) {
347  subpic_params_present = get_bits1(gb);
348 
349  if (subpic_params_present) {
350  skip_bits(gb, 8); // tick_divisor_minus2
351  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
352  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
353  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
354  }
355 
356  skip_bits(gb, 4); // bit_rate_scale
357  skip_bits(gb, 4); // cpb_size_scale
358 
359  if (subpic_params_present)
360  skip_bits(gb, 4); // cpb_size_du_scale
361 
362  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
363  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
364  skip_bits(gb, 5); // dpb_output_delay_length_minus1
365  }
366  }
367 
368  for (i = 0; i < max_sublayers; i++) {
369  int low_delay = 0;
370  unsigned int nb_cpb = 1;
371  int fixed_rate = get_bits1(gb);
372 
373  if (!fixed_rate)
374  fixed_rate = get_bits1(gb);
375 
376  if (fixed_rate)
377  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
378  else
379  low_delay = get_bits1(gb);
380 
381  if (!low_delay) {
382  nb_cpb = get_ue_golomb_long(gb) + 1;
383  if (nb_cpb < 1 || nb_cpb > 32) {
384  av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
385  return AVERROR_INVALIDDATA;
386  }
387  }
388 
389  if (nal_params_present)
390  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
391  if (vcl_params_present)
392  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
393  }
394  return 0;
395 }
396 
398  HEVCParamSets *ps)
399 {
400  int i,j;
401  int vps_id = 0;
402  HEVCVPS *vps;
403  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
404 
405  if (!vps_buf)
406  return AVERROR(ENOMEM);
407  vps = (HEVCVPS*)vps_buf->data;
408 
409  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
410 
411  vps_id = get_bits(gb, 4);
412  if (vps_id >= MAX_VPS_COUNT) {
413  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
414  goto err;
415  }
416 
417  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
418  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
419  goto err;
420  }
421 
422  vps->vps_max_layers = get_bits(gb, 6) + 1;
423  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
425 
426  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
427  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
428  goto err;
429  }
430 
431  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
432  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
433  vps->vps_max_sub_layers);
434  goto err;
435  }
436 
437  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
438  goto err;
439 
441 
443  for (; i < vps->vps_max_sub_layers; i++) {
447 
449  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
450  vps->vps_max_dec_pic_buffering[i] - 1);
451  goto err;
452  }
453  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
454  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
455  vps->vps_num_reorder_pics[i]);
456  if (avctx->err_recognition & AV_EF_EXPLODE)
457  goto err;
458  }
459  }
460 
461  vps->vps_max_layer_id = get_bits(gb, 6);
462  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
463  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
464  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
465  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
466  goto err;
467  }
468 
469  for (i = 1; i < vps->vps_num_layer_sets; i++)
470  for (j = 0; j <= vps->vps_max_layer_id; j++)
471  skip_bits(gb, 1); // layer_id_included_flag[i][j]
472 
474  if (vps->vps_timing_info_present_flag) {
475  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
476  vps->vps_time_scale = get_bits_long(gb, 32);
481  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
482  av_log(avctx, AV_LOG_ERROR,
483  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
484  goto err;
485  }
486  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
487  int common_inf_present = 1;
488 
489  get_ue_golomb_long(gb); // hrd_layer_set_idx
490  if (i)
491  common_inf_present = get_bits1(gb);
492  decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
493  }
494  }
495  get_bits1(gb); /* vps_extension_flag */
496 
497  if (get_bits_left(gb) < 0) {
498  av_log(avctx, AV_LOG_ERROR,
499  "Overread VPS by %d bits\n", -get_bits_left(gb));
500  if (ps->vps_list[vps_id])
501  goto err;
502  }
503 
504  if (ps->vps_list[vps_id] &&
505  !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
506  av_buffer_unref(&vps_buf);
507  } else {
508  remove_vps(ps, vps_id);
509  ps->vps_list[vps_id] = vps_buf;
510  }
511 
512  return 0;
513 
514 err:
515  av_buffer_unref(&vps_buf);
516  return AVERROR_INVALIDDATA;
517 }
518 
519 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
520  int apply_defdispwin, HEVCSPS *sps)
521 {
522  VUI *vui = &sps->vui;
523  GetBitContext backup;
524  int sar_present, alt = 0;
525 
526  av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
527 
528  sar_present = get_bits1(gb);
529  if (sar_present) {
530  uint8_t sar_idx = get_bits(gb, 8);
531  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
532  vui->sar = vui_sar[sar_idx];
533  else if (sar_idx == 255) {
534  vui->sar.num = get_bits(gb, 16);
535  vui->sar.den = get_bits(gb, 16);
536  } else
537  av_log(avctx, AV_LOG_WARNING,
538  "Unknown SAR index: %u.\n", sar_idx);
539  }
540 
544 
547  vui->video_format = get_bits(gb, 3);
548  vui->video_full_range_flag = get_bits1(gb);
553  vui->colour_primaries = get_bits(gb, 8);
554  vui->transfer_characteristic = get_bits(gb, 8);
555  vui->matrix_coeffs = get_bits(gb, 8);
556 
557  // Set invalid values to "unspecified"
558  if (vui->colour_primaries >= AVCOL_PRI_NB)
562  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
564  if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
565  switch (sps->pix_fmt) {
566  case AV_PIX_FMT_YUV444P:
567  sps->pix_fmt = AV_PIX_FMT_GBRP;
568  break;
570  sps->pix_fmt = AV_PIX_FMT_GBRP10;
571  break;
573  sps->pix_fmt = AV_PIX_FMT_GBRP12;
574  break;
575  }
576  }
577  }
578  }
579 
581  if (vui->chroma_loc_info_present_flag) {
584  }
585 
587  vui->field_seq_flag = get_bits1(gb);
589 
590  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
592  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
593  } else
595  // Backup context in case an alternate header is detected
596  memcpy(&backup, gb, sizeof(backup));
597 
598  if (vui->default_display_window_flag) {
599  int vert_mult = 1 + (sps->chroma_format_idc < 2);
600  int horiz_mult = 1 + (sps->chroma_format_idc < 3);
601  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
602  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
603  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
604  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
605 
606  if (apply_defdispwin &&
608  av_log(avctx, AV_LOG_DEBUG,
609  "discarding vui default display window, "
610  "original values are l:%u r:%u t:%u b:%u\n",
615 
618  vui->def_disp_win.top_offset =
619  vui->def_disp_win.bottom_offset = 0;
620  }
621  }
622 
624 
625  if (vui->vui_timing_info_present_flag) {
626  if( get_bits_left(gb) < 66) {
627  // The alternate syntax seem to have timing info located
628  // at where def_disp_win is normally located
629  av_log(avctx, AV_LOG_WARNING,
630  "Strange VUI timing information, retrying...\n");
632  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
633  memcpy(gb, &backup, sizeof(backup));
634  alt = 1;
635  }
636  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
637  vui->vui_time_scale = get_bits_long(gb, 32);
638  if (alt) {
639  av_log(avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
641  }
647  decode_hrd(gb, 1, sps->max_sub_layers);
648  }
649 
651  if (vui->bitstream_restriction_flag) {
660  }
661 }
662 
664 {
665  int matrixId;
666 
667  for (matrixId = 0; matrixId < 6; matrixId++) {
668  // 4x4 default is 16
669  memset(sl->sl[0][matrixId], 16, 16);
670  sl->sl_dc[0][matrixId] = 16; // default for 16x16
671  sl->sl_dc[1][matrixId] = 16; // default for 32x32
672  }
673  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
674  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
675  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
676  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
677  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
678  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
679  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
680  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
681  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
682  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
683  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
684  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
685  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
686  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
687  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
688  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
689  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
690  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
691 }
692 
694 {
695  uint8_t scaling_list_pred_mode_flag;
696  int32_t scaling_list_dc_coef[2][6];
697  int size_id, matrix_id, pos;
698  int i;
699 
700  for (size_id = 0; size_id < 4; size_id++)
701  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
702  scaling_list_pred_mode_flag = get_bits1(gb);
703  if (!scaling_list_pred_mode_flag) {
704  unsigned int delta = get_ue_golomb_long(gb);
705  /* Only need to handle non-zero delta. Zero means default,
706  * which should already be in the arrays. */
707  if (delta) {
708  // Copy from previous array.
709  if (matrix_id < delta) {
710  av_log(avctx, AV_LOG_ERROR,
711  "Invalid delta in scaling list data: %d.\n", delta);
712  return AVERROR_INVALIDDATA;
713  }
714 
715  memcpy(sl->sl[size_id][matrix_id],
716  sl->sl[size_id][matrix_id - delta],
717  size_id > 0 ? 64 : 16);
718  if (size_id > 1)
719  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
720  }
721  } else {
722  int next_coef, coef_num;
723  int32_t scaling_list_delta_coef;
724 
725  next_coef = 8;
726  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
727  if (size_id > 1) {
728  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
729  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
730  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
731  }
732  for (i = 0; i < coef_num; i++) {
733  if (size_id == 0)
734  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
736  else
737  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
739 
740  scaling_list_delta_coef = get_se_golomb(gb);
741  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
742  sl->sl[size_id][matrix_id][pos] = next_coef;
743  }
744  }
745  }
746 
747  if (sps->chroma_format_idc == 3) {
748  for (i = 0; i < 64; i++) {
749  sl->sl[3][1][i] = sl->sl[2][1][i];
750  sl->sl[3][2][i] = sl->sl[2][2][i];
751  sl->sl[3][4][i] = sl->sl[2][4][i];
752  sl->sl[3][5][i] = sl->sl[2][5][i];
753  }
754  sl->sl_dc[1][1] = sl->sl_dc[0][1];
755  sl->sl_dc[1][2] = sl->sl_dc[0][2];
756  sl->sl_dc[1][4] = sl->sl_dc[0][4];
757  sl->sl_dc[1][5] = sl->sl_dc[0][5];
758  }
759 
760 
761  return 0;
762 }
763 
764 static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
765 {
766  const AVPixFmtDescriptor *desc;
767  switch (sps->bit_depth) {
768  case 8:
769  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
770  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
771  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
772  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
773  break;
774  case 9:
775  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
776  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
777  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
778  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
779  break;
780  case 10:
781  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
782  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
783  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
784  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
785  break;
786  case 12:
787  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
788  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
789  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
790  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
791  break;
792  default:
793  av_log(avctx, AV_LOG_ERROR,
794  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
795  av_log(avctx, AV_LOG_ERROR,
796  "chroma_format_idc is %d, depth is %d",
797  sps->chroma_format_idc, sps->bit_depth);
798  return AVERROR_INVALIDDATA;
799  }
800 
801  desc = av_pix_fmt_desc_get(sps->pix_fmt);
802  if (!desc)
803  return AVERROR(EINVAL);
804 
805  sps->hshift[0] = sps->vshift[0] = 0;
806  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
807  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
808 
809  sps->pixel_shift = sps->bit_depth > 8;
810 
811  return 0;
812 }
813 
814 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
815  int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
816 {
817  int ret = 0;
818  int log2_diff_max_min_transform_block_size;
819  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
820  int i;
821 
822  // Coded parameters
823 
824  sps->vps_id = get_bits(gb, 4);
825  if (sps->vps_id >= MAX_VPS_COUNT) {
826  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
827  return AVERROR_INVALIDDATA;
828  }
829 
830  if (vps_list && !vps_list[sps->vps_id]) {
831  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
832  sps->vps_id);
833  return AVERROR_INVALIDDATA;
834  }
835 
836  sps->max_sub_layers = get_bits(gb, 3) + 1;
837  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
838  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
839  sps->max_sub_layers);
840  return AVERROR_INVALIDDATA;
841  }
842 
843  skip_bits1(gb); // temporal_id_nesting_flag
844 
845  if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
846  return ret;
847 
848  *sps_id = get_ue_golomb_long(gb);
849  if (*sps_id >= MAX_SPS_COUNT) {
850  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
851  return AVERROR_INVALIDDATA;
852  }
853 
855  if (sps->chroma_format_idc > 3U) {
856  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
857  return AVERROR_INVALIDDATA;
858  }
859 
860  if (sps->chroma_format_idc == 3)
862 
864  sps->chroma_format_idc = 0;
865 
866  sps->width = get_ue_golomb_long(gb);
867  sps->height = get_ue_golomb_long(gb);
868  if ((ret = av_image_check_size(sps->width,
869  sps->height, 0, avctx)) < 0)
870  return ret;
871 
872  if (get_bits1(gb)) { // pic_conformance_flag
873  int vert_mult = 1 + (sps->chroma_format_idc < 2);
874  int horiz_mult = 1 + (sps->chroma_format_idc < 3);
875  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
876  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
877  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
878  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
879 
880  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
881  av_log(avctx, AV_LOG_DEBUG,
882  "discarding sps conformance window, "
883  "original values are l:%u r:%u t:%u b:%u\n",
888 
891  sps->pic_conf_win.top_offset =
892  sps->pic_conf_win.bottom_offset = 0;
893  }
894  sps->output_window = sps->pic_conf_win;
895  }
896 
897  sps->bit_depth = get_ue_golomb_long(gb) + 8;
898  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
899  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
900  av_log(avctx, AV_LOG_ERROR,
901  "Luma bit depth (%d) is different from chroma bit depth (%d), "
902  "this is unsupported.\n",
903  sps->bit_depth, bit_depth_chroma);
904  return AVERROR_INVALIDDATA;
905  }
906 
907  ret = map_pixel_format(avctx, sps);
908  if (ret < 0)
909  return ret;
910 
911  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
912  if (sps->log2_max_poc_lsb > 16) {
913  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
914  sps->log2_max_poc_lsb - 4);
915  return AVERROR_INVALIDDATA;
916  }
917 
918  sublayer_ordering_info = get_bits1(gb);
919  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
920  for (i = start; i < sps->max_sub_layers; i++) {
925  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
927  return AVERROR_INVALIDDATA;
928  }
930  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
932  if (avctx->err_recognition & AV_EF_EXPLODE ||
934  return AVERROR_INVALIDDATA;
935  }
937  }
938  }
939 
940  if (!sublayer_ordering_info) {
941  for (i = 0; i < start; i++) {
945  }
946  }
947 
948  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
950  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
951  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
952  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
953  sps->log2_min_tb_size;
954 
955  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
956  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
957  return AVERROR_INVALIDDATA;
958  }
959 
960  if (sps->log2_diff_max_min_coding_block_size > 30) {
961  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_coding_block_size", sps->log2_diff_max_min_coding_block_size);
962  return AVERROR_INVALIDDATA;
963  }
964 
965  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
966  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
967  return AVERROR_INVALIDDATA;
968  }
969 
970  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
971  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
972  return AVERROR_INVALIDDATA;
973  }
974 
977 
979  if (sps->scaling_list_enable_flag) {
981 
982  if (get_bits1(gb)) {
983  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
984  if (ret < 0)
985  return ret;
986  }
987  }
988 
989  sps->amp_enabled_flag = get_bits1(gb);
990  sps->sao_enabled = get_bits1(gb);
991 
992  sps->pcm_enabled_flag = get_bits1(gb);
993  if (sps->pcm_enabled_flag) {
994  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
995  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
998  get_ue_golomb_long(gb);
999  if (sps->pcm.bit_depth > sps->bit_depth) {
1000  av_log(avctx, AV_LOG_ERROR,
1001  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
1002  sps->pcm.bit_depth, sps->bit_depth);
1003  return AVERROR_INVALIDDATA;
1004  }
1005 
1007  }
1008 
1009  sps->nb_st_rps = get_ue_golomb_long(gb);
1010  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
1011  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1012  sps->nb_st_rps);
1013  return AVERROR_INVALIDDATA;
1014  }
1015  for (i = 0; i < sps->nb_st_rps; i++) {
1016  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1017  sps, 0)) < 0)
1018  return ret;
1019  }
1020 
1024  if (sps->num_long_term_ref_pics_sps > 31U) {
1025  av_log(avctx, AV_LOG_ERROR, "num_long_term_ref_pics_sps %d is out of range.\n",
1027  return AVERROR_INVALIDDATA;
1028  }
1029  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1030  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1032  }
1033  }
1034 
1037  sps->vui.sar = (AVRational){0, 1};
1038  vui_present = get_bits1(gb);
1039  if (vui_present)
1040  decode_vui(gb, avctx, apply_defdispwin, sps);
1041 
1042  if (get_bits1(gb)) { // sps_extension_flag
1043  int sps_extension_flag[1];
1044  for (i = 0; i < 1; i++)
1045  sps_extension_flag[i] = get_bits1(gb);
1046  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1047  if (sps_extension_flag[0]) {
1048  int extended_precision_processing_flag;
1049  int high_precision_offsets_enabled_flag;
1050  int cabac_bypass_alignment_enabled_flag;
1051 
1055 
1057 
1058  extended_precision_processing_flag = get_bits1(gb);
1059  if (extended_precision_processing_flag)
1060  av_log(avctx, AV_LOG_WARNING,
1061  "extended_precision_processing_flag not yet implemented\n");
1062 
1064  high_precision_offsets_enabled_flag = get_bits1(gb);
1065  if (high_precision_offsets_enabled_flag)
1066  av_log(avctx, AV_LOG_WARNING,
1067  "high_precision_offsets_enabled_flag not yet implemented\n");
1068 
1070 
1071  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1072  if (cabac_bypass_alignment_enabled_flag)
1073  av_log(avctx, AV_LOG_WARNING,
1074  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1075  }
1076  }
1077  if (apply_defdispwin) {
1082  }
1083  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1084  !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
1085  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1086  av_log(avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1087  "chroma samples to preserve alignment.\n",
1088  sps->output_window.left_offset);
1089  }
1090  sps->output_width = sps->width -
1092  sps->output_height = sps->height -
1094  if (sps->width <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset ||
1095  sps->height <= sps->output_window.top_offset + (int64_t)sps->output_window.bottom_offset) {
1096  av_log(avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1097  sps->output_width, sps->output_height);
1098  if (avctx->err_recognition & AV_EF_EXPLODE) {
1099  return AVERROR_INVALIDDATA;
1100  }
1101  av_log(avctx, AV_LOG_WARNING,
1102  "Displaying the whole video surface.\n");
1103  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1104  memset(&sps->output_window, 0, sizeof(sps->output_window));
1105  sps->output_width = sps->width;
1106  sps->output_height = sps->height;
1107  }
1108 
1109  // Inferred parameters
1110  sps->log2_ctb_size = sps->log2_min_cb_size +
1112  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1113 
1114  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1115  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1116  return AVERROR_INVALIDDATA;
1117  }
1118  if (sps->log2_ctb_size < 4) {
1119  av_log(avctx,
1120  AV_LOG_ERROR,
1121  "log2_ctb_size %d differs from the bounds of any known profile\n",
1122  sps->log2_ctb_size);
1123  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1124  return AVERROR_INVALIDDATA;
1125  }
1126 
1127  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1128  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1129  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1130 
1131  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1132  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1133  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1134  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1135  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1136  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1137  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1138 
1139  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1140 
1141  if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
1142  av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1143  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1144  return AVERROR_INVALIDDATA;
1145  }
1146 
1148  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1150  return AVERROR_INVALIDDATA;
1151  }
1153  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1155  return AVERROR_INVALIDDATA;
1156  }
1157  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1158  av_log(avctx, AV_LOG_ERROR,
1159  "max transform block size out of range: %d\n",
1160  sps->log2_max_trafo_size);
1161  return AVERROR_INVALIDDATA;
1162  }
1163 
1164  if (get_bits_left(gb) < 0) {
1165  av_log(avctx, AV_LOG_ERROR,
1166  "Overread SPS by %d bits\n", -get_bits_left(gb));
1167  return AVERROR_INVALIDDATA;
1168  }
1169 
1170  return 0;
1171 }
1172 
1174  HEVCParamSets *ps, int apply_defdispwin)
1175 {
1176  HEVCSPS *sps;
1177  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
1178  unsigned int sps_id;
1179  int ret;
1180 
1181  if (!sps_buf)
1182  return AVERROR(ENOMEM);
1183  sps = (HEVCSPS*)sps_buf->data;
1184 
1185  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1186 
1187  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1188  apply_defdispwin,
1189  ps->vps_list, avctx);
1190  if (ret < 0) {
1191  av_buffer_unref(&sps_buf);
1192  return ret;
1193  }
1194 
1195  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1196  av_log(avctx, AV_LOG_DEBUG,
1197  "Parsed SPS: id %d; coded wxh: %dx%d; "
1198  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1199  sps_id, sps->width, sps->height,
1200  sps->output_width, sps->output_height,
1202  }
1203 
1204  /* check if this is a repeat of an already parsed SPS, then keep the
1205  * original one.
1206  * otherwise drop all PPSes that depend on it */
1207  if (ps->sps_list[sps_id] &&
1208  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1209  av_buffer_unref(&sps_buf);
1210  } else {
1211  remove_sps(ps, sps_id);
1212  ps->sps_list[sps_id] = sps_buf;
1213  }
1214 
1215  return 0;
1216 }
1217 
1218 static void hevc_pps_free(void *opaque, uint8_t *data)
1219 {
1220  HEVCPPS *pps = (HEVCPPS*)data;
1221 
1222  av_freep(&pps->column_width);
1223  av_freep(&pps->row_height);
1224  av_freep(&pps->col_bd);
1225  av_freep(&pps->row_bd);
1226  av_freep(&pps->col_idxX);
1227  av_freep(&pps->ctb_addr_rs_to_ts);
1228  av_freep(&pps->ctb_addr_ts_to_rs);
1229  av_freep(&pps->tile_pos_rs);
1230  av_freep(&pps->tile_id);
1232 
1233  av_freep(&pps);
1234 }
1235 
1237  HEVCPPS *pps, HEVCSPS *sps) {
1238  int i;
1239 
1240  if (pps->transform_skip_enabled_flag) {
1242  }
1249  av_log(avctx, AV_LOG_ERROR,
1250  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1251  return AVERROR_INVALIDDATA;
1252  }
1253  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1254  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1255  if (pps->cb_qp_offset_list[i]) {
1256  av_log(avctx, AV_LOG_WARNING,
1257  "cb_qp_offset_list not tested yet.\n");
1258  }
1259  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1260  if (pps->cr_qp_offset_list[i]) {
1261  av_log(avctx, AV_LOG_WARNING,
1262  "cb_qp_offset_list not tested yet.\n");
1263  }
1264  }
1265  }
1268 
1269  return(0);
1270 }
1271 
1272 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1273  HEVCPPS *pps, HEVCSPS *sps)
1274 {
1275  int log2_diff;
1276  int pic_area_in_ctbs;
1277  int i, j, x, y, ctb_addr_rs, tile_id;
1278 
1279  // Inferred parameters
1280  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1281  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1282  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1283  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1284  return AVERROR(ENOMEM);
1285 
1286  if (pps->uniform_spacing_flag) {
1287  if (!pps->column_width) {
1288  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1289  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1290  }
1291  if (!pps->column_width || !pps->row_height)
1292  return AVERROR(ENOMEM);
1293 
1294  for (i = 0; i < pps->num_tile_columns; i++) {
1295  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1296  (i * sps->ctb_width) / pps->num_tile_columns;
1297  }
1298 
1299  for (i = 0; i < pps->num_tile_rows; i++) {
1300  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1301  (i * sps->ctb_height) / pps->num_tile_rows;
1302  }
1303  }
1304 
1305  pps->col_bd[0] = 0;
1306  for (i = 0; i < pps->num_tile_columns; i++)
1307  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1308 
1309  pps->row_bd[0] = 0;
1310  for (i = 0; i < pps->num_tile_rows; i++)
1311  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1312 
1313  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1314  if (i > pps->col_bd[j])
1315  j++;
1316  pps->col_idxX[i] = j;
1317  }
1318 
1319  /**
1320  * 6.5
1321  */
1322  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1323 
1324  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1325  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1326  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1327  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1328  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1329  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1330  return AVERROR(ENOMEM);
1331  }
1332 
1333  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1334  int tb_x = ctb_addr_rs % sps->ctb_width;
1335  int tb_y = ctb_addr_rs / sps->ctb_width;
1336  int tile_x = 0;
1337  int tile_y = 0;
1338  int val = 0;
1339 
1340  for (i = 0; i < pps->num_tile_columns; i++) {
1341  if (tb_x < pps->col_bd[i + 1]) {
1342  tile_x = i;
1343  break;
1344  }
1345  }
1346 
1347  for (i = 0; i < pps->num_tile_rows; i++) {
1348  if (tb_y < pps->row_bd[i + 1]) {
1349  tile_y = i;
1350  break;
1351  }
1352  }
1353 
1354  for (i = 0; i < tile_x; i++)
1355  val += pps->row_height[tile_y] * pps->column_width[i];
1356  for (i = 0; i < tile_y; i++)
1357  val += sps->ctb_width * pps->row_height[i];
1358 
1359  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1360  tb_x - pps->col_bd[tile_x];
1361 
1362  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1363  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1364  }
1365 
1366  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1367  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1368  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1369  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1370  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1371 
1372  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1373  if (!pps->tile_pos_rs)
1374  return AVERROR(ENOMEM);
1375 
1376  for (j = 0; j < pps->num_tile_rows; j++)
1377  for (i = 0; i < pps->num_tile_columns; i++)
1378  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1379  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1380 
1381  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1382  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1383  for (y = 0; y < sps->tb_mask+2; y++) {
1384  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1385  pps->min_tb_addr_zs_tab[y] = -1;
1386  }
1387  for (y = 0; y < sps->tb_mask+1; y++) {
1388  for (x = 0; x < sps->tb_mask+1; x++) {
1389  int tb_x = x >> log2_diff;
1390  int tb_y = y >> log2_diff;
1391  int rs = sps->ctb_width * tb_y + tb_x;
1392  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1393  for (i = 0; i < log2_diff; i++) {
1394  int m = 1 << i;
1395  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1396  }
1397  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1398  }
1399  }
1400 
1401  return 0;
1402 }
1403 
1405  HEVCParamSets *ps)
1406 {
1407  HEVCSPS *sps = NULL;
1408  int i, ret = 0;
1409  unsigned int pps_id = 0;
1410 
1411  AVBufferRef *pps_buf;
1412  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1413 
1414  if (!pps)
1415  return AVERROR(ENOMEM);
1416 
1417  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1418  hevc_pps_free, NULL, 0);
1419  if (!pps_buf) {
1420  av_freep(&pps);
1421  return AVERROR(ENOMEM);
1422  }
1423 
1424  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1425 
1426  // Default values
1428  pps->num_tile_columns = 1;
1429  pps->num_tile_rows = 1;
1430  pps->uniform_spacing_flag = 1;
1431  pps->disable_dbf = 0;
1432  pps->beta_offset = 0;
1433  pps->tc_offset = 0;
1435 
1436  // Coded parameters
1437  pps_id = get_ue_golomb_long(gb);
1438  if (pps_id >= MAX_PPS_COUNT) {
1439  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1440  ret = AVERROR_INVALIDDATA;
1441  goto err;
1442  }
1443  pps->sps_id = get_ue_golomb_long(gb);
1444  if (pps->sps_id >= MAX_SPS_COUNT) {
1445  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1446  ret = AVERROR_INVALIDDATA;
1447  goto err;
1448  }
1449  if (!ps->sps_list[pps->sps_id]) {
1450  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1451  ret = AVERROR_INVALIDDATA;
1452  goto err;
1453  }
1454  sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1455 
1458  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1459 
1460  pps->sign_data_hiding_flag = get_bits1(gb);
1461 
1463 
1466 
1468 
1471 
1473  pps->diff_cu_qp_delta_depth = 0;
1474  if (pps->cu_qp_delta_enabled_flag)
1476 
1477  if (pps->diff_cu_qp_delta_depth < 0 ||
1479  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1480  pps->diff_cu_qp_delta_depth);
1481  ret = AVERROR_INVALIDDATA;
1482  goto err;
1483  }
1484 
1485  pps->cb_qp_offset = get_se_golomb(gb);
1486  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1487  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1488  pps->cb_qp_offset);
1489  ret = AVERROR_INVALIDDATA;
1490  goto err;
1491  }
1492  pps->cr_qp_offset = get_se_golomb(gb);
1493  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1494  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1495  pps->cr_qp_offset);
1496  ret = AVERROR_INVALIDDATA;
1497  goto err;
1498  }
1500 
1501  pps->weighted_pred_flag = get_bits1(gb);
1502  pps->weighted_bipred_flag = get_bits1(gb);
1503 
1505  pps->tiles_enabled_flag = get_bits1(gb);
1507 
1508  if (pps->tiles_enabled_flag) {
1509  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1510  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1511  if (pps->num_tile_columns <= 0 ||
1512  pps->num_tile_columns >= sps->width) {
1513  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1514  pps->num_tile_columns - 1);
1515  ret = AVERROR_INVALIDDATA;
1516  goto err;
1517  }
1518  if (pps->num_tile_rows <= 0 ||
1519  pps->num_tile_rows >= sps->height) {
1520  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1521  pps->num_tile_rows - 1);
1522  ret = AVERROR_INVALIDDATA;
1523  goto err;
1524  }
1525 
1526  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1527  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1528  if (!pps->column_width || !pps->row_height) {
1529  ret = AVERROR(ENOMEM);
1530  goto err;
1531  }
1532 
1533  pps->uniform_spacing_flag = get_bits1(gb);
1534  if (!pps->uniform_spacing_flag) {
1535  uint64_t sum = 0;
1536  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1537  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1538  sum += pps->column_width[i];
1539  }
1540  if (sum >= sps->ctb_width) {
1541  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1542  ret = AVERROR_INVALIDDATA;
1543  goto err;
1544  }
1545  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1546 
1547  sum = 0;
1548  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1549  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1550  sum += pps->row_height[i];
1551  }
1552  if (sum >= sps->ctb_height) {
1553  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1554  ret = AVERROR_INVALIDDATA;
1555  goto err;
1556  }
1557  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1558  }
1560  }
1561 
1563 
1567  pps->disable_dbf = get_bits1(gb);
1568  if (!pps->disable_dbf) {
1569  pps->beta_offset = get_se_golomb(gb) * 2;
1570  pps->tc_offset = get_se_golomb(gb) * 2;
1571  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1572  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1573  pps->beta_offset/2);
1574  ret = AVERROR_INVALIDDATA;
1575  goto err;
1576  }
1577  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1578  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1579  pps->tc_offset/2);
1580  ret = AVERROR_INVALIDDATA;
1581  goto err;
1582  }
1583  }
1584  }
1585 
1587  if (pps->scaling_list_data_present_flag) {
1589  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1590  if (ret < 0)
1591  goto err;
1592  }
1595  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1596  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1597  pps->log2_parallel_merge_level - 2);
1598  ret = AVERROR_INVALIDDATA;
1599  goto err;
1600  }
1601 
1603 
1604  if (get_bits1(gb)) { // pps_extension_present_flag
1605  int pps_range_extensions_flag = get_bits1(gb);
1606  /* int pps_extension_7bits = */ get_bits(gb, 7);
1607  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1608  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1609  goto err;
1610  }
1611  }
1612 
1613  ret = setup_pps(avctx, gb, pps, sps);
1614  if (ret < 0)
1615  goto err;
1616 
1617  if (get_bits_left(gb) < 0) {
1618  av_log(avctx, AV_LOG_ERROR,
1619  "Overread PPS by %d bits\n", -get_bits_left(gb));
1620  goto err;
1621  }
1622 
1623  remove_pps(ps, pps_id);
1624  ps->pps_list[pps_id] = pps_buf;
1625 
1626  return 0;
1627 
1628 err:
1629  av_buffer_unref(&pps_buf);
1630  return ret;
1631 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:378
const HEVCPPS * pps
Definition: hevc.h:570
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc.h:451
const char const char void * val
Definition: avisynth_c.h:634
uint8_t log2_sao_offset_scale_luma
Definition: hevc.h:544
const char * s
Definition: avisynth_c.h:631
int min_spatial_segmentation_idc
Definition: hevc.h:345
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:124
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2263
int ctb_height
Definition: hevc.h:472
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc.h:540
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
enum AVCodecID id
Definition: mxfenc.c:104
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc.h:338
int max_dec_pic_buffering
Definition: hevc.h:419
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
int transform_skip_rotation_enabled_flag
Definition: hevc.h:461
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:247
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int8_t cb_qp_offset_list[5]
Definition: hevc.h:542
const char * desc
Definition: nvenc.c:89
unsigned int * row_height
RowHeight.
Definition: hevc.h:549
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc.h:388
#define MAX_REFS
Definition: hevc.h:41
int pic_init_qp_minus26
Definition: hevc.h:497
#define MAX_PPS_COUNT
Definition: h264.h:54
VUI vui
Definition: hevc.h:424
#define MAX_DPB_SIZE
Definition: hevc.h:40
int vshift[3]
Definition: hevc.h:483
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:180
int num
numerator
Definition: rational.h:44
#define MAX_LOG2_CTB_SIZE
Definition: hevc.h:60
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2899
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
uint32_t vui_time_scale
Definition: hevc.h:336
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:359
uint8_t weighted_bipred_flag
Definition: hevc.h:509
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:110
unsigned int left_offset
Definition: hevc.h:303
Definition: hevc.h:364
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:522
uint8_t cabac_init_present_flag
Definition: hevc.h:493
int chroma_loc_info_present_flag
Definition: hevc.h:323
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:318
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:347
int max_latency_increase
Definition: hevc.h:421
int min_cb_height
Definition: hevc.h:475
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:555
int explicit_rdpcm_enabled_flag
Definition: hevc.h:464
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:495
static const AVRational vui_sar[]
Definition: hevc_ps.c:52
struct HEVCSPS::@55 pcm
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:563
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:431
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:437
int chroma_sample_loc_type_top_field
Definition: hevc.h:324
int width
Definition: hevc.h:469
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int qp_bd_offset
Definition: hevc.h:485
int pixel_shift
Definition: hevc.h:411
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:515
HEVCWindow output_window
Definition: hevc.h:406
int output_width
Definition: hevc.h:405
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc.h:534
uint8_t log2_sao_offset_scale_chroma
Definition: hevc.h:545
int restricted_ref_pic_lists_flag
Definition: hevc.h:344
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static void remove_vps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:96
int chroma_format_idc
Definition: hevc.h:401
uint8_t disable_dbf
Definition: hevc.h:526
unsigned int log2_max_trafo_size
Definition: hevc.h:454
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t profile_compatibility_flag[32]
Definition: hevc.h:356
Definition: hevc.h:309
static int decode_hrd(GetBitContext *gb, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:335
unsigned int num_negative_pics
Definition: hevc.h:278
uint8_t
uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:368
static void remove_pps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:72
static const uint8_t default_scaling_list_inter[]
Definition: hevc_ps.c:41
unsigned int vps_num_reorder_pics[MAX_SUB_LAYERS]
Definition: hevc.h:380
float delta
HEVCWindow pic_conf_win
Definition: hevc.h:408
uint8_t log2_max_transform_skip_block_size
Definition: hevc.h:537
int overscan_info_present_flag
Definition: hevc.h:312
uint8_t vps_timing_info_present_flag
Definition: hevc.h:384
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:826
uint8_t matrix_coeffs
Definition: hevc.h:321
int min_tb_width
Definition: hevc.h:476
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:3249
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
Parse the SPS from the bitstream into the provided HEVCSPS struct.
Definition: hevc_ps.c:814
const HEVCVPS * vps
Definition: hevc.h:568
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:496
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:444
int min_cb_width
Definition: hevc.h:474
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc.h:375
int frame_field_info_present_flag
Definition: hevc.h:329
uint8_t tier_flag
Definition: hevc.h:354
uint8_t scaling_list_data_present_flag
Definition: hevc.h:530
uint8_t bit_depth_chroma
Definition: hevc.h:443
uint8_t loop_filter_disable_flag
Definition: hevc.h:446
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
Definition: hevc_ps.c:764
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:348
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:3250
int bitstream_restriction_flag
Definition: hevc.h:341
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:511
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
int8_t cr_qp_offset_list[5]
Definition: hevc.h:543
int vps_max_layer_id
Definition: hevc.h:382
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:568
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t frame_only_constraint_flag
Definition: hevc.h:361
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:921
unsigned int log2_max_poc_lsb
Definition: hevc.h:414
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int vps_max_layers
Definition: hevc.h:374
int min_pu_height
Definition: hevc.h:479
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc.h:466
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:397
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:334
uint8_t amp_enabled_flag
Definition: hevc.h:433
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define MAX_SHORT_TERM_RPS_COUNT
Definition: hevc.h:53
Not part of ABI.
Definition: pixfmt.h:404
unsigned int log2_ctb_size
Definition: hevc.h:455
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1752
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:337
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:346
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
uint8_t vps_temporal_id_nesting_flag
Definition: hevc.h:373
uint8_t colour_primaries
Definition: hevc.h:319
uint8_t used[32]
Definition: hevc.h:282
int motion_vectors_over_pic_boundaries_flag
Definition: hevc.h:343
uint8_t tiles_enabled_flag
Definition: hevc.h:514
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:66
uint32_t vps_num_units_in_tick
Definition: hevc.h:385
int * col_idxX
Definition: hevc.h:552
const HEVCSPS * sps
Definition: hevc.h:569
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc.h:383
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:341
uint8_t lists_modification_present_flag
Definition: hevc.h:533
int * min_tb_addr_zs_tab
MinTbAddrZS.
Definition: hevc.h:559
uint8_t profile_idc
Definition: hevc.h:355
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:251
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1236
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2944
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:327
int max_transform_hierarchy_depth_inter
Definition: hevc.h:458
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:74
uint8_t vps_poc_proportional_to_timing_flag
Definition: hevc.h:387
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:517
int output_height
Definition: hevc.h:405
unsigned int top_offset
Definition: hevc.h:305
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:565
int hshift[3]
Definition: hevc.h:482
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:3251
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:347
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:502
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:438
#define MAX_SPS_COUNT
Definition: h264.h:53
int ctb_width
Definition: hevc.h:471
uint8_t sl_dc[2][6]
Definition: hevc.h:396
int32_t delta_poc[32]
Definition: hevc.h:281
uint8_t sign_data_hiding_flag
Definition: hevc.h:491
int height
Definition: hevc.h:470
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2955
uint8_t output_flag_present_flag
Definition: hevc.h:510
int log2_max_mv_length_vertical
Definition: hevc.h:349
PTLCommon general_ptl
Definition: hevc.h:365
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:342
int max_bytes_per_pic_denom
Definition: hevc.h:346
int overscan_appropriate_flag
Definition: hevc.h:313
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:663
int implicit_rdpcm_enabled_flag
Definition: hevc.h:463
unsigned vps_id
Definition: hevc.h:400
#define FF_ARRAY_ELEMS(a)
uint8_t constrained_intra_pred_flag
Definition: hevc.h:499
int tb_mask
Definition: hevc.h:480
uint8_t sl[4][6][64]
Definition: hevc.h:395
PTL ptl
Definition: hevc.h:377
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:507
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:85
uint32_t vps_time_scale
Definition: hevc.h:386
int colour_description_present_flag
Definition: hevc.h:318
uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:369
Definition: hevc.h:399
enum AVPixelFormat pix_fmt
Definition: hevc.h:412
Definition: hevc.h:372
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:215
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
Definition: hevc.h:488
uint8_t transform_skip_enabled_flag
Definition: hevc.h:500
uint8_t uniform_spacing_flag
Definition: hevc.h:519
int ctb_size
Definition: hevc.h:473
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: hevc_ps.c:519
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:554
PTL ptl
Definition: hevc.h:425
int max_sub_layers
Definition: hevc.h:417
unsigned int log2_min_pu_size
Definition: hevc.h:456
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:489
int debug
debug
Definition: avcodec.h:2896
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define MAX_VPS_COUNT
Definition: hevc.h:50
ScalingList scaling_list
Definition: hevc.h:531
main external API structure.
Definition: avcodec.h:1657
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:278
int log2_max_mv_length_horizontal
Definition: hevc.h:348
uint8_t sao_enabled
Definition: hevc.h:434
int num_extra_slice_header_bits
Definition: hevc.h:535
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc.h:520
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:439
uint8_t cross_component_prediction_enabled_flag
Definition: hevc.h:538
uint32_t vui_num_units_in_tick
Definition: hevc.h:335
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 deblocking_filter_control_present_flag
Definition: hevc.h:524
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
int transform_skip_context_enabled_flag
Definition: hevc.h:462
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:324
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:343
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:448
unsigned int nb_st_rps
Definition: hevc.h:430
int chroma_sample_loc_type_bottom_field
Definition: hevc.h:325
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc.h:518
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
uint8_t chroma_qp_offset_list_enabled_flag
Definition: hevc.h:539
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
rational number numerator/denominator
Definition: rational.h:43
int vps_num_hrd_parameters
Definition: hevc.h:389
struct HEVCSPS::@54 temporal_layer[MAX_SUB_LAYERS]
#define MAX_SUB_LAYERS
7.4.2.1
Definition: hevc.h:49
Not part of ABI.
Definition: pixfmt.h:430
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:1218
unsigned int log2_min_tb_size
Definition: hevc.h:453
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:437
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1404
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:340
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1173
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:332
uint8_t scaling_list_enable_flag
Definition: hevc.h:427
int * tile_id
TileId.
Definition: hevc.h:556
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:30
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:528
uint8_t transfer_characteristic
Definition: hevc.h:320
int default_display_window_flag
Definition: hevc.h:331
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc.h:332
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:360
int cr_qp_offset
Definition: hevc.h:506
ScalingList scaling_list
Definition: hevc.h:428
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:344
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:452
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:350
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, HEVCSPS *sps)
Definition: hevc_ps.c:693
unsigned int log2_max_pcm_cb_size
Definition: hevc.h:445
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1272
uint8_t level_idc
Definition: hevc.h:357
int neutra_chroma_indication_flag
Definition: hevc.h:326
int * tile_pos_rs
TilePosRS.
Definition: hevc.h:557
A reference to a data buffer.
Definition: buffer.h:81
int max_transform_hierarchy_depth_intra
Definition: hevc.h:459
uint8_t profile_space
Definition: hevc.h:353
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
Y , 8bpp.
Definition: pixfmt.h:70
unsigned int * row_bd
RowBd.
Definition: hevc.h:551
int video_format
Definition: hevc.h:316
uint8_t weighted_pred_flag
Definition: hevc.h:508
unsigned int * col_bd
ColBd.
Definition: hevc.h:550
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:548
uint8_t slice_header_extension_present_flag
Definition: hevc.h:536
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx, PTLCommon *ptl)
Definition: hevc_ps.c:238
int den
denominator
Definition: rational.h:45
int video_full_range_flag
Definition: hevc.h:317
PTLCommon sub_layer_ptl[MAX_SUB_LAYERS]
Definition: hevc.h:366
AVRational sar
Definition: hevc.h:310
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc.h:541
int num_delta_pocs
Definition: hevc.h:279
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:3252
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:449
int rps_idx_num_delta_pocs
Definition: hevc.h:280
int min_pu_width
Definition: hevc.h:478
static uint8_t tmp[8]
Definition: des.c:38
unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS]
Definition: hevc.h:379
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:436
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:381
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1759
int vui_hrd_parameters_present_flag
Definition: hevc.h:339
unsigned int right_offset
Definition: hevc.h:304
int diff_cu_qp_delta_depth
Definition: hevc.h:503
#define av_freep(p)
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
void INT64 start
Definition: avisynth_c.h:553
int num_reorder_pics
Definition: hevc.h:420
static void remove_sps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:79
uint8_t progressive_source_flag
Definition: hevc.h:358
int cb_qp_offset
Definition: hevc.h:505
#define av_malloc_array(a, b)
int video_signal_type_present_flag
Definition: hevc.h:315
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:525
int bit_depth
Definition: hevc.h:410
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:527
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2179
int min_tb_height
Definition: hevc.h:477
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc.h:558
uint8_t non_packed_constraint_flag
Definition: hevc.h:360
int intra_smoothing_disabled_flag
Definition: hevc.h:465
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:415
int tiles_fixed_structure_flag
Definition: hevc.h:342
uint8_t interlaced_source_flag
Definition: hevc.h:359
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:564
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:252
int field_seq_flag
Definition: hevc.h:328
Not part of ABI.
Definition: pixfmt.h:448
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:402
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
unsigned int bottom_offset
Definition: hevc.h:306
int vps_sub_layer_ordering_info_present_flag
Definition: hevc.h:378
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:513