FFmpeg  2.8.15
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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  if (k >= FF_ARRAY_ELEMS(rps->used)) {
173  av_log(avctx, AV_LOG_ERROR,
174  "Invalid num_delta_pocs: %d\n", k);
175  return AVERROR_INVALIDDATA;
176  }
177 
178  rps->num_delta_pocs = k;
179  rps->num_negative_pics = k0;
180  // sort in increasing order (smallest first)
181  if (rps->num_delta_pocs != 0) {
182  int used, tmp;
183  for (i = 1; i < rps->num_delta_pocs; i++) {
184  delta_poc = rps->delta_poc[i];
185  used = rps->used[i];
186  for (k = i - 1; k >= 0; k--) {
187  tmp = rps->delta_poc[k];
188  if (delta_poc < tmp) {
189  rps->delta_poc[k + 1] = tmp;
190  rps->used[k + 1] = rps->used[k];
191  rps->delta_poc[k] = delta_poc;
192  rps->used[k] = used;
193  }
194  }
195  }
196  }
197  if ((rps->num_negative_pics >> 1) != 0) {
198  int used;
199  k = rps->num_negative_pics - 1;
200  // flip the negative values to largest first
201  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
202  delta_poc = rps->delta_poc[i];
203  used = rps->used[i];
204  rps->delta_poc[i] = rps->delta_poc[k];
205  rps->used[i] = rps->used[k];
206  rps->delta_poc[k] = delta_poc;
207  rps->used[k] = used;
208  k--;
209  }
210  }
211  } else {
212  unsigned int prev, nb_positive_pics;
214  nb_positive_pics = get_ue_golomb_long(gb);
215 
216  if (rps->num_negative_pics >= MAX_REFS ||
217  nb_positive_pics >= MAX_REFS) {
218  av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
219  return AVERROR_INVALIDDATA;
220  }
221 
222  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
223  if (rps->num_delta_pocs) {
224  prev = 0;
225  for (i = 0; i < rps->num_negative_pics; i++) {
226  delta_poc = get_ue_golomb_long(gb) + 1;
227  if (delta_poc < 1 || delta_poc > 32768) {
228  av_log(avctx, AV_LOG_ERROR,
229  "Invalid value of delta_poc: %d\n",
230  delta_poc);
231  return AVERROR_INVALIDDATA;
232  }
233  prev -= delta_poc;
234  rps->delta_poc[i] = prev;
235  rps->used[i] = get_bits1(gb);
236  }
237  prev = 0;
238  for (i = 0; i < nb_positive_pics; i++) {
239  delta_poc = get_ue_golomb_long(gb) + 1;
240  if (delta_poc < 1 || delta_poc > 32768) {
241  av_log(avctx, AV_LOG_ERROR,
242  "Invalid value of delta_poc: %d\n",
243  delta_poc);
244  return AVERROR_INVALIDDATA;
245  }
246  prev += delta_poc;
247  rps->delta_poc[rps->num_negative_pics + i] = prev;
248  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
249  }
250  }
251  }
252  return 0;
253 }
254 
255 
257  PTLCommon *ptl)
258 {
259  int i;
260 
261  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
262  return -1;
263 
264  ptl->profile_space = get_bits(gb, 2);
265  ptl->tier_flag = get_bits1(gb);
266  ptl->profile_idc = get_bits(gb, 5);
267  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
268  av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
269  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
270  av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
272  av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
273  else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
274  av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
275  else
276  av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
277 
278  for (i = 0; i < 32; i++)
284 
285  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
286  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
287  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
288 
289  return 0;
290 }
291 
292 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
293  PTL *ptl, int max_num_sub_layers)
294 {
295  int i;
296  if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
297  get_bits_left(gb) < 8 + 8*2) {
298  av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
299  return -1;
300  }
301 
302  ptl->general_ptl.level_idc = get_bits(gb, 8);
303 
304  for (i = 0; i < max_num_sub_layers - 1; i++) {
307  }
308 
309  if (max_num_sub_layers - 1> 0)
310  for (i = max_num_sub_layers - 1; i < 8; i++)
311  skip_bits(gb, 2); // reserved_zero_2bits[i]
312  for (i = 0; i < max_num_sub_layers - 1; i++) {
313  if (ptl->sub_layer_profile_present_flag[i] &&
314  decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
315  av_log(avctx, AV_LOG_ERROR,
316  "PTL information for sublayer %i too short\n", i);
317  return -1;
318  }
319  if (ptl->sub_layer_level_present_flag[i]) {
320  if (get_bits_left(gb) < 8) {
321  av_log(avctx, AV_LOG_ERROR,
322  "Not enough data for sublayer %i level_idc\n", i);
323  return -1;
324  } else
325  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
326  }
327  }
328 
329  return 0;
330 }
331 
332 static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
333  int subpic_params_present)
334 {
335  int i;
336 
337  for (i = 0; i < nb_cpb; i++) {
338  get_ue_golomb_long(gb); // bit_rate_value_minus1
339  get_ue_golomb_long(gb); // cpb_size_value_minus1
340 
341  if (subpic_params_present) {
342  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
343  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
344  }
345  skip_bits1(gb); // cbr_flag
346  }
347 }
348 
349 static int decode_hrd(GetBitContext *gb, int common_inf_present,
350  int max_sublayers)
351 {
352  int nal_params_present = 0, vcl_params_present = 0;
353  int subpic_params_present = 0;
354  int i;
355 
356  if (common_inf_present) {
357  nal_params_present = get_bits1(gb);
358  vcl_params_present = get_bits1(gb);
359 
360  if (nal_params_present || vcl_params_present) {
361  subpic_params_present = get_bits1(gb);
362 
363  if (subpic_params_present) {
364  skip_bits(gb, 8); // tick_divisor_minus2
365  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
366  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
367  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
368  }
369 
370  skip_bits(gb, 4); // bit_rate_scale
371  skip_bits(gb, 4); // cpb_size_scale
372 
373  if (subpic_params_present)
374  skip_bits(gb, 4); // cpb_size_du_scale
375 
376  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
377  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
378  skip_bits(gb, 5); // dpb_output_delay_length_minus1
379  }
380  }
381 
382  for (i = 0; i < max_sublayers; i++) {
383  int low_delay = 0;
384  unsigned int nb_cpb = 1;
385  int fixed_rate = get_bits1(gb);
386 
387  if (!fixed_rate)
388  fixed_rate = get_bits1(gb);
389 
390  if (fixed_rate)
391  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
392  else
393  low_delay = get_bits1(gb);
394 
395  if (!low_delay) {
396  nb_cpb = get_ue_golomb_long(gb) + 1;
397  if (nb_cpb < 1 || nb_cpb > 32) {
398  av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
399  return AVERROR_INVALIDDATA;
400  }
401  }
402 
403  if (nal_params_present)
404  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
405  if (vcl_params_present)
406  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
407  }
408  return 0;
409 }
410 
412  HEVCParamSets *ps)
413 {
414  int i,j;
415  int vps_id = 0;
416  HEVCVPS *vps;
417  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
418 
419  if (!vps_buf)
420  return AVERROR(ENOMEM);
421  vps = (HEVCVPS*)vps_buf->data;
422 
423  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
424 
425  vps_id = get_bits(gb, 4);
426  if (vps_id >= MAX_VPS_COUNT) {
427  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
428  goto err;
429  }
430 
431  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
432  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
433  goto err;
434  }
435 
436  vps->vps_max_layers = get_bits(gb, 6) + 1;
437  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
439 
440  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
441  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
442  goto err;
443  }
444 
445  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
446  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
447  vps->vps_max_sub_layers);
448  goto err;
449  }
450 
451  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
452  goto err;
453 
455 
457  for (; i < vps->vps_max_sub_layers; i++) {
461 
463  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
464  vps->vps_max_dec_pic_buffering[i] - 1);
465  goto err;
466  }
467  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
468  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
469  vps->vps_num_reorder_pics[i]);
470  if (avctx->err_recognition & AV_EF_EXPLODE)
471  goto err;
472  }
473  }
474 
475  vps->vps_max_layer_id = get_bits(gb, 6);
476  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
477  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
478  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
479  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
480  goto err;
481  }
482 
483  for (i = 1; i < vps->vps_num_layer_sets; i++)
484  for (j = 0; j <= vps->vps_max_layer_id; j++)
485  skip_bits(gb, 1); // layer_id_included_flag[i][j]
486 
488  if (vps->vps_timing_info_present_flag) {
489  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
490  vps->vps_time_scale = get_bits_long(gb, 32);
495  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
496  av_log(avctx, AV_LOG_ERROR,
497  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
498  goto err;
499  }
500  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
501  int common_inf_present = 1;
502 
503  get_ue_golomb_long(gb); // hrd_layer_set_idx
504  if (i)
505  common_inf_present = get_bits1(gb);
506  decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
507  }
508  }
509  get_bits1(gb); /* vps_extension_flag */
510 
511  if (get_bits_left(gb) < 0) {
512  av_log(avctx, AV_LOG_ERROR,
513  "Overread VPS by %d bits\n", -get_bits_left(gb));
514  if (ps->vps_list[vps_id])
515  goto err;
516  }
517 
518  if (ps->vps_list[vps_id] &&
519  !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
520  av_buffer_unref(&vps_buf);
521  } else {
522  remove_vps(ps, vps_id);
523  ps->vps_list[vps_id] = vps_buf;
524  }
525 
526  return 0;
527 
528 err:
529  av_buffer_unref(&vps_buf);
530  return AVERROR_INVALIDDATA;
531 }
532 
533 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
534  int apply_defdispwin, HEVCSPS *sps)
535 {
536  VUI *vui = &sps->vui;
537  GetBitContext backup;
538  int sar_present, alt = 0;
539 
540  av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
541 
542  sar_present = get_bits1(gb);
543  if (sar_present) {
544  uint8_t sar_idx = get_bits(gb, 8);
545  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
546  vui->sar = vui_sar[sar_idx];
547  else if (sar_idx == 255) {
548  vui->sar.num = get_bits(gb, 16);
549  vui->sar.den = get_bits(gb, 16);
550  } else
551  av_log(avctx, AV_LOG_WARNING,
552  "Unknown SAR index: %u.\n", sar_idx);
553  }
554 
558 
561  vui->video_format = get_bits(gb, 3);
562  vui->video_full_range_flag = get_bits1(gb);
567  vui->colour_primaries = get_bits(gb, 8);
568  vui->transfer_characteristic = get_bits(gb, 8);
569  vui->matrix_coeffs = get_bits(gb, 8);
570 
571  // Set invalid values to "unspecified"
572  if (vui->colour_primaries >= AVCOL_PRI_NB)
576  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
578  }
579  }
580 
582  if (vui->chroma_loc_info_present_flag) {
585  }
586 
588  vui->field_seq_flag = get_bits1(gb);
590 
591  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
593  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
594  } else
596  // Backup context in case an alternate header is detected
597  memcpy(&backup, gb, sizeof(backup));
598 
599  if (vui->default_display_window_flag) {
600  //TODO: * 2 is only valid for 420
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 + 256U + scaling_list_delta_coef) % 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  //TODO: * 2 is only valid for 420
878 
879  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
880  av_log(avctx, AV_LOG_DEBUG,
881  "discarding sps conformance window, "
882  "original values are l:%u r:%u t:%u b:%u\n",
887 
890  sps->pic_conf_win.top_offset =
891  sps->pic_conf_win.bottom_offset = 0;
892  }
893  sps->output_window = sps->pic_conf_win;
894  }
895 
896  sps->bit_depth = get_ue_golomb_long(gb) + 8;
897  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
898  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
899  av_log(avctx, AV_LOG_ERROR,
900  "Luma bit depth (%d) is different from chroma bit depth (%d), "
901  "this is unsupported.\n",
902  sps->bit_depth, bit_depth_chroma);
903  return AVERROR_INVALIDDATA;
904  }
905  sps->bit_depth_chroma = bit_depth_chroma;
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 (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1000  av_log(avctx, AV_LOG_ERROR,
1001  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1002  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, 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  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1270  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1271  )
1272  return AVERROR_INVALIDDATA;
1273 
1274  return(0);
1275 }
1276 
1277 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1278  HEVCPPS *pps, HEVCSPS *sps)
1279 {
1280  int log2_diff;
1281  int pic_area_in_ctbs;
1282  int i, j, x, y, ctb_addr_rs, tile_id;
1283 
1284  // Inferred parameters
1285  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1286  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1287  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1288  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1289  return AVERROR(ENOMEM);
1290 
1291  if (pps->uniform_spacing_flag) {
1292  if (!pps->column_width) {
1293  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1294  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1295  }
1296  if (!pps->column_width || !pps->row_height)
1297  return AVERROR(ENOMEM);
1298 
1299  for (i = 0; i < pps->num_tile_columns; i++) {
1300  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1301  (i * sps->ctb_width) / pps->num_tile_columns;
1302  }
1303 
1304  for (i = 0; i < pps->num_tile_rows; i++) {
1305  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1306  (i * sps->ctb_height) / pps->num_tile_rows;
1307  }
1308  }
1309 
1310  pps->col_bd[0] = 0;
1311  for (i = 0; i < pps->num_tile_columns; i++)
1312  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1313 
1314  pps->row_bd[0] = 0;
1315  for (i = 0; i < pps->num_tile_rows; i++)
1316  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1317 
1318  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1319  if (i > pps->col_bd[j])
1320  j++;
1321  pps->col_idxX[i] = j;
1322  }
1323 
1324  /**
1325  * 6.5
1326  */
1327  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1328 
1329  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1330  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1331  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1332  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1333  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1334  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1335  return AVERROR(ENOMEM);
1336  }
1337 
1338  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1339  int tb_x = ctb_addr_rs % sps->ctb_width;
1340  int tb_y = ctb_addr_rs / sps->ctb_width;
1341  int tile_x = 0;
1342  int tile_y = 0;
1343  int val = 0;
1344 
1345  for (i = 0; i < pps->num_tile_columns; i++) {
1346  if (tb_x < pps->col_bd[i + 1]) {
1347  tile_x = i;
1348  break;
1349  }
1350  }
1351 
1352  for (i = 0; i < pps->num_tile_rows; i++) {
1353  if (tb_y < pps->row_bd[i + 1]) {
1354  tile_y = i;
1355  break;
1356  }
1357  }
1358 
1359  for (i = 0; i < tile_x; i++)
1360  val += pps->row_height[tile_y] * pps->column_width[i];
1361  for (i = 0; i < tile_y; i++)
1362  val += sps->ctb_width * pps->row_height[i];
1363 
1364  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1365  tb_x - pps->col_bd[tile_x];
1366 
1367  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1368  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1369  }
1370 
1371  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1372  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1373  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1374  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1375  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1376 
1377  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1378  if (!pps->tile_pos_rs)
1379  return AVERROR(ENOMEM);
1380 
1381  for (j = 0; j < pps->num_tile_rows; j++)
1382  for (i = 0; i < pps->num_tile_columns; i++)
1383  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1384  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1385 
1386  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1387  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1388  for (y = 0; y < sps->tb_mask+2; y++) {
1389  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1390  pps->min_tb_addr_zs_tab[y] = -1;
1391  }
1392  for (y = 0; y < sps->tb_mask+1; y++) {
1393  for (x = 0; x < sps->tb_mask+1; x++) {
1394  int tb_x = x >> log2_diff;
1395  int tb_y = y >> log2_diff;
1396  int rs = sps->ctb_width * tb_y + tb_x;
1397  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1398  for (i = 0; i < log2_diff; i++) {
1399  int m = 1 << i;
1400  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1401  }
1402  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1403  }
1404  }
1405 
1406  return 0;
1407 }
1408 
1410  HEVCParamSets *ps)
1411 {
1412  HEVCSPS *sps = NULL;
1413  int i, ret = 0;
1414  unsigned int pps_id = 0;
1415  unsigned log2_parallel_merge_level_minus2;
1416 
1417  AVBufferRef *pps_buf;
1418  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1419 
1420  if (!pps)
1421  return AVERROR(ENOMEM);
1422 
1423  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1424  hevc_pps_free, NULL, 0);
1425  if (!pps_buf) {
1426  av_freep(&pps);
1427  return AVERROR(ENOMEM);
1428  }
1429 
1430  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1431 
1432  // Default values
1434  pps->num_tile_columns = 1;
1435  pps->num_tile_rows = 1;
1436  pps->uniform_spacing_flag = 1;
1437  pps->disable_dbf = 0;
1438  pps->beta_offset = 0;
1439  pps->tc_offset = 0;
1441 
1442  // Coded parameters
1443  pps_id = get_ue_golomb_long(gb);
1444  if (pps_id >= MAX_PPS_COUNT) {
1445  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1446  ret = AVERROR_INVALIDDATA;
1447  goto err;
1448  }
1449  pps->sps_id = get_ue_golomb_long(gb);
1450  if (pps->sps_id >= MAX_SPS_COUNT) {
1451  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1452  ret = AVERROR_INVALIDDATA;
1453  goto err;
1454  }
1455  if (!ps->sps_list[pps->sps_id]) {
1456  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1457  ret = AVERROR_INVALIDDATA;
1458  goto err;
1459  }
1460  sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1461 
1464  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1465 
1466  pps->sign_data_hiding_flag = get_bits1(gb);
1467 
1469 
1472 
1474 
1477 
1479  pps->diff_cu_qp_delta_depth = 0;
1480  if (pps->cu_qp_delta_enabled_flag)
1482 
1483  if (pps->diff_cu_qp_delta_depth < 0 ||
1485  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1486  pps->diff_cu_qp_delta_depth);
1487  ret = AVERROR_INVALIDDATA;
1488  goto err;
1489  }
1490 
1491  pps->cb_qp_offset = get_se_golomb(gb);
1492  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1493  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1494  pps->cb_qp_offset);
1495  ret = AVERROR_INVALIDDATA;
1496  goto err;
1497  }
1498  pps->cr_qp_offset = get_se_golomb(gb);
1499  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1500  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1501  pps->cr_qp_offset);
1502  ret = AVERROR_INVALIDDATA;
1503  goto err;
1504  }
1506 
1507  pps->weighted_pred_flag = get_bits1(gb);
1508  pps->weighted_bipred_flag = get_bits1(gb);
1509 
1511  pps->tiles_enabled_flag = get_bits1(gb);
1513 
1514  if (pps->tiles_enabled_flag) {
1515  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1516  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1517  if (pps->num_tile_columns <= 0 ||
1518  pps->num_tile_columns >= sps->width) {
1519  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1520  pps->num_tile_columns - 1);
1521  ret = AVERROR_INVALIDDATA;
1522  goto err;
1523  }
1524  if (pps->num_tile_rows <= 0 ||
1525  pps->num_tile_rows >= sps->height) {
1526  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1527  pps->num_tile_rows - 1);
1528  ret = AVERROR_INVALIDDATA;
1529  goto err;
1530  }
1531 
1532  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1533  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1534  if (!pps->column_width || !pps->row_height) {
1535  ret = AVERROR(ENOMEM);
1536  goto err;
1537  }
1538 
1539  pps->uniform_spacing_flag = get_bits1(gb);
1540  if (!pps->uniform_spacing_flag) {
1541  uint64_t sum = 0;
1542  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1543  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1544  sum += pps->column_width[i];
1545  }
1546  if (sum >= sps->ctb_width) {
1547  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1548  ret = AVERROR_INVALIDDATA;
1549  goto err;
1550  }
1551  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1552 
1553  sum = 0;
1554  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1555  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1556  sum += pps->row_height[i];
1557  }
1558  if (sum >= sps->ctb_height) {
1559  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1560  ret = AVERROR_INVALIDDATA;
1561  goto err;
1562  }
1563  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1564  }
1566  }
1567 
1569 
1573  pps->disable_dbf = get_bits1(gb);
1574  if (!pps->disable_dbf) {
1575  int beta_offset_div2 = get_se_golomb(gb);
1576  int tc_offset_div2 = get_se_golomb(gb) ;
1577  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1578  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1579  beta_offset_div2);
1580  ret = AVERROR_INVALIDDATA;
1581  goto err;
1582  }
1583  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1584  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1585  tc_offset_div2);
1586  ret = AVERROR_INVALIDDATA;
1587  goto err;
1588  }
1589  pps->beta_offset = 2 * beta_offset_div2;
1590  pps->tc_offset = 2 * tc_offset_div2;
1591  }
1592  }
1593 
1595  if (pps->scaling_list_data_present_flag) {
1597  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1598  if (ret < 0)
1599  goto err;
1600  }
1602  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
1603  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
1604  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1605  log2_parallel_merge_level_minus2);
1606  ret = AVERROR_INVALIDDATA;
1607  goto err;
1608  }
1609  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1610 
1612 
1613  if (get_bits1(gb)) { // pps_extension_present_flag
1614  int pps_range_extensions_flag = get_bits1(gb);
1615  /* int pps_extension_7bits = */ get_bits(gb, 7);
1616  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1617  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1618  goto err;
1619  }
1620  }
1621 
1622  ret = setup_pps(avctx, gb, pps, sps);
1623  if (ret < 0)
1624  goto err;
1625 
1626  if (get_bits_left(gb) < 0) {
1627  av_log(avctx, AV_LOG_ERROR,
1628  "Overread PPS by %d bits\n", -get_bits_left(gb));
1629  goto err;
1630  }
1631 
1632  remove_pps(ps, pps_id);
1633  ps->pps_list[pps_id] = pps_buf;
1634 
1635  return 0;
1636 
1637 err:
1638  av_buffer_unref(&pps_buf);
1639  return ret;
1640 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:388
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: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: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:102
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc.h:337
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:68
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:261
#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
unsigned int * row_height
RowHeight.
Definition: hevc.h:549
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:3206
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:497
#define MAX_PPS_COUNT
Definition: h264.h:50
VUI vui
Definition: hevc.h:424
#define MAX_DPB_SIZE
Definition: hevc.h:39
int vshift[3]
Definition: hevc.h:483
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: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:302
Definition: hevc.h:363
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:322
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:332
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:384
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
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:563
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:431
int chroma_sample_loc_type_top_field
Definition: hevc.h:323
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:80
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:405
int output_width
Definition: hevc.h:404
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: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: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:355
Definition: hevc.h:308
static int decode_hrd(GetBitContext *gb, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:349
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:537
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:476
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: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:530
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:385
int bitstream_restriction_flag
Definition: hevc.h:340
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:511
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
int bit_depth_chroma
Definition: hevc.h:410
int8_t cr_qp_offset_list[5]
Definition: hevc.h:543
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:594
#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:414
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:479
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc.h:466
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2911
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:411
#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: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:52
Not part of ABI.
Definition: pixfmt.h:488
unsigned int log2_ctb_size
Definition: hevc.h:455
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1607
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
#define FFMAX(a, b)
Definition: common.h:90
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:514
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:552
const HEVCSPS * sps
Definition: hevc.h:569
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:533
int * min_tb_addr_zs_tab
MinTbAddrZS.
Definition: hevc.h:559
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:266
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:2900
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:364
int max_transform_hierarchy_depth_inter
Definition: hevc.h:458
#define FFMIN(a, b)
Definition: common.h:92
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:517
int output_height
Definition: hevc.h:404
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:3205
unsigned int top_offset
Definition: hevc.h:304
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:565
int hshift[3]
Definition: hevc.h:482
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:346
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:49
int ctb_width
Definition: hevc.h:471
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:491
int height
Definition: hevc.h:470
uint8_t output_flag_present_flag
Definition: hevc.h:510
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:663
int implicit_rdpcm_enabled_flag
Definition: hevc.h:463
unsigned vps_id
Definition: hevc.h:399
#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:394
PTL ptl
Definition: hevc.h:376
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: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:412
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: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:533
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:2852
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:531
main external API structure.
Definition: avcodec.h:1512
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:292
struct HEVCSPS::@51 pcm
int log2_max_mv_length_horizontal
Definition: hevc.h:347
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: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:524
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
int transform_skip_context_enabled_flag
Definition: hevc.h:462
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:330
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:380
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:324
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:298
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: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:1218
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:3207
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:1409
#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:1173
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:338
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: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:506
ScalingList scaling_list
Definition: hevc.h:428
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:381
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:452
#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: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:1277
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: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: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:551
int video_format
Definition: hevc.h:315
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:256
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:3204
AVRational sar
Definition: hevc.h:309
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc.h:541
int num_delta_pocs
Definition: hevc.h:278
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:449
int rps_idx_num_delta_pocs
Definition: hevc.h:279
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2855
int min_pu_width
Definition: hevc.h:478
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:436
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:380
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1614
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: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
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:505
#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:525
int bit_depth
Definition: hevc.h:409
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:2050
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:359
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:341
uint8_t interlaced_source_flag
Definition: hevc.h:358
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: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:513