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++)
266 
267  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
268  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
269  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
270 
271  return 0;
272 }
273 
274 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
275  PTL *ptl, int max_num_sub_layers)
276 {
277  int i;
278  if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
279  get_bits_left(gb) < 8 + 8*2) {
280  av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
281  return -1;
282  }
283 
284  ptl->general_ptl.level_idc = get_bits(gb, 8);
285 
286  for (i = 0; i < max_num_sub_layers - 1; i++) {
289  }
290 
291  if (max_num_sub_layers - 1> 0)
292  for (i = max_num_sub_layers - 1; i < 8; i++)
293  skip_bits(gb, 2); // reserved_zero_2bits[i]
294  for (i = 0; i < max_num_sub_layers - 1; i++) {
295  if (ptl->sub_layer_profile_present_flag[i] &&
296  decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
297  av_log(avctx, AV_LOG_ERROR,
298  "PTL information for sublayer %i too short\n", i);
299  return -1;
300  }
301  if (ptl->sub_layer_level_present_flag[i]) {
302  if (get_bits_left(gb) < 8) {
303  av_log(avctx, AV_LOG_ERROR,
304  "Not enough data for sublayer %i level_idc\n", i);
305  return -1;
306  } else
307  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
308  }
309  }
310 
311  return 0;
312 }
313 
314 static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
315  int subpic_params_present)
316 {
317  int i;
318 
319  for (i = 0; i < nb_cpb; i++) {
320  get_ue_golomb_long(gb); // bit_rate_value_minus1
321  get_ue_golomb_long(gb); // cpb_size_value_minus1
322 
323  if (subpic_params_present) {
324  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
325  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
326  }
327  skip_bits1(gb); // cbr_flag
328  }
329 }
330 
331 static int decode_hrd(GetBitContext *gb, int common_inf_present,
332  int max_sublayers)
333 {
334  int nal_params_present = 0, vcl_params_present = 0;
335  int subpic_params_present = 0;
336  int i;
337 
338  if (common_inf_present) {
339  nal_params_present = get_bits1(gb);
340  vcl_params_present = get_bits1(gb);
341 
342  if (nal_params_present || vcl_params_present) {
343  subpic_params_present = get_bits1(gb);
344 
345  if (subpic_params_present) {
346  skip_bits(gb, 8); // tick_divisor_minus2
347  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
348  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
349  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
350  }
351 
352  skip_bits(gb, 4); // bit_rate_scale
353  skip_bits(gb, 4); // cpb_size_scale
354 
355  if (subpic_params_present)
356  skip_bits(gb, 4); // cpb_size_du_scale
357 
358  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
359  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
360  skip_bits(gb, 5); // dpb_output_delay_length_minus1
361  }
362  }
363 
364  for (i = 0; i < max_sublayers; i++) {
365  int low_delay = 0;
366  unsigned int nb_cpb = 1;
367  int fixed_rate = get_bits1(gb);
368 
369  if (!fixed_rate)
370  fixed_rate = get_bits1(gb);
371 
372  if (fixed_rate)
373  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
374  else
375  low_delay = get_bits1(gb);
376 
377  if (!low_delay) {
378  nb_cpb = get_ue_golomb_long(gb) + 1;
379  if (nb_cpb < 1 || nb_cpb > 32) {
380  av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
381  return AVERROR_INVALIDDATA;
382  }
383  }
384 
385  if (nal_params_present)
386  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
387  if (vcl_params_present)
388  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
389  }
390  return 0;
391 }
392 
394  HEVCParamSets *ps)
395 {
396  int i,j;
397  int vps_id = 0;
398  HEVCVPS *vps;
399  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
400 
401  if (!vps_buf)
402  return AVERROR(ENOMEM);
403  vps = (HEVCVPS*)vps_buf->data;
404 
405  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
406 
407  vps_id = get_bits(gb, 4);
408  if (vps_id >= MAX_VPS_COUNT) {
409  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
410  goto err;
411  }
412 
413  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
414  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
415  goto err;
416  }
417 
418  vps->vps_max_layers = get_bits(gb, 6) + 1;
419  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
421 
422  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
423  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
424  goto err;
425  }
426 
427  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
428  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
429  vps->vps_max_sub_layers);
430  goto err;
431  }
432 
433  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
434  goto err;
435 
437 
439  for (; i < vps->vps_max_sub_layers; i++) {
443 
445  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
446  vps->vps_max_dec_pic_buffering[i] - 1);
447  goto err;
448  }
449  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
450  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
451  vps->vps_num_reorder_pics[i]);
452  if (avctx->err_recognition & AV_EF_EXPLODE)
453  goto err;
454  }
455  }
456 
457  vps->vps_max_layer_id = get_bits(gb, 6);
458  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
459  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
460  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
461  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
462  goto err;
463  }
464 
465  for (i = 1; i < vps->vps_num_layer_sets; i++)
466  for (j = 0; j <= vps->vps_max_layer_id; j++)
467  skip_bits(gb, 1); // layer_id_included_flag[i][j]
468 
470  if (vps->vps_timing_info_present_flag) {
471  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
472  vps->vps_time_scale = get_bits_long(gb, 32);
477  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
478  av_log(avctx, AV_LOG_ERROR,
479  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
480  goto err;
481  }
482  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
483  int common_inf_present = 1;
484 
485  get_ue_golomb_long(gb); // hrd_layer_set_idx
486  if (i)
487  common_inf_present = get_bits1(gb);
488  decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
489  }
490  }
491  get_bits1(gb); /* vps_extension_flag */
492 
493  if (get_bits_left(gb) < 0) {
494  av_log(avctx, AV_LOG_ERROR,
495  "Overread VPS by %d bits\n", -get_bits_left(gb));
496  if (ps->vps_list[vps_id])
497  goto err;
498  }
499 
500  if (ps->vps_list[vps_id] &&
501  !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
502  av_buffer_unref(&vps_buf);
503  } else {
504  remove_vps(ps, vps_id);
505  ps->vps_list[vps_id] = vps_buf;
506  }
507 
508  return 0;
509 
510 err:
511  av_buffer_unref(&vps_buf);
512  return AVERROR_INVALIDDATA;
513 }
514 
515 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
516  int apply_defdispwin, HEVCSPS *sps)
517 {
518  VUI *vui = &sps->vui;
519  GetBitContext backup;
520  int sar_present, alt = 0;
521 
522  av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
523 
524  sar_present = get_bits1(gb);
525  if (sar_present) {
526  uint8_t sar_idx = get_bits(gb, 8);
527  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
528  vui->sar = vui_sar[sar_idx];
529  else if (sar_idx == 255) {
530  vui->sar.num = get_bits(gb, 16);
531  vui->sar.den = get_bits(gb, 16);
532  } else
533  av_log(avctx, AV_LOG_WARNING,
534  "Unknown SAR index: %u.\n", sar_idx);
535  }
536 
540 
543  vui->video_format = get_bits(gb, 3);
544  vui->video_full_range_flag = get_bits1(gb);
549  vui->colour_primaries = get_bits(gb, 8);
550  vui->transfer_characteristic = get_bits(gb, 8);
551  vui->matrix_coeffs = get_bits(gb, 8);
552 
553  // Set invalid values to "unspecified"
554  if (vui->colour_primaries >= AVCOL_PRI_NB)
558  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
560  }
561  }
562 
564  if (vui->chroma_loc_info_present_flag) {
567  }
568 
570  vui->field_seq_flag = get_bits1(gb);
572 
573  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
575  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
576  } else
578  // Backup context in case an alternate header is detected
579  memcpy(&backup, gb, sizeof(backup));
580 
581  if (vui->default_display_window_flag) {
582  //TODO: * 2 is only valid for 420
587 
588  if (apply_defdispwin &&
590  av_log(avctx, AV_LOG_DEBUG,
591  "discarding vui default display window, "
592  "original values are l:%u r:%u t:%u b:%u\n",
597 
600  vui->def_disp_win.top_offset =
601  vui->def_disp_win.bottom_offset = 0;
602  }
603  }
604 
606 
607  if (vui->vui_timing_info_present_flag) {
608  if( get_bits_left(gb) < 66) {
609  // The alternate syntax seem to have timing info located
610  // at where def_disp_win is normally located
611  av_log(avctx, AV_LOG_WARNING,
612  "Strange VUI timing information, retrying...\n");
614  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
615  memcpy(gb, &backup, sizeof(backup));
616  alt = 1;
617  }
618  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
619  vui->vui_time_scale = get_bits_long(gb, 32);
620  if (alt) {
621  av_log(avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
623  }
629  decode_hrd(gb, 1, sps->max_sub_layers);
630  }
631 
633  if (vui->bitstream_restriction_flag) {
642  }
643 }
644 
646 {
647  int matrixId;
648 
649  for (matrixId = 0; matrixId < 6; matrixId++) {
650  // 4x4 default is 16
651  memset(sl->sl[0][matrixId], 16, 16);
652  sl->sl_dc[0][matrixId] = 16; // default for 16x16
653  sl->sl_dc[1][matrixId] = 16; // default for 32x32
654  }
655  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
656  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
657  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
658  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
659  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
660  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
661  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
662  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
663  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
664  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
665  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
666  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
667  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
668  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
669  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
670  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
671  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
672  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
673 }
674 
676 {
677  uint8_t scaling_list_pred_mode_flag;
678  int32_t scaling_list_dc_coef[2][6];
679  int size_id, matrix_id, pos;
680  int i;
681 
682  for (size_id = 0; size_id < 4; size_id++)
683  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
684  scaling_list_pred_mode_flag = get_bits1(gb);
685  if (!scaling_list_pred_mode_flag) {
686  unsigned int delta = get_ue_golomb_long(gb);
687  /* Only need to handle non-zero delta. Zero means default,
688  * which should already be in the arrays. */
689  if (delta) {
690  // Copy from previous array.
691  if (matrix_id < delta) {
692  av_log(avctx, AV_LOG_ERROR,
693  "Invalid delta in scaling list data: %d.\n", delta);
694  return AVERROR_INVALIDDATA;
695  }
696 
697  memcpy(sl->sl[size_id][matrix_id],
698  sl->sl[size_id][matrix_id - delta],
699  size_id > 0 ? 64 : 16);
700  if (size_id > 1)
701  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
702  }
703  } else {
704  int next_coef, coef_num;
705  int32_t scaling_list_delta_coef;
706 
707  next_coef = 8;
708  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
709  if (size_id > 1) {
710  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
711  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
712  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
713  }
714  for (i = 0; i < coef_num; i++) {
715  if (size_id == 0)
716  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
718  else
719  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
721 
722  scaling_list_delta_coef = get_se_golomb(gb);
723  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
724  sl->sl[size_id][matrix_id][pos] = next_coef;
725  }
726  }
727  }
728 
729  if (sps->chroma_format_idc == 3) {
730  for (i = 0; i < 64; i++) {
731  sl->sl[3][1][i] = sl->sl[2][1][i];
732  sl->sl[3][2][i] = sl->sl[2][2][i];
733  sl->sl[3][4][i] = sl->sl[2][4][i];
734  sl->sl[3][5][i] = sl->sl[2][5][i];
735  }
736  sl->sl_dc[1][1] = sl->sl_dc[0][1];
737  sl->sl_dc[1][2] = sl->sl_dc[0][2];
738  sl->sl_dc[1][4] = sl->sl_dc[0][4];
739  sl->sl_dc[1][5] = sl->sl_dc[0][5];
740  }
741 
742 
743  return 0;
744 }
745 
746 static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
747 {
748  const AVPixFmtDescriptor *desc;
749  switch (sps->bit_depth) {
750  case 8:
751  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
752  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
753  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
754  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
755  break;
756  case 9:
757  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
758  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
759  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
760  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
761  break;
762  case 10:
763  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
764  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
765  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
766  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
767  break;
768  case 12:
769  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
770  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
771  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
772  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
773  break;
774  default:
775  av_log(avctx, AV_LOG_ERROR,
776  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
777  av_log(avctx, AV_LOG_ERROR,
778  "chroma_format_idc is %d, depth is %d",
779  sps->chroma_format_idc, sps->bit_depth);
780  return AVERROR_INVALIDDATA;
781  }
782 
783  desc = av_pix_fmt_desc_get(sps->pix_fmt);
784  if (!desc)
785  return AVERROR(EINVAL);
786 
787  sps->hshift[0] = sps->vshift[0] = 0;
788  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
789  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
790 
791  sps->pixel_shift = sps->bit_depth > 8;
792 
793  return 0;
794 }
795 
796 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
797  int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
798 {
799  int ret = 0;
800  int log2_diff_max_min_transform_block_size;
801  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
802  int i;
803 
804  // Coded parameters
805 
806  sps->vps_id = get_bits(gb, 4);
807  if (sps->vps_id >= MAX_VPS_COUNT) {
808  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
809  return AVERROR_INVALIDDATA;
810  }
811 
812  if (vps_list && !vps_list[sps->vps_id]) {
813  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
814  sps->vps_id);
815  return AVERROR_INVALIDDATA;
816  }
817 
818  sps->max_sub_layers = get_bits(gb, 3) + 1;
819  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
820  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
821  sps->max_sub_layers);
822  return AVERROR_INVALIDDATA;
823  }
824 
825  skip_bits1(gb); // temporal_id_nesting_flag
826 
827  if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
828  return ret;
829 
830  *sps_id = get_ue_golomb_long(gb);
831  if (*sps_id >= MAX_SPS_COUNT) {
832  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
833  return AVERROR_INVALIDDATA;
834  }
835 
837 
838  if (sps->chroma_format_idc == 3)
840 
842  sps->chroma_format_idc = 0;
843 
844  sps->width = get_ue_golomb_long(gb);
845  sps->height = get_ue_golomb_long(gb);
846  if ((ret = av_image_check_size(sps->width,
847  sps->height, 0, avctx)) < 0)
848  return ret;
849 
850  if (get_bits1(gb)) { // pic_conformance_flag
851  //TODO: * 2 is only valid for 420
856 
857  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
858  av_log(avctx, AV_LOG_DEBUG,
859  "discarding sps conformance window, "
860  "original values are l:%u r:%u t:%u b:%u\n",
865 
868  sps->pic_conf_win.top_offset =
869  sps->pic_conf_win.bottom_offset = 0;
870  }
871  sps->output_window = sps->pic_conf_win;
872  }
873 
874  sps->bit_depth = get_ue_golomb_long(gb) + 8;
875  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
876  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
877  av_log(avctx, AV_LOG_ERROR,
878  "Luma bit depth (%d) is different from chroma bit depth (%d), "
879  "this is unsupported.\n",
880  sps->bit_depth, bit_depth_chroma);
881  return AVERROR_INVALIDDATA;
882  }
883 
884  ret = map_pixel_format(avctx, sps);
885  if (ret < 0)
886  return ret;
887 
888  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
889  if (sps->log2_max_poc_lsb > 16) {
890  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
891  sps->log2_max_poc_lsb - 4);
892  return AVERROR_INVALIDDATA;
893  }
894 
895  sublayer_ordering_info = get_bits1(gb);
896  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
897  for (i = start; i < sps->max_sub_layers; i++) {
902  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
904  return AVERROR_INVALIDDATA;
905  }
907  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
909  if (avctx->err_recognition & AV_EF_EXPLODE ||
911  return AVERROR_INVALIDDATA;
912  }
914  }
915  }
916 
917  if (!sublayer_ordering_info) {
918  for (i = 0; i < start; i++) {
922  }
923  }
924 
925  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
927  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
928  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
929  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
930  sps->log2_min_tb_size;
931 
932  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
933  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
934  return AVERROR_INVALIDDATA;
935  }
936 
937  if (sps->log2_diff_max_min_coding_block_size > 30) {
938  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);
939  return AVERROR_INVALIDDATA;
940  }
941 
942  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
943  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
944  return AVERROR_INVALIDDATA;
945  }
946 
947  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
948  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
949  return AVERROR_INVALIDDATA;
950  }
951 
954 
956  if (sps->scaling_list_enable_flag) {
958 
959  if (get_bits1(gb)) {
960  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
961  if (ret < 0)
962  return ret;
963  }
964  }
965 
966  sps->amp_enabled_flag = get_bits1(gb);
967  sps->sao_enabled = get_bits1(gb);
968 
969  sps->pcm_enabled_flag = get_bits1(gb);
970  if (sps->pcm_enabled_flag) {
971  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
972  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
975  get_ue_golomb_long(gb);
976  if (sps->pcm.bit_depth > sps->bit_depth) {
977  av_log(avctx, AV_LOG_ERROR,
978  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
979  sps->pcm.bit_depth, sps->bit_depth);
980  return AVERROR_INVALIDDATA;
981  }
982 
984  }
985 
986  sps->nb_st_rps = get_ue_golomb_long(gb);
987  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
988  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
989  sps->nb_st_rps);
990  return AVERROR_INVALIDDATA;
991  }
992  for (i = 0; i < sps->nb_st_rps; i++) {
993  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
994  sps, 0)) < 0)
995  return ret;
996  }
997 
1001  if (sps->num_long_term_ref_pics_sps > 31U) {
1002  av_log(avctx, AV_LOG_ERROR, "num_long_term_ref_pics_sps %d is out of range.\n",
1004  return AVERROR_INVALIDDATA;
1005  }
1006  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1007  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1009  }
1010  }
1011 
1014  sps->vui.sar = (AVRational){0, 1};
1015  vui_present = get_bits1(gb);
1016  if (vui_present)
1017  decode_vui(gb, avctx, apply_defdispwin, sps);
1018 
1019  if (get_bits1(gb)) { // sps_extension_flag
1020  int sps_extension_flag[1];
1021  for (i = 0; i < 1; i++)
1022  sps_extension_flag[i] = get_bits1(gb);
1023  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1024  if (sps_extension_flag[0]) {
1025  int extended_precision_processing_flag;
1026  int high_precision_offsets_enabled_flag;
1027  int cabac_bypass_alignment_enabled_flag;
1028 
1032 
1034 
1035  extended_precision_processing_flag = get_bits1(gb);
1036  if (extended_precision_processing_flag)
1037  av_log(avctx, AV_LOG_WARNING,
1038  "extended_precision_processing_flag not yet implemented\n");
1039 
1041  high_precision_offsets_enabled_flag = get_bits1(gb);
1042  if (high_precision_offsets_enabled_flag)
1043  av_log(avctx, AV_LOG_WARNING,
1044  "high_precision_offsets_enabled_flag not yet implemented\n");
1045 
1047 
1048  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1049  if (cabac_bypass_alignment_enabled_flag)
1050  av_log(avctx, AV_LOG_WARNING,
1051  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1052  }
1053  }
1054  if (apply_defdispwin) {
1059  }
1060  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1061  !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
1062  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1063  av_log(avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1064  "chroma samples to preserve alignment.\n",
1065  sps->output_window.left_offset);
1066  }
1067  sps->output_width = sps->width -
1069  sps->output_height = sps->height -
1071  if (sps->width <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset ||
1072  sps->height <= sps->output_window.top_offset + (int64_t)sps->output_window.bottom_offset) {
1073  av_log(avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1074  sps->output_width, sps->output_height);
1075  if (avctx->err_recognition & AV_EF_EXPLODE) {
1076  return AVERROR_INVALIDDATA;
1077  }
1078  av_log(avctx, AV_LOG_WARNING,
1079  "Displaying the whole video surface.\n");
1080  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1081  memset(&sps->output_window, 0, sizeof(sps->output_window));
1082  sps->output_width = sps->width;
1083  sps->output_height = sps->height;
1084  }
1085 
1086  // Inferred parameters
1087  sps->log2_ctb_size = sps->log2_min_cb_size +
1089  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1090 
1091  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1092  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1093  return AVERROR_INVALIDDATA;
1094  }
1095  if (sps->log2_ctb_size < 4) {
1096  av_log(avctx,
1097  AV_LOG_ERROR,
1098  "log2_ctb_size %d differs from the bounds of any known profile\n",
1099  sps->log2_ctb_size);
1100  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1101  return AVERROR_INVALIDDATA;
1102  }
1103 
1104  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1105  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1106  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1107 
1108  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1109  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1110  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1111  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1112  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1113  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1114  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1115 
1116  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1117 
1118  if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
1119  av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1120  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1121  return AVERROR_INVALIDDATA;
1122  }
1123 
1125  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1127  return AVERROR_INVALIDDATA;
1128  }
1130  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1132  return AVERROR_INVALIDDATA;
1133  }
1134  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1135  av_log(avctx, AV_LOG_ERROR,
1136  "max transform block size out of range: %d\n",
1137  sps->log2_max_trafo_size);
1138  return AVERROR_INVALIDDATA;
1139  }
1140 
1141  if (get_bits_left(gb) < 0) {
1142  av_log(avctx, AV_LOG_ERROR,
1143  "Overread SPS by %d bits\n", -get_bits_left(gb));
1144  return AVERROR_INVALIDDATA;
1145  }
1146 
1147  return 0;
1148 }
1149 
1151  HEVCParamSets *ps, int apply_defdispwin)
1152 {
1153  HEVCSPS *sps;
1154  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
1155  unsigned int sps_id;
1156  int ret;
1157 
1158  if (!sps_buf)
1159  return AVERROR(ENOMEM);
1160  sps = (HEVCSPS*)sps_buf->data;
1161 
1162  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1163 
1164  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1165  apply_defdispwin,
1166  ps->vps_list, avctx);
1167  if (ret < 0) {
1168  av_buffer_unref(&sps_buf);
1169  return ret;
1170  }
1171 
1172  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1173  av_log(avctx, AV_LOG_DEBUG,
1174  "Parsed SPS: id %d; coded wxh: %dx%d; "
1175  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1176  sps_id, sps->width, sps->height,
1177  sps->output_width, sps->output_height,
1179  }
1180 
1181  /* check if this is a repeat of an already parsed SPS, then keep the
1182  * original one.
1183  * otherwise drop all PPSes that depend on it */
1184  if (ps->sps_list[sps_id] &&
1185  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1186  av_buffer_unref(&sps_buf);
1187  } else {
1188  remove_sps(ps, sps_id);
1189  ps->sps_list[sps_id] = sps_buf;
1190  }
1191 
1192  return 0;
1193 }
1194 
1195 static void hevc_pps_free(void *opaque, uint8_t *data)
1196 {
1197  HEVCPPS *pps = (HEVCPPS*)data;
1198 
1199  av_freep(&pps->column_width);
1200  av_freep(&pps->row_height);
1201  av_freep(&pps->col_bd);
1202  av_freep(&pps->row_bd);
1203  av_freep(&pps->col_idxX);
1204  av_freep(&pps->ctb_addr_rs_to_ts);
1205  av_freep(&pps->ctb_addr_ts_to_rs);
1206  av_freep(&pps->tile_pos_rs);
1207  av_freep(&pps->tile_id);
1209 
1210  av_freep(&pps);
1211 }
1212 
1214  HEVCPPS *pps, HEVCSPS *sps) {
1215  int i;
1216 
1217  if (pps->transform_skip_enabled_flag) {
1219  }
1226  av_log(avctx, AV_LOG_ERROR,
1227  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1228  return AVERROR_INVALIDDATA;
1229  }
1230  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1231  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1232  if (pps->cb_qp_offset_list[i]) {
1233  av_log(avctx, AV_LOG_WARNING,
1234  "cb_qp_offset_list not tested yet.\n");
1235  }
1236  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1237  if (pps->cr_qp_offset_list[i]) {
1238  av_log(avctx, AV_LOG_WARNING,
1239  "cb_qp_offset_list not tested yet.\n");
1240  }
1241  }
1242  }
1245 
1246  return(0);
1247 }
1248 
1249 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1250  HEVCPPS *pps, HEVCSPS *sps)
1251 {
1252  int log2_diff;
1253  int pic_area_in_ctbs;
1254  int i, j, x, y, ctb_addr_rs, tile_id;
1255 
1256  // Inferred parameters
1257  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1258  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1259  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1260  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1261  return AVERROR(ENOMEM);
1262 
1263  if (pps->uniform_spacing_flag) {
1264  if (!pps->column_width) {
1265  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1266  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1267  }
1268  if (!pps->column_width || !pps->row_height)
1269  return AVERROR(ENOMEM);
1270 
1271  for (i = 0; i < pps->num_tile_columns; i++) {
1272  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1273  (i * sps->ctb_width) / pps->num_tile_columns;
1274  }
1275 
1276  for (i = 0; i < pps->num_tile_rows; i++) {
1277  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1278  (i * sps->ctb_height) / pps->num_tile_rows;
1279  }
1280  }
1281 
1282  pps->col_bd[0] = 0;
1283  for (i = 0; i < pps->num_tile_columns; i++)
1284  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1285 
1286  pps->row_bd[0] = 0;
1287  for (i = 0; i < pps->num_tile_rows; i++)
1288  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1289 
1290  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1291  if (i > pps->col_bd[j])
1292  j++;
1293  pps->col_idxX[i] = j;
1294  }
1295 
1296  /**
1297  * 6.5
1298  */
1299  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1300 
1301  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1302  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1303  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1304  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1305  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1306  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1307  return AVERROR(ENOMEM);
1308  }
1309 
1310  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1311  int tb_x = ctb_addr_rs % sps->ctb_width;
1312  int tb_y = ctb_addr_rs / sps->ctb_width;
1313  int tile_x = 0;
1314  int tile_y = 0;
1315  int val = 0;
1316 
1317  for (i = 0; i < pps->num_tile_columns; i++) {
1318  if (tb_x < pps->col_bd[i + 1]) {
1319  tile_x = i;
1320  break;
1321  }
1322  }
1323 
1324  for (i = 0; i < pps->num_tile_rows; i++) {
1325  if (tb_y < pps->row_bd[i + 1]) {
1326  tile_y = i;
1327  break;
1328  }
1329  }
1330 
1331  for (i = 0; i < tile_x; i++)
1332  val += pps->row_height[tile_y] * pps->column_width[i];
1333  for (i = 0; i < tile_y; i++)
1334  val += sps->ctb_width * pps->row_height[i];
1335 
1336  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1337  tb_x - pps->col_bd[tile_x];
1338 
1339  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1340  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1341  }
1342 
1343  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1344  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1345  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1346  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1347  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1348 
1349  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1350  if (!pps->tile_pos_rs)
1351  return AVERROR(ENOMEM);
1352 
1353  for (j = 0; j < pps->num_tile_rows; j++)
1354  for (i = 0; i < pps->num_tile_columns; i++)
1355  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1356  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1357 
1358  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1359  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1360  for (y = 0; y < sps->tb_mask+2; y++) {
1361  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1362  pps->min_tb_addr_zs_tab[y] = -1;
1363  }
1364  for (y = 0; y < sps->tb_mask+1; y++) {
1365  for (x = 0; x < sps->tb_mask+1; x++) {
1366  int tb_x = x >> log2_diff;
1367  int tb_y = y >> log2_diff;
1368  int rs = sps->ctb_width * tb_y + tb_x;
1369  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1370  for (i = 0; i < log2_diff; i++) {
1371  int m = 1 << i;
1372  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1373  }
1374  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1375  }
1376  }
1377 
1378  return 0;
1379 }
1380 
1382  HEVCParamSets *ps)
1383 {
1384  HEVCSPS *sps = NULL;
1385  int i, ret = 0;
1386  unsigned int pps_id = 0;
1387 
1388  AVBufferRef *pps_buf;
1389  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1390 
1391  if (!pps)
1392  return AVERROR(ENOMEM);
1393 
1394  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1395  hevc_pps_free, NULL, 0);
1396  if (!pps_buf) {
1397  av_freep(&pps);
1398  return AVERROR(ENOMEM);
1399  }
1400 
1401  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1402 
1403  // Default values
1405  pps->num_tile_columns = 1;
1406  pps->num_tile_rows = 1;
1407  pps->uniform_spacing_flag = 1;
1408  pps->disable_dbf = 0;
1409  pps->beta_offset = 0;
1410  pps->tc_offset = 0;
1412 
1413  // Coded parameters
1414  pps_id = get_ue_golomb_long(gb);
1415  if (pps_id >= MAX_PPS_COUNT) {
1416  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1417  ret = AVERROR_INVALIDDATA;
1418  goto err;
1419  }
1420  pps->sps_id = get_ue_golomb_long(gb);
1421  if (pps->sps_id >= MAX_SPS_COUNT) {
1422  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1423  ret = AVERROR_INVALIDDATA;
1424  goto err;
1425  }
1426  if (!ps->sps_list[pps->sps_id]) {
1427  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1428  ret = AVERROR_INVALIDDATA;
1429  goto err;
1430  }
1431  sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1432 
1435  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1436 
1437  pps->sign_data_hiding_flag = get_bits1(gb);
1438 
1440 
1443 
1445 
1448 
1450  pps->diff_cu_qp_delta_depth = 0;
1451  if (pps->cu_qp_delta_enabled_flag)
1453 
1454  if (pps->diff_cu_qp_delta_depth < 0 ||
1456  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1457  pps->diff_cu_qp_delta_depth);
1458  ret = AVERROR_INVALIDDATA;
1459  goto err;
1460  }
1461 
1462  pps->cb_qp_offset = get_se_golomb(gb);
1463  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1464  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1465  pps->cb_qp_offset);
1466  ret = AVERROR_INVALIDDATA;
1467  goto err;
1468  }
1469  pps->cr_qp_offset = get_se_golomb(gb);
1470  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1471  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1472  pps->cr_qp_offset);
1473  ret = AVERROR_INVALIDDATA;
1474  goto err;
1475  }
1477 
1478  pps->weighted_pred_flag = get_bits1(gb);
1479  pps->weighted_bipred_flag = get_bits1(gb);
1480 
1482  pps->tiles_enabled_flag = get_bits1(gb);
1484 
1485  if (pps->tiles_enabled_flag) {
1486  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1487  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1488  if (pps->num_tile_columns <= 0 ||
1489  pps->num_tile_columns >= sps->width) {
1490  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1491  pps->num_tile_columns - 1);
1492  ret = AVERROR_INVALIDDATA;
1493  goto err;
1494  }
1495  if (pps->num_tile_rows <= 0 ||
1496  pps->num_tile_rows >= sps->height) {
1497  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1498  pps->num_tile_rows - 1);
1499  ret = AVERROR_INVALIDDATA;
1500  goto err;
1501  }
1502 
1503  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1504  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1505  if (!pps->column_width || !pps->row_height) {
1506  ret = AVERROR(ENOMEM);
1507  goto err;
1508  }
1509 
1510  pps->uniform_spacing_flag = get_bits1(gb);
1511  if (!pps->uniform_spacing_flag) {
1512  uint64_t sum = 0;
1513  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1514  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1515  sum += pps->column_width[i];
1516  }
1517  if (sum >= sps->ctb_width) {
1518  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1519  ret = AVERROR_INVALIDDATA;
1520  goto err;
1521  }
1522  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1523 
1524  sum = 0;
1525  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1526  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1527  sum += pps->row_height[i];
1528  }
1529  if (sum >= sps->ctb_height) {
1530  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1531  ret = AVERROR_INVALIDDATA;
1532  goto err;
1533  }
1534  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1535  }
1537  }
1538 
1540 
1544  pps->disable_dbf = get_bits1(gb);
1545  if (!pps->disable_dbf) {
1546  pps->beta_offset = get_se_golomb(gb) * 2;
1547  pps->tc_offset = get_se_golomb(gb) * 2;
1548  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1549  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1550  pps->beta_offset/2);
1551  ret = AVERROR_INVALIDDATA;
1552  goto err;
1553  }
1554  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1555  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1556  pps->tc_offset/2);
1557  ret = AVERROR_INVALIDDATA;
1558  goto err;
1559  }
1560  }
1561  }
1562 
1564  if (pps->scaling_list_data_present_flag) {
1566  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1567  if (ret < 0)
1568  goto err;
1569  }
1572  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1573  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1574  pps->log2_parallel_merge_level - 2);
1575  ret = AVERROR_INVALIDDATA;
1576  goto err;
1577  }
1578 
1580 
1581  if (get_bits1(gb)) { // pps_extension_present_flag
1582  int pps_range_extensions_flag = get_bits1(gb);
1583  /* int pps_extension_7bits = */ get_bits(gb, 7);
1584  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1585  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1586  goto err;
1587  }
1588  }
1589 
1590  ret = setup_pps(avctx, gb, pps, sps);
1591  if (ret < 0)
1592  goto err;
1593 
1594  if (get_bits_left(gb) < 0) {
1595  av_log(avctx, AV_LOG_ERROR,
1596  "Overread PPS by %d bits\n", -get_bits_left(gb));
1597  goto err;
1598  }
1599 
1600  remove_pps(ps, pps_id);
1601  ps->pps_list[pps_id] = pps_buf;
1602 
1603  return 0;
1604 
1605 err:
1606  av_buffer_unref(&pps_buf);
1607  return ret;
1608 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:383
const HEVCPPS * pps
Definition: hevc.h:569
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc.h:450
const char const char void * val
Definition: avisynth_c.h:634
uint8_t log2_sao_offset_scale_luma
Definition: hevc.h:543
const char * s
Definition: avisynth_c.h:631
int min_spatial_segmentation_idc
Definition: hevc.h:344
#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:2129
int ctb_height
Definition: hevc.h:471
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc.h:539
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
enum AVCodecID id
Definition: mxfenc.c:101
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc.h:337
int max_dec_pic_buffering
Definition: hevc.h:418
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
int transform_skip_rotation_enabled_flag
Definition: hevc.h:460
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int8_t cb_qp_offset_list[5]
Definition: hevc.h:541
unsigned int * row_height
RowHeight.
Definition: hevc.h:548
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:3196
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc.h:387
#define MAX_REFS
Definition: hevc.h:40
int pic_init_qp_minus26
Definition: hevc.h:496
#define MAX_PPS_COUNT
Definition: h264.h:50
VUI vui
Definition: hevc.h:423
#define MAX_DPB_SIZE
Definition: hevc.h:39
int vshift[3]
Definition: hevc.h:482
int num
numerator
Definition: rational.h:44
#define MAX_LOG2_CTB_SIZE
Definition: hevc.h:59
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
uint32_t vui_time_scale
Definition: hevc.h:335
uint8_t weighted_bipred_flag
Definition: hevc.h:508
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:302
Definition: hevc.h:363
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:521
uint8_t cabac_init_present_flag
Definition: hevc.h:492
int chroma_loc_info_present_flag
Definition: hevc.h:322
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:314
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:384
int max_latency_increase
Definition: hevc.h:420
int min_cb_height
Definition: hevc.h:474
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:554
int explicit_rdpcm_enabled_flag
Definition: hevc.h:463
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:494
static const AVRational vui_sar[]
Definition: hevc_ps.c:52
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:562
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:430
int chroma_sample_loc_type_top_field
Definition: hevc.h:323
int width
Definition: hevc.h:468
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
int qp_bd_offset
Definition: hevc.h:484
int pixel_shift
Definition: hevc.h:410
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:514
HEVCWindow output_window
Definition: hevc.h:405
int output_width
Definition: hevc.h:404
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc.h:533
uint8_t log2_sao_offset_scale_chroma
Definition: hevc.h:544
int restricted_ref_pic_lists_flag
Definition: hevc.h:343
#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:400
uint8_t disable_dbf
Definition: hevc.h:525
unsigned int log2_max_trafo_size
Definition: hevc.h:453
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:355
Definition: hevc.h:308
static int decode_hrd(GetBitContext *gb, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:331
unsigned int num_negative_pics
Definition: hevc.h:277
uint8_t
uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:367
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:379
float delta
HEVCWindow pic_conf_win
Definition: hevc.h:407
uint8_t log2_max_transform_skip_block_size
Definition: hevc.h:536
int overscan_info_present_flag
Definition: hevc.h:311
uint8_t vps_timing_info_present_flag
Definition: hevc.h:383
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:731
uint8_t matrix_coeffs
Definition: hevc.h:320
int min_tb_width
Definition: hevc.h:475
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:796
const HEVCVPS * vps
Definition: hevc.h:567
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:495
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:443
int min_cb_width
Definition: hevc.h:473
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc.h:374
int frame_field_info_present_flag
Definition: hevc.h:328
uint8_t tier_flag
Definition: hevc.h:353
uint8_t scaling_list_data_present_flag
Definition: hevc.h:529
uint8_t bit_depth_chroma
Definition: hevc.h:442
uint8_t loop_filter_disable_flag
Definition: hevc.h:445
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
Definition: hevc_ps.c:746
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:385
int bitstream_restriction_flag
Definition: hevc.h:340
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:510
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
int8_t cr_qp_offset_list[5]
Definition: hevc.h:542
int vps_max_layer_id
Definition: hevc.h:381
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
#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:360
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:826
unsigned int log2_max_poc_lsb
Definition: hevc.h:413
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
int vps_max_layers
Definition: hevc.h:373
int min_pu_height
Definition: hevc.h:478
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc.h:465
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2901
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:393
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:333
uint8_t amp_enabled_flag
Definition: hevc.h:432
#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:52
Not part of ABI.
Definition: pixfmt.h:488
unsigned int log2_ctb_size
Definition: hevc.h:454
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1597
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:336
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:383
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:372
uint8_t colour_primaries
Definition: hevc.h:318
uint8_t used[32]
Definition: hevc.h:281
int motion_vectors_over_pic_boundaries_flag
Definition: hevc.h:342
uint8_t tiles_enabled_flag
Definition: hevc.h:513
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
uint32_t vps_num_units_in_tick
Definition: hevc.h:384
int * col_idxX
Definition: hevc.h:551
const HEVCSPS * sps
Definition: hevc.h:568
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc.h:382
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:378
uint8_t lists_modification_present_flag
Definition: hevc.h:532
int * min_tb_addr_zs_tab
MinTbAddrZS.
Definition: hevc.h:558
uint8_t profile_idc
Definition: hevc.h:354
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:241
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1213
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2890
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:364
int max_transform_hierarchy_depth_inter
Definition: hevc.h:457
#define FFMIN(a, b)
Definition: common.h:81
float y
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:75
uint8_t vps_poc_proportional_to_timing_flag
Definition: hevc.h:386
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:516
int output_height
Definition: hevc.h:404
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:3195
unsigned int top_offset
Definition: hevc.h:304
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:564
int hshift[3]
Definition: hevc.h:481
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:346
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:501
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:437
#define MAX_SPS_COUNT
Definition: h264.h:49
int ctb_width
Definition: hevc.h:470
uint8_t sl_dc[2][6]
Definition: hevc.h:395
int32_t delta_poc[32]
Definition: hevc.h:280
uint8_t sign_data_hiding_flag
Definition: hevc.h:490
int height
Definition: hevc.h:469
uint8_t output_flag_present_flag
Definition: hevc.h:509
int log2_max_mv_length_vertical
Definition: hevc.h:348
PTLCommon general_ptl
Definition: hevc.h:364
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:379
int max_bytes_per_pic_denom
Definition: hevc.h:345
int overscan_appropriate_flag
Definition: hevc.h:312
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:645
int implicit_rdpcm_enabled_flag
Definition: hevc.h:462
unsigned vps_id
Definition: hevc.h:399
#define FF_ARRAY_ELEMS(a)
uint8_t constrained_intra_pred_flag
Definition: hevc.h:498
int tb_mask
Definition: hevc.h:479
uint8_t sl[4][6][64]
Definition: hevc.h:394
PTL ptl
Definition: hevc.h:376
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:506
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:385
int colour_description_present_flag
Definition: hevc.h:317
uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:368
Definition: hevc.h:398
enum AVPixelFormat pix_fmt
Definition: hevc.h:411
Definition: hevc.h:371
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:487
uint8_t transform_skip_enabled_flag
Definition: hevc.h:499
uint8_t uniform_spacing_flag
Definition: hevc.h:518
int ctb_size
Definition: hevc.h:472
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: hevc_ps.c:515
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:553
PTL ptl
Definition: hevc.h:424
int max_sub_layers
Definition: hevc.h:416
unsigned int log2_min_pu_size
Definition: hevc.h:455
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:488
int debug
debug
Definition: avcodec.h:2842
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
#define MAX_VPS_COUNT
Definition: hevc.h:49
ScalingList scaling_list
Definition: hevc.h:530
main external API structure.
Definition: avcodec.h:1502
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:274
struct HEVCSPS::@51 pcm
int log2_max_mv_length_horizontal
Definition: hevc.h:347
uint8_t sao_enabled
Definition: hevc.h:433
int num_extra_slice_header_bits
Definition: hevc.h:534
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc.h:519
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:438
uint8_t cross_component_prediction_enabled_flag
Definition: hevc.h:537
uint32_t vui_num_units_in_tick
Definition: hevc.h:334
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:523
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
int transform_skip_context_enabled_flag
Definition: hevc.h:461
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:329
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:380
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:447
unsigned int nb_st_rps
Definition: hevc.h:429
int chroma_sample_loc_type_bottom_field
Definition: hevc.h:324
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc.h:517
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
uint8_t chroma_qp_offset_list_enabled_flag
Definition: hevc.h:538
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:388
#define MAX_SUB_LAYERS
7.4.2.1
Definition: hevc.h:48
Not part of ABI.
Definition: pixfmt.h:511
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:1195
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:3197
unsigned int log2_min_tb_size
Definition: hevc.h:452
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:436
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1381
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:377
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1150
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
uint8_t scaling_list_enable_flag
Definition: hevc.h:426
int * tile_id
TileId.
Definition: hevc.h:555
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:30
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:527
uint8_t transfer_characteristic
Definition: hevc.h:319
int default_display_window_flag
Definition: hevc.h:330
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc.h:331
int cr_qp_offset
Definition: hevc.h:505
ScalingList scaling_list
Definition: hevc.h:427
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:381
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:451
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:387
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, HEVCSPS *sps)
Definition: hevc_ps.c:675
unsigned int log2_max_pcm_cb_size
Definition: hevc.h:444
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1249
uint8_t level_idc
Definition: hevc.h:356
int neutra_chroma_indication_flag
Definition: hevc.h:325
int * tile_pos_rs
TilePosRS.
Definition: hevc.h:556
A reference to a data buffer.
Definition: buffer.h:81
int max_transform_hierarchy_depth_intra
Definition: hevc.h:458
uint8_t profile_space
Definition: hevc.h:352
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
Y , 8bpp.
Definition: pixfmt.h:71
unsigned int * row_bd
RowBd.
Definition: hevc.h:550
int video_format
Definition: hevc.h:315
uint8_t weighted_pred_flag
Definition: hevc.h:507
unsigned int * col_bd
ColBd.
Definition: hevc.h:549
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:547
uint8_t slice_header_extension_present_flag
Definition: hevc.h:535
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:316
PTLCommon sub_layer_ptl[MAX_SUB_LAYERS]
Definition: hevc.h:365
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:3194
AVRational sar
Definition: hevc.h:309
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc.h:540
int num_delta_pocs
Definition: hevc.h:278
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:448
int rps_idx_num_delta_pocs
Definition: hevc.h:279
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2845
int min_pu_width
Definition: hevc.h:477
unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS]
Definition: hevc.h:378
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:435
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:380
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1604
int vui_hrd_parameters_present_flag
Definition: hevc.h:338
unsigned int right_offset
Definition: hevc.h:303
int diff_cu_qp_delta_depth
Definition: hevc.h:502
#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:419
struct HEVCSPS::@50 temporal_layer[MAX_SUB_LAYERS]
static void remove_sps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:79
uint8_t progressive_source_flag
Definition: hevc.h:357
int cb_qp_offset
Definition: hevc.h:504
#define av_malloc_array(a, b)
int video_signal_type_present_flag
Definition: hevc.h:314
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:524
int bit_depth
Definition: hevc.h:409
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:526
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:2050
int min_tb_height
Definition: hevc.h:476
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc.h:557
uint8_t non_packed_constraint_flag
Definition: hevc.h:359
int intra_smoothing_disabled_flag
Definition: hevc.h:464
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:414
int tiles_fixed_structure_flag
Definition: hevc.h:341
uint8_t interlaced_source_flag
Definition: hevc.h:358
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:563
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:327
Not part of ABI.
Definition: pixfmt.h:529
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:401
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
unsigned int bottom_offset
Definition: hevc.h:305
int vps_sub_layer_ordering_info_present_flag
Definition: hevc.h:377
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:512