FFmpeg  2.7.2
 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(HEVCContext *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(HEVCContext *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(HEVCContext *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  const HEVCSPS *sps, int is_slice_header)
112 {
113  HEVCLocalContext *lc = s->HEVClc;
114  uint8_t rps_predict = 0;
115  int delta_poc;
116  int k0 = 0;
117  int k1 = 0;
118  int k = 0;
119  int i;
120 
121  GetBitContext *gb = &lc->gb;
122 
123  if (rps != sps->st_rps && sps->nb_st_rps)
124  rps_predict = get_bits1(gb);
125 
126  if (rps_predict) {
127  const ShortTermRPS *rps_ridx;
128  int delta_rps;
129  unsigned abs_delta_rps;
130  uint8_t use_delta_flag = 0;
131  uint8_t delta_rps_sign;
132 
133  if (is_slice_header) {
134  unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
135  if (delta_idx > sps->nb_st_rps) {
137  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
138  delta_idx, sps->nb_st_rps);
139  return AVERROR_INVALIDDATA;
140  }
141  rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
142  } else
143  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
144 
145  delta_rps_sign = get_bits1(gb);
146  abs_delta_rps = get_ue_golomb_long(gb) + 1;
147  if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
149  "Invalid value of abs_delta_rps: %d\n",
150  abs_delta_rps);
151  return AVERROR_INVALIDDATA;
152  }
153  delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
154  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
155  int used = rps->used[k] = get_bits1(gb);
156 
157  if (!used)
158  use_delta_flag = get_bits1(gb);
159 
160  if (used || use_delta_flag) {
161  if (i < rps_ridx->num_delta_pocs)
162  delta_poc = delta_rps + rps_ridx->delta_poc[i];
163  else
164  delta_poc = delta_rps;
165  rps->delta_poc[k] = delta_poc;
166  if (delta_poc < 0)
167  k0++;
168  else
169  k1++;
170  k++;
171  }
172  }
173 
174  rps->num_delta_pocs = k;
175  rps->num_negative_pics = k0;
176  // sort in increasing order (smallest first)
177  if (rps->num_delta_pocs != 0) {
178  int used, tmp;
179  for (i = 1; i < rps->num_delta_pocs; i++) {
180  delta_poc = rps->delta_poc[i];
181  used = rps->used[i];
182  for (k = i - 1; k >= 0; k--) {
183  tmp = rps->delta_poc[k];
184  if (delta_poc < tmp) {
185  rps->delta_poc[k + 1] = tmp;
186  rps->used[k + 1] = rps->used[k];
187  rps->delta_poc[k] = delta_poc;
188  rps->used[k] = used;
189  }
190  }
191  }
192  }
193  if ((rps->num_negative_pics >> 1) != 0) {
194  int used;
195  k = rps->num_negative_pics - 1;
196  // flip the negative values to largest first
197  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
198  delta_poc = rps->delta_poc[i];
199  used = rps->used[i];
200  rps->delta_poc[i] = rps->delta_poc[k];
201  rps->used[i] = rps->used[k];
202  rps->delta_poc[k] = delta_poc;
203  rps->used[k] = used;
204  k--;
205  }
206  }
207  } else {
208  unsigned int prev, nb_positive_pics;
210  nb_positive_pics = get_ue_golomb_long(gb);
211 
212  if (rps->num_negative_pics >= MAX_REFS ||
213  nb_positive_pics >= MAX_REFS) {
214  av_log(s->avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
215  return AVERROR_INVALIDDATA;
216  }
217 
218  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
219  if (rps->num_delta_pocs) {
220  prev = 0;
221  for (i = 0; i < rps->num_negative_pics; i++) {
222  delta_poc = get_ue_golomb_long(gb) + 1;
223  prev -= delta_poc;
224  rps->delta_poc[i] = prev;
225  rps->used[i] = get_bits1(gb);
226  }
227  prev = 0;
228  for (i = 0; i < nb_positive_pics; i++) {
229  delta_poc = get_ue_golomb_long(gb) + 1;
230  prev += delta_poc;
231  rps->delta_poc[rps->num_negative_pics + i] = prev;
232  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
233  }
234  }
235  }
236  return 0;
237 }
238 
239 
241 {
242  int i;
243  HEVCLocalContext *lc = s->HEVClc;
244  GetBitContext *gb = &lc->gb;
245 
246  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
247  return -1;
248 
249  ptl->profile_space = get_bits(gb, 2);
250  ptl->tier_flag = get_bits1(gb);
251  ptl->profile_idc = get_bits(gb, 5);
252  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
253  av_log(s->avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
254  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
255  av_log(s->avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
257  av_log(s->avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
258  else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
259  av_log(s->avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
260  else
261  av_log(s->avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
262 
263  for (i = 0; i < 32; i++)
269 
270  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
271  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
272  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
273 
274  return 0;
275 }
276 
277 static int parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
278 {
279  int i;
280  HEVCLocalContext *lc = s->HEVClc;
281  GetBitContext *gb = &lc->gb;
282  if (decode_profile_tier_level(s, &ptl->general_ptl) < 0 ||
283  get_bits_left(gb) < 8 + 8*2) {
284  av_log(s->avctx, AV_LOG_ERROR, "PTL information too short\n");
285  return -1;
286  }
287 
288  ptl->general_ptl.level_idc = get_bits(gb, 8);
289 
290  for (i = 0; i < max_num_sub_layers - 1; i++) {
293  }
294 
295  if (max_num_sub_layers - 1> 0)
296  for (i = max_num_sub_layers - 1; i < 8; i++)
297  skip_bits(gb, 2); // reserved_zero_2bits[i]
298  for (i = 0; i < max_num_sub_layers - 1; i++) {
299  if (ptl->sub_layer_profile_present_flag[i] &&
300  decode_profile_tier_level(s, &ptl->sub_layer_ptl[i]) < 0) {
302  "PTL information for sublayer %i too short\n", i);
303  return -1;
304  }
305  if (ptl->sub_layer_level_present_flag[i]) {
306  if (get_bits_left(gb) < 8) {
308  "Not enough data for sublayer %i level_idc\n", i);
309  return -1;
310  } else
311  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
312  }
313  }
314 
315  return 0;
316 }
317 
318 static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb,
319  int subpic_params_present)
320 {
321  GetBitContext *gb = &s->HEVClc->gb;
322  int i;
323 
324  for (i = 0; i < nb_cpb; i++) {
325  get_ue_golomb_long(gb); // bit_rate_value_minus1
326  get_ue_golomb_long(gb); // cpb_size_value_minus1
327 
328  if (subpic_params_present) {
329  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
330  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
331  }
332  skip_bits1(gb); // cbr_flag
333  }
334 }
335 
336 static int decode_hrd(HEVCContext *s, int common_inf_present,
337  int max_sublayers)
338 {
339  GetBitContext *gb = &s->HEVClc->gb;
340  int nal_params_present = 0, vcl_params_present = 0;
341  int subpic_params_present = 0;
342  int i;
343 
344  if (common_inf_present) {
345  nal_params_present = get_bits1(gb);
346  vcl_params_present = get_bits1(gb);
347 
348  if (nal_params_present || vcl_params_present) {
349  subpic_params_present = get_bits1(gb);
350 
351  if (subpic_params_present) {
352  skip_bits(gb, 8); // tick_divisor_minus2
353  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
354  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
355  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
356  }
357 
358  skip_bits(gb, 4); // bit_rate_scale
359  skip_bits(gb, 4); // cpb_size_scale
360 
361  if (subpic_params_present)
362  skip_bits(gb, 4); // cpb_size_du_scale
363 
364  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
365  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
366  skip_bits(gb, 5); // dpb_output_delay_length_minus1
367  }
368  }
369 
370  for (i = 0; i < max_sublayers; i++) {
371  int low_delay = 0;
372  unsigned int nb_cpb = 1;
373  int fixed_rate = get_bits1(gb);
374 
375  if (!fixed_rate)
376  fixed_rate = get_bits1(gb);
377 
378  if (fixed_rate)
379  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
380  else
381  low_delay = get_bits1(gb);
382 
383  if (!low_delay) {
384  nb_cpb = get_ue_golomb_long(gb) + 1;
385  if (nb_cpb < 1 || nb_cpb > 32) {
386  av_log(s->avctx, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
387  return AVERROR_INVALIDDATA;
388  }
389  }
390 
391  if (nal_params_present)
392  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
393  if (vcl_params_present)
394  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
395  }
396  return 0;
397 }
398 
400 {
401  int i,j;
402  GetBitContext *gb = &s->HEVClc->gb;
403  int vps_id = 0;
404  HEVCVPS *vps;
405  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
406 
407  if (!vps_buf)
408  return AVERROR(ENOMEM);
409  vps = (HEVCVPS*)vps_buf->data;
410 
411  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VPS\n");
412 
413  vps_id = get_bits(gb, 4);
414  if (vps_id >= MAX_VPS_COUNT) {
415  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
416  goto err;
417  }
418 
419  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
420  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
421  goto err;
422  }
423 
424  vps->vps_max_layers = get_bits(gb, 6) + 1;
425  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
427 
428  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
429  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
430  goto err;
431  }
432 
433  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
434  av_log(s->avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
435  vps->vps_max_sub_layers);
436  goto err;
437  }
438 
439  if (parse_ptl(s, &vps->ptl, vps->vps_max_sub_layers) < 0)
440  goto err;
441 
443 
445  for (; i < vps->vps_max_sub_layers; i++) {
449 
451  av_log(s->avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
452  vps->vps_max_dec_pic_buffering[i] - 1);
453  goto err;
454  }
455  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
456  av_log(s->avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
457  vps->vps_num_reorder_pics[i]);
459  goto err;
460  }
461  }
462 
463  vps->vps_max_layer_id = get_bits(gb, 6);
464  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
465  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
466  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
467  av_log(s->avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
468  goto err;
469  }
470 
471  for (i = 1; i < vps->vps_num_layer_sets; i++)
472  for (j = 0; j <= vps->vps_max_layer_id; j++)
473  skip_bits(gb, 1); // layer_id_included_flag[i][j]
474 
476  if (vps->vps_timing_info_present_flag) {
477  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
478  vps->vps_time_scale = get_bits_long(gb, 32);
483  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
485  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
486  goto err;
487  }
488  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
489  int common_inf_present = 1;
490 
491  get_ue_golomb_long(gb); // hrd_layer_set_idx
492  if (i)
493  common_inf_present = get_bits1(gb);
494  decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
495  }
496  }
497  get_bits1(gb); /* vps_extension_flag */
498 
499  if (get_bits_left(gb) < 0) {
501  "Overread VPS by %d bits\n", -get_bits_left(gb));
502  if (s->vps_list[vps_id])
503  goto err;
504  }
505 
506  if (s->vps_list[vps_id] &&
507  !memcmp(s->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
508  av_buffer_unref(&vps_buf);
509  } else {
510  remove_vps(s, vps_id);
511  s->vps_list[vps_id] = vps_buf;
512  }
513 
514  return 0;
515 
516 err:
517  av_buffer_unref(&vps_buf);
518  return AVERROR_INVALIDDATA;
519 }
520 
521 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
522 {
523  VUI *vui = &sps->vui;
524  GetBitContext *gb = &s->HEVClc->gb;
525  GetBitContext backup;
526  int sar_present, alt = 0;
527 
528  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
529 
530  sar_present = get_bits1(gb);
531  if (sar_present) {
532  uint8_t sar_idx = get_bits(gb, 8);
533  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
534  vui->sar = vui_sar[sar_idx];
535  else if (sar_idx == 255) {
536  vui->sar.num = get_bits(gb, 16);
537  vui->sar.den = get_bits(gb, 16);
538  } else
540  "Unknown SAR index: %u.\n", sar_idx);
541  }
542 
546 
549  vui->video_format = get_bits(gb, 3);
550  vui->video_full_range_flag = get_bits1(gb);
555  vui->colour_primaries = get_bits(gb, 8);
556  vui->transfer_characteristic = get_bits(gb, 8);
557  vui->matrix_coeffs = get_bits(gb, 8);
558 
559  // Set invalid values to "unspecified"
560  if (vui->colour_primaries >= AVCOL_PRI_NB)
564  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
566  }
567  }
568 
570  if (vui->chroma_loc_info_present_flag) {
573  }
574 
576  vui->field_seq_flag = get_bits1(gb);
578 
579  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
581  av_log(s->avctx, AV_LOG_WARNING, "Invalid default display window\n");
582  } else
584  // Backup context in case an alternate header is detected
585  memcpy(&backup, gb, sizeof(backup));
586 
587  if (vui->default_display_window_flag) {
588  //TODO: * 2 is only valid for 420
593 
594  if (s->apply_defdispwin &&
597  "discarding vui default display window, "
598  "original values are l:%u r:%u t:%u b:%u\n",
603 
606  vui->def_disp_win.top_offset =
607  vui->def_disp_win.bottom_offset = 0;
608  }
609  }
610 
612 
613  if (vui->vui_timing_info_present_flag) {
614  if( get_bits_left(gb) < 66) {
615  // The alternate syntax seem to have timing info located
616  // at where def_disp_win is normally located
618  "Strange VUI timing information, retrying...\n");
620  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
621  memcpy(gb, &backup, sizeof(backup));
622  alt = 1;
623  }
624  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
625  vui->vui_time_scale = get_bits_long(gb, 32);
626  if (alt) {
627  av_log(s->avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
629  }
635  decode_hrd(s, 1, sps->max_sub_layers);
636  }
637 
639  if (vui->bitstream_restriction_flag) {
648  }
649 }
650 
652 {
653  int matrixId;
654 
655  for (matrixId = 0; matrixId < 6; matrixId++) {
656  // 4x4 default is 16
657  memset(sl->sl[0][matrixId], 16, 16);
658  sl->sl_dc[0][matrixId] = 16; // default for 16x16
659  sl->sl_dc[1][matrixId] = 16; // default for 32x32
660  }
661  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
662  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
663  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
664  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
665  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
666  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
667  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
668  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
669  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
670  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
671  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
672  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
673  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
674  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
675  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
676  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
677  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
678  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
679 }
680 
682 {
683  GetBitContext *gb = &s->HEVClc->gb;
684  uint8_t scaling_list_pred_mode_flag;
685  int32_t scaling_list_dc_coef[2][6];
686  int size_id, matrix_id, pos;
687  int i;
688 
689  for (size_id = 0; size_id < 4; size_id++)
690  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
691  scaling_list_pred_mode_flag = get_bits1(gb);
692  if (!scaling_list_pred_mode_flag) {
693  unsigned int delta = get_ue_golomb_long(gb);
694  /* Only need to handle non-zero delta. Zero means default,
695  * which should already be in the arrays. */
696  if (delta) {
697  // Copy from previous array.
698  if (matrix_id < delta) {
700  "Invalid delta in scaling list data: %d.\n", delta);
701  return AVERROR_INVALIDDATA;
702  }
703 
704  memcpy(sl->sl[size_id][matrix_id],
705  sl->sl[size_id][matrix_id - delta],
706  size_id > 0 ? 64 : 16);
707  if (size_id > 1)
708  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
709  }
710  } else {
711  int next_coef, coef_num;
712  int32_t scaling_list_delta_coef;
713 
714  next_coef = 8;
715  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
716  if (size_id > 1) {
717  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
718  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
719  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
720  }
721  for (i = 0; i < coef_num; i++) {
722  if (size_id == 0)
723  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
725  else
726  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
728 
729  scaling_list_delta_coef = get_se_golomb(gb);
730  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
731  sl->sl[size_id][matrix_id][pos] = next_coef;
732  }
733  }
734  }
735 
736  if (sps->chroma_format_idc == 3) {
737  for (i = 0; i < 64; i++) {
738  sl->sl[3][1][i] = sl->sl[2][1][i];
739  sl->sl[3][2][i] = sl->sl[2][2][i];
740  sl->sl[3][4][i] = sl->sl[2][4][i];
741  sl->sl[3][5][i] = sl->sl[2][5][i];
742  }
743  sl->sl_dc[1][1] = sl->sl_dc[0][1];
744  sl->sl_dc[1][2] = sl->sl_dc[0][2];
745  sl->sl_dc[1][4] = sl->sl_dc[0][4];
746  sl->sl_dc[1][5] = sl->sl_dc[0][5];
747  }
748 
749 
750  return 0;
751 }
752 
754 {
755  const AVPixFmtDescriptor *desc;
756  GetBitContext *gb = &s->HEVClc->gb;
757  int ret = 0;
758  unsigned int sps_id = 0;
759  int log2_diff_max_min_transform_block_size;
760  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
761  int i;
762 
763  HEVCSPS *sps;
764  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
765 
766  if (!sps_buf)
767  return AVERROR(ENOMEM);
768  sps = (HEVCSPS*)sps_buf->data;
769 
770  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
771 
772  // Coded parameters
773 
774  sps->vps_id = get_bits(gb, 4);
775  if (sps->vps_id >= MAX_VPS_COUNT) {
776  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
777  ret = AVERROR_INVALIDDATA;
778  goto err;
779  }
780 
781  if (!s->vps_list[sps->vps_id]) {
782  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
783  sps->vps_id);
784  ret = AVERROR_INVALIDDATA;
785  goto err;
786  }
787 
788  sps->max_sub_layers = get_bits(gb, 3) + 1;
789  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
790  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
791  sps->max_sub_layers);
792  ret = AVERROR_INVALIDDATA;
793  goto err;
794  }
795 
796  skip_bits1(gb); // temporal_id_nesting_flag
797 
798  if (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)
799  goto err;
800 
801  sps_id = get_ue_golomb_long(gb);
802  if (sps_id >= MAX_SPS_COUNT) {
803  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
804  ret = AVERROR_INVALIDDATA;
805  goto err;
806  }
807 
809 
810  if (sps->chroma_format_idc == 3)
812 
814  sps->chroma_format_idc = 0;
815 
816  sps->width = get_ue_golomb_long(gb);
817  sps->height = get_ue_golomb_long(gb);
818  if ((ret = av_image_check_size(sps->width,
819  sps->height, 0, s->avctx)) < 0)
820  goto err;
821 
822  if (get_bits1(gb)) { // pic_conformance_flag
823  //TODO: * 2 is only valid for 420
828 
831  "discarding sps conformance window, "
832  "original values are l:%u r:%u t:%u b:%u\n",
837 
840  sps->pic_conf_win.top_offset =
841  sps->pic_conf_win.bottom_offset = 0;
842  }
843  sps->output_window = sps->pic_conf_win;
844  }
845 
846  sps->bit_depth = get_ue_golomb_long(gb) + 8;
847  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
848  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
850  "Luma bit depth (%d) is different from chroma bit depth (%d), "
851  "this is unsupported.\n",
852  sps->bit_depth, bit_depth_chroma);
853  ret = AVERROR_INVALIDDATA;
854  goto err;
855  }
856 
857  switch (sps->bit_depth) {
858  case 8:
859  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
860  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
861  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
862  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
863  break;
864  case 9:
865  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
866  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
867  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
868  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
869  break;
870  case 10:
871  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
872  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
873  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
874  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
875  break;
876  case 12:
877  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
878  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
879  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
880  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
881  break;
882  default:
884  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
885  ret = AVERROR_PATCHWELCOME;
886  goto err;
887  }
888 
889  desc = av_pix_fmt_desc_get(sps->pix_fmt);
890  if (!desc) {
891  ret = AVERROR(EINVAL);
892  goto err;
893  }
894 
895  sps->hshift[0] = sps->vshift[0] = 0;
896  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
897  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
898 
899  sps->pixel_shift = sps->bit_depth > 8;
900 
901  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
902  if (sps->log2_max_poc_lsb > 16) {
903  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
904  sps->log2_max_poc_lsb - 4);
905  ret = AVERROR_INVALIDDATA;
906  goto err;
907  }
908 
909  sublayer_ordering_info = get_bits1(gb);
910  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
911  for (i = start; i < sps->max_sub_layers; i++) {
916  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
918  ret = AVERROR_INVALIDDATA;
919  goto err;
920  }
922  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
924  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
926  ret = AVERROR_INVALIDDATA;
927  goto err;
928  }
930  }
931  }
932 
933  if (!sublayer_ordering_info) {
934  for (i = 0; i < start; i++) {
938  }
939  }
940 
941  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
943  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
944  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
945  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
946  sps->log2_min_tb_size;
947 
948  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
949  av_log(s->avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
950  ret = AVERROR_INVALIDDATA;
951  goto err;
952  }
953 
954  if (sps->log2_diff_max_min_coding_block_size > 30) {
955  av_log(s->avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_coding_block_size", sps->log2_diff_max_min_coding_block_size);
956  ret = AVERROR_INVALIDDATA;
957  goto err;
958  }
959 
960  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
961  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
962  ret = AVERROR_INVALIDDATA;
963  goto err;
964  }
965 
966  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
967  av_log(s->avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
968  ret = AVERROR_INVALIDDATA;
969  goto err;
970  }
971 
974 
976  if (sps->scaling_list_enable_flag) {
978 
979  if (get_bits1(gb)) {
980  ret = scaling_list_data(s, &sps->scaling_list, sps);
981  if (ret < 0)
982  goto err;
983  }
984  }
985 
986  sps->amp_enabled_flag = get_bits1(gb);
987  sps->sao_enabled = get_bits1(gb);
988 
989  sps->pcm_enabled_flag = get_bits1(gb);
990  if (sps->pcm_enabled_flag) {
991  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
992  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
995  get_ue_golomb_long(gb);
996  if (sps->pcm.bit_depth > sps->bit_depth) {
998  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
999  sps->pcm.bit_depth, sps->bit_depth);
1000  ret = AVERROR_INVALIDDATA;
1001  goto err;
1002  }
1003 
1005  }
1006 
1007  sps->nb_st_rps = get_ue_golomb_long(gb);
1008  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
1009  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1010  sps->nb_st_rps);
1011  ret = AVERROR_INVALIDDATA;
1012  goto err;
1013  }
1014  for (i = 0; i < sps->nb_st_rps; i++) {
1015  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
1016  sps, 0)) < 0)
1017  goto err;
1018  }
1019 
1023  if (sps->num_long_term_ref_pics_sps > 31U) {
1024  av_log(s->avctx, AV_LOG_ERROR, "num_long_term_ref_pics_sps %d is out of range.\n",
1026  goto err;
1027  }
1028  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1029  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1031  }
1032  }
1033 
1036  sps->vui.sar = (AVRational){0, 1};
1037  vui_present = get_bits1(gb);
1038  if (vui_present)
1039  decode_vui(s, sps);
1040 
1041  if (get_bits1(gb)) { // sps_extension_flag
1042  int sps_extension_flag[1];
1043  for (i = 0; i < 1; i++)
1044  sps_extension_flag[i] = get_bits1(gb);
1045  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1046  if (sps_extension_flag[0]) {
1047  int extended_precision_processing_flag;
1048  int high_precision_offsets_enabled_flag;
1049  int cabac_bypass_alignment_enabled_flag;
1050 
1054 
1056 
1057  extended_precision_processing_flag = get_bits1(gb);
1058  if (extended_precision_processing_flag)
1060  "extended_precision_processing_flag not yet implemented\n");
1061 
1063  high_precision_offsets_enabled_flag = get_bits1(gb);
1064  if (high_precision_offsets_enabled_flag)
1066  "high_precision_offsets_enabled_flag not yet implemented\n");
1067 
1069 
1070  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1071  if (cabac_bypass_alignment_enabled_flag)
1073  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1074  }
1075  }
1076  if (s->apply_defdispwin) {
1081  }
1082  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1083  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
1084  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1085  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1086  "chroma samples to preserve alignment.\n",
1087  sps->output_window.left_offset);
1088  }
1089  sps->output_width = sps->width -
1091  sps->output_height = sps->height -
1093  if (sps->width <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset ||
1094  sps->height <= sps->output_window.top_offset + (int64_t)sps->output_window.bottom_offset) {
1095  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1096  sps->output_width, sps->output_height);
1097  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1098  ret = AVERROR_INVALIDDATA;
1099  goto err;
1100  }
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(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1116  goto err;
1117  }
1118  if (sps->log2_ctb_size < 4) {
1119  av_log(s->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(s->avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1124  goto err;
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(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1144  goto err;
1145  }
1146 
1148  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1150  goto err;
1151  }
1153  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1155  goto err;
1156  }
1157  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1159  "max transform block size out of range: %d\n",
1160  sps->log2_max_trafo_size);
1161  goto err;
1162  }
1163 
1164  if (get_bits_left(gb) < 0) {
1166  "Overread SPS by %d bits\n", -get_bits_left(gb));
1167  goto err;
1168  }
1169 
1170  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
1172  "Parsed SPS: id %d; coded wxh: %dx%d; "
1173  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1174  sps_id, sps->width, sps->height,
1175  sps->output_width, sps->output_height,
1177  }
1178 
1179  /* check if this is a repeat of an already parsed SPS, then keep the
1180  * original one.
1181  * otherwise drop all PPSes that depend on it */
1182  if (s->sps_list[sps_id] &&
1183  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1184  av_buffer_unref(&sps_buf);
1185  } else {
1186  remove_sps(s, sps_id);
1187  s->sps_list[sps_id] = sps_buf;
1188  }
1189 
1190  return 0;
1191 
1192 err:
1193  av_buffer_unref(&sps_buf);
1194  return ret;
1195 }
1196 
1197 static void hevc_pps_free(void *opaque, uint8_t *data)
1198 {
1199  HEVCPPS *pps = (HEVCPPS*)data;
1200 
1201  av_freep(&pps->column_width);
1202  av_freep(&pps->row_height);
1203  av_freep(&pps->col_bd);
1204  av_freep(&pps->row_bd);
1205  av_freep(&pps->col_idxX);
1206  av_freep(&pps->ctb_addr_rs_to_ts);
1207  av_freep(&pps->ctb_addr_ts_to_rs);
1208  av_freep(&pps->tile_pos_rs);
1209  av_freep(&pps->tile_id);
1211 
1212  av_freep(&pps);
1213 }
1214 
1216  GetBitContext *gb = &s->HEVClc->gb;
1217  int i;
1218 
1219  if (pps->transform_skip_enabled_flag) {
1221  }
1229  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1230  return AVERROR_INVALIDDATA;
1231  }
1232  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1233  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1234  if (pps->cb_qp_offset_list[i]) {
1236  "cb_qp_offset_list not tested yet.\n");
1237  }
1238  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1239  if (pps->cr_qp_offset_list[i]) {
1241  "cb_qp_offset_list not tested yet.\n");
1242  }
1243  }
1244  }
1247 
1248  return(0);
1249 }
1250 
1252 {
1253  GetBitContext *gb = &s->HEVClc->gb;
1254  HEVCSPS *sps = NULL;
1255  int pic_area_in_ctbs;
1256  int log2_diff_ctb_min_tb_size;
1257  int i, j, x, y, ctb_addr_rs, tile_id;
1258  int ret = 0;
1259  unsigned int pps_id = 0;
1260 
1261  AVBufferRef *pps_buf;
1262  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1263 
1264  if (!pps)
1265  return AVERROR(ENOMEM);
1266 
1267  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1268  hevc_pps_free, NULL, 0);
1269  if (!pps_buf) {
1270  av_freep(&pps);
1271  return AVERROR(ENOMEM);
1272  }
1273 
1274  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1275 
1276  // Default values
1278  pps->num_tile_columns = 1;
1279  pps->num_tile_rows = 1;
1280  pps->uniform_spacing_flag = 1;
1281  pps->disable_dbf = 0;
1282  pps->beta_offset = 0;
1283  pps->tc_offset = 0;
1285 
1286  // Coded parameters
1287  pps_id = get_ue_golomb_long(gb);
1288  if (pps_id >= MAX_PPS_COUNT) {
1289  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1290  ret = AVERROR_INVALIDDATA;
1291  goto err;
1292  }
1293  pps->sps_id = get_ue_golomb_long(gb);
1294  if (pps->sps_id >= MAX_SPS_COUNT) {
1295  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1296  ret = AVERROR_INVALIDDATA;
1297  goto err;
1298  }
1299  if (!s->sps_list[pps->sps_id]) {
1300  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1301  ret = AVERROR_INVALIDDATA;
1302  goto err;
1303  }
1304  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1305 
1308  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1309 
1310  pps->sign_data_hiding_flag = get_bits1(gb);
1311 
1313 
1316 
1318 
1321 
1323  pps->diff_cu_qp_delta_depth = 0;
1324  if (pps->cu_qp_delta_enabled_flag)
1326 
1327  if (pps->diff_cu_qp_delta_depth < 0 ||
1329  av_log(s->avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1330  pps->diff_cu_qp_delta_depth);
1331  ret = AVERROR_INVALIDDATA;
1332  goto err;
1333  }
1334 
1335  pps->cb_qp_offset = get_se_golomb(gb);
1336  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1337  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1338  pps->cb_qp_offset);
1339  ret = AVERROR_INVALIDDATA;
1340  goto err;
1341  }
1342  pps->cr_qp_offset = get_se_golomb(gb);
1343  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1344  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1345  pps->cr_qp_offset);
1346  ret = AVERROR_INVALIDDATA;
1347  goto err;
1348  }
1350 
1351  pps->weighted_pred_flag = get_bits1(gb);
1352  pps->weighted_bipred_flag = get_bits1(gb);
1353 
1355  pps->tiles_enabled_flag = get_bits1(gb);
1357 
1358  if (pps->tiles_enabled_flag) {
1359  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1360  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1361  if (pps->num_tile_columns <= 0 ||
1362  pps->num_tile_columns >= sps->width) {
1363  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1364  pps->num_tile_columns - 1);
1365  ret = AVERROR_INVALIDDATA;
1366  goto err;
1367  }
1368  if (pps->num_tile_rows <= 0 ||
1369  pps->num_tile_rows >= sps->height) {
1370  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1371  pps->num_tile_rows - 1);
1372  ret = AVERROR_INVALIDDATA;
1373  goto err;
1374  }
1375 
1376  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1377  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1378  if (!pps->column_width || !pps->row_height) {
1379  ret = AVERROR(ENOMEM);
1380  goto err;
1381  }
1382 
1383  pps->uniform_spacing_flag = get_bits1(gb);
1384  if (!pps->uniform_spacing_flag) {
1385  uint64_t sum = 0;
1386  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1387  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1388  sum += pps->column_width[i];
1389  }
1390  if (sum >= sps->ctb_width) {
1391  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1392  ret = AVERROR_INVALIDDATA;
1393  goto err;
1394  }
1395  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1396 
1397  sum = 0;
1398  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1399  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1400  sum += pps->row_height[i];
1401  }
1402  if (sum >= sps->ctb_height) {
1403  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1404  ret = AVERROR_INVALIDDATA;
1405  goto err;
1406  }
1407  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1408  }
1410  }
1411 
1413 
1417  pps->disable_dbf = get_bits1(gb);
1418  if (!pps->disable_dbf) {
1419  pps->beta_offset = get_se_golomb(gb) * 2;
1420  pps->tc_offset = get_se_golomb(gb) * 2;
1421  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1422  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1423  pps->beta_offset/2);
1424  ret = AVERROR_INVALIDDATA;
1425  goto err;
1426  }
1427  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1428  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1429  pps->tc_offset/2);
1430  ret = AVERROR_INVALIDDATA;
1431  goto err;
1432  }
1433  }
1434  }
1435 
1437  if (pps->scaling_list_data_present_flag) {
1439  ret = scaling_list_data(s, &pps->scaling_list, sps);
1440  if (ret < 0)
1441  goto err;
1442  }
1445  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1446  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1447  pps->log2_parallel_merge_level - 2);
1448  ret = AVERROR_INVALIDDATA;
1449  goto err;
1450  }
1451 
1453 
1454  if (get_bits1(gb)) { // pps_extension_present_flag
1455  int pps_range_extensions_flag = get_bits1(gb);
1456  /* int pps_extension_7bits = */ get_bits(gb, 7);
1457  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1458  if ((ret = pps_range_extensions(s, pps, sps)) < 0)
1459  goto err;
1460  }
1461  }
1462 
1463  // Inferred parameters
1464  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1465  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1466  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1467  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1468  ret = AVERROR(ENOMEM);
1469  goto err;
1470  }
1471 
1472  if (pps->uniform_spacing_flag) {
1473  if (!pps->column_width) {
1474  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1475  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1476  }
1477  if (!pps->column_width || !pps->row_height) {
1478  ret = AVERROR(ENOMEM);
1479  goto err;
1480  }
1481 
1482  for (i = 0; i < pps->num_tile_columns; i++) {
1483  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1484  (i * sps->ctb_width) / pps->num_tile_columns;
1485  }
1486 
1487  for (i = 0; i < pps->num_tile_rows; i++) {
1488  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1489  (i * sps->ctb_height) / pps->num_tile_rows;
1490  }
1491  }
1492 
1493  pps->col_bd[0] = 0;
1494  for (i = 0; i < pps->num_tile_columns; i++)
1495  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1496 
1497  pps->row_bd[0] = 0;
1498  for (i = 0; i < pps->num_tile_rows; i++)
1499  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1500 
1501  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1502  if (i > pps->col_bd[j])
1503  j++;
1504  pps->col_idxX[i] = j;
1505  }
1506 
1507  /**
1508  * 6.5
1509  */
1510  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1511 
1512  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1513  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1514  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1515  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1516  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1517  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1518  ret = AVERROR(ENOMEM);
1519  goto err;
1520  }
1521 
1522  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1523  int tb_x = ctb_addr_rs % sps->ctb_width;
1524  int tb_y = ctb_addr_rs / sps->ctb_width;
1525  int tile_x = 0;
1526  int tile_y = 0;
1527  int val = 0;
1528 
1529  for (i = 0; i < pps->num_tile_columns; i++) {
1530  if (tb_x < pps->col_bd[i + 1]) {
1531  tile_x = i;
1532  break;
1533  }
1534  }
1535 
1536  for (i = 0; i < pps->num_tile_rows; i++) {
1537  if (tb_y < pps->row_bd[i + 1]) {
1538  tile_y = i;
1539  break;
1540  }
1541  }
1542 
1543  for (i = 0; i < tile_x; i++)
1544  val += pps->row_height[tile_y] * pps->column_width[i];
1545  for (i = 0; i < tile_y; i++)
1546  val += sps->ctb_width * pps->row_height[i];
1547 
1548  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1549  tb_x - pps->col_bd[tile_x];
1550 
1551  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1552  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1553  }
1554 
1555  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1556  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1557  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1558  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1559  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1560 
1561  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1562  if (!pps->tile_pos_rs) {
1563  ret = AVERROR(ENOMEM);
1564  goto err;
1565  }
1566 
1567  for (j = 0; j < pps->num_tile_rows; j++)
1568  for (i = 0; i < pps->num_tile_columns; i++)
1569  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1570 
1571  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1572  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1573  for (y = 0; y < sps->tb_mask+2; y++) {
1574  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1575  pps->min_tb_addr_zs_tab[y] = -1;
1576  }
1577  for (y = 0; y < sps->tb_mask+1; y++) {
1578  for (x = 0; x < sps->tb_mask+1; x++) {
1579  int tb_x = x >> log2_diff_ctb_min_tb_size;
1580  int tb_y = y >> log2_diff_ctb_min_tb_size;
1581  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1582  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1583  (log2_diff_ctb_min_tb_size * 2);
1584  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1585  int m = 1 << i;
1586  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1587  }
1588  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1589  }
1590  }
1591 
1592  if (get_bits_left(gb) < 0) {
1594  "Overread PPS by %d bits\n", -get_bits_left(gb));
1595  goto err;
1596  }
1597 
1598  remove_pps(s, pps_id);
1599  s->pps_list[pps_id] = pps_buf;
1600 
1601  return 0;
1602 
1603 err:
1604  av_buffer_unref(&pps_buf);
1605  return ret;
1606 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:383
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc.h:449
const char const char void * val
Definition: avisynth_c.h:634
uint8_t log2_sao_offset_scale_luma
Definition: hevc.h:542
const char * s
Definition: avisynth_c.h:631
int min_spatial_segmentation_idc
Definition: hevc.h:343
#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:2090
static int parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:277
int ctb_height
Definition: hevc.h:470
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
#define CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:711
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc.h:538
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
enum AVCodecID id
Definition: mxfenc.c:99
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc.h:336
int max_dec_pic_buffering
Definition: hevc.h:417
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:459
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
#define CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:769
int8_t cb_qp_offset_list[5]
Definition: hevc.h:540
int ff_hevc_decode_nal_sps(HEVCContext *s)
Definition: hevc_ps.c:753
unsigned int * row_height
RowHeight.
Definition: hevc.h:547
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2912
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc.h:386
#define MAX_REFS
Definition: hevc.h:40
int pic_init_qp_minus26
Definition: hevc.h:495
#define MAX_PPS_COUNT
Definition: h264.h:50
VUI vui
Definition: hevc.h:422
#define MAX_DPB_SIZE
Definition: hevc.h:39
int vshift[3]
Definition: hevc.h:481
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_cabac.c:430
uint32_t vui_time_scale
Definition: hevc.h:334
static int decode_hrd(HEVCContext *s, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:336
uint8_t weighted_bipred_flag
Definition: hevc.h:507
unsigned int left_offset
Definition: hevc.h:301
Definition: hevc.h:362
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:520
uint8_t cabac_init_present_flag
Definition: hevc.h:491
int chroma_loc_info_present_flag
Definition: hevc.h:321
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:368
int max_latency_increase
Definition: hevc.h:419
#define FF_ARRAY_ELEMS(a)
int min_cb_height
Definition: hevc.h:473
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:553
int explicit_rdpcm_enabled_flag
Definition: hevc.h:462
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:493
static const AVRational vui_sar[]
Definition: hevc_ps.c:52
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:429
int chroma_sample_loc_type_top_field
Definition: hevc.h:322
int width
Definition: hevc.h:467
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:483
int pixel_shift
Definition: hevc.h:409
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:513
HEVCWindow output_window
Definition: hevc.h:404
int output_width
Definition: hevc.h:403
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc.h:532
uint8_t log2_sao_offset_scale_chroma
Definition: hevc.h:543
int restricted_ref_pic_lists_flag
Definition: hevc.h:342
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int chroma_format_idc
Definition: hevc.h:399
uint8_t disable_dbf
Definition: hevc.h:524
unsigned int log2_max_trafo_size
Definition: hevc.h:452
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:354
Definition: hevc.h:307
unsigned int num_negative_pics
Definition: hevc.h:277
uint8_t
uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:366
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:378
float delta
HEVCWindow pic_conf_win
Definition: hevc.h:406
uint8_t log2_max_transform_skip_block_size
Definition: hevc.h:535
int overscan_info_present_flag
Definition: hevc.h:310
uint8_t vps_timing_info_present_flag
Definition: hevc.h:382
uint8_t matrix_coeffs
Definition: hevc.h:319
int min_tb_width
Definition: hevc.h:474
int apply_defdispwin
Definition: hevc.h:905
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:494
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:442
AVCodecContext * avctx
Definition: hevc.h:792
int min_cb_width
Definition: hevc.h:472
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc.h:373
int frame_field_info_present_flag
Definition: hevc.h:327
uint8_t tier_flag
Definition: hevc.h:352
uint8_t scaling_list_data_present_flag
Definition: hevc.h:528
uint8_t bit_depth_chroma
Definition: hevc.h:441
static int decode_profile_tier_level(HEVCContext *s, PTLCommon *ptl)
Definition: hevc_ps.c:240
static int pps_range_extensions(HEVCContext *s, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1215
int ff_hevc_decode_nal_vps(HEVCContext *s)
Definition: hevc_ps.c:399
uint8_t loop_filter_disable_flag
Definition: hevc.h:444
int ff_hevc_decode_nal_pps(HEVCContext *s)
Definition: hevc_ps.c:1251
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:369
int bitstream_restriction_flag
Definition: hevc.h:339
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:509
#define av_log(a,...)
unsigned m
Definition: audioconvert.c:187
int8_t cr_qp_offset_list[5]
Definition: hevc.h:541
int vps_max_layer_id
Definition: hevc.h:380
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
const HEVCSPS * sps
Definition: hevc.h:816
static void remove_sps(HEVCContext *s, int id)
Definition: hevc_ps.c:79
#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:359
unsigned int log2_max_poc_lsb
Definition: hevc.h:412
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:372
int min_pu_height
Definition: hevc.h:477
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:818
int persistent_rice_adaptation_enabled_flag
coded frame dimension in various units
Definition: hevc.h:464
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2623
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:332
uint8_t amp_enabled_flag
Definition: hevc.h:431
#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:471
unsigned int log2_ctb_size
Definition: hevc.h:453
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1335
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:335
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:367
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:371
uint8_t colour_primaries
Definition: hevc.h:317
uint8_t used[32]
Definition: hevc.h:280
int motion_vectors_over_pic_boundaries_flag
Definition: hevc.h:341
uint8_t tiles_enabled_flag
Definition: hevc.h:512
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:383
const HEVCPPS * pps
Definition: hevc.h:817
int * col_idxX
Definition: hevc.h:550
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc.h:381
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:362
uint8_t lists_modification_present_flag
Definition: hevc.h:531
int * min_tb_addr_zs_tab
MinTbAddrZS.
Definition: hevc.h:557
uint8_t profile_idc
Definition: hevc.h:353
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 scaling_list_data(HEVCContext *s, ScalingList *sl, HEVCSPS *sps)
Definition: hevc_ps.c:681
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2612
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:348
int max_transform_hierarchy_depth_inter
Definition: hevc.h:456
#define FFMIN(a, b)
Definition: common.h:66
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:385
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:515
ret
Definition: avfilter.c:974
int output_height
Definition: hevc.h:403
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2911
unsigned int top_offset
Definition: hevc.h:303
int hshift[3]
Definition: hevc.h:480
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:819
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:345
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:500
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:436
#define MAX_SPS_COUNT
Definition: h264.h:49
int ctb_width
Definition: hevc.h:469
uint8_t sl_dc[2][6]
Definition: hevc.h:394
int32_t delta_poc[32]
Definition: hevc.h:279
uint8_t sign_data_hiding_flag
Definition: hevc.h:489
int height
Definition: hevc.h:468
uint8_t output_flag_present_flag
Definition: hevc.h:508
int log2_max_mv_length_vertical
Definition: hevc.h:347
PTLCommon general_ptl
Definition: hevc.h:363
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:363
int max_bytes_per_pic_denom
Definition: hevc.h:344
int overscan_appropriate_flag
Definition: hevc.h:311
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:651
int implicit_rdpcm_enabled_flag
Definition: hevc.h:461
unsigned vps_id
Definition: hevc.h:398
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:820
uint8_t constrained_intra_pred_flag
Definition: hevc.h:497
int tb_mask
Definition: hevc.h:478
uint8_t sl[4][6][64]
Definition: hevc.h:393
PTL ptl
Definition: hevc.h:375
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:505
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
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
uint32_t vps_time_scale
Definition: hevc.h:384
int colour_description_present_flag
Definition: hevc.h:316
uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:367
Definition: hevc.h:397
enum AVPixelFormat pix_fmt
Definition: hevc.h:410
Definition: hevc.h:370
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:486
uint8_t transform_skip_enabled_flag
Definition: hevc.h:498
uint8_t uniform_spacing_flag
Definition: hevc.h:517
int ctb_size
Definition: hevc.h:471
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:552
PTL ptl
Definition: hevc.h:423
int max_sub_layers
Definition: hevc.h:415
static void remove_pps(HEVCContext *s, int id)
Definition: hevc_ps.c:72
unsigned int log2_min_pu_size
Definition: hevc.h:454
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:487
int debug
debug
Definition: avcodec.h:2565
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:529
struct HEVCSPS::@51 pcm
int log2_max_mv_length_horizontal
Definition: hevc.h:346
uint8_t sao_enabled
Definition: hevc.h:432
int num_extra_slice_header_bits
Definition: hevc.h:533
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc.h:518
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:437
const HEVCVPS * vps
Definition: hevc.h:815
uint8_t cross_component_prediction_enabled_flag
Definition: hevc.h:536
uint32_t vui_num_units_in_tick
Definition: hevc.h:333
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:522
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
int transform_skip_context_enabled_flag
Definition: hevc.h:460
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:329
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:364
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:446
unsigned int nb_st_rps
Definition: hevc.h:428
int chroma_sample_loc_type_bottom_field
Definition: hevc.h:323
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc.h:516
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
uint8_t chroma_qp_offset_list_enabled_flag
Definition: hevc.h:537
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_cabac.c:470
rational number numerator/denominator
Definition: rational.h:43
int vps_num_hrd_parameters
Definition: hevc.h:387
#define MAX_SUB_LAYERS
7.4.2.1
Definition: hevc.h:48
Not part of ABI.
Definition: pixfmt.h:494
GetBitContext gb
Definition: hevc.h:754
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:1197
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:2913
unsigned int log2_min_tb_size
Definition: hevc.h:451
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:435
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:361
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:425
int * tile_id
TileId.
Definition: hevc.h:554
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:30
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:526
uint8_t transfer_characteristic
Definition: hevc.h:318
int default_display_window_flag
Definition: hevc.h:329
HEVCLocalContext * HEVClc
Definition: hevc.h:797
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc.h:330
int cr_qp_offset
Definition: hevc.h:504
ScalingList scaling_list
Definition: hevc.h:426
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:365
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:450
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:371
unsigned int log2_max_pcm_cb_size
Definition: hevc.h:443
uint8_t level_idc
Definition: hevc.h:355
int neutra_chroma_indication_flag
Definition: hevc.h:324
int * tile_pos_rs
TilePosRS.
Definition: hevc.h:555
static void decode_vui(HEVCContext *s, HEVCSPS *sps)
Definition: hevc_ps.c:521
A reference to a data buffer.
Definition: buffer.h:81
int max_transform_hierarchy_depth_intra
Definition: hevc.h:457
uint8_t profile_space
Definition: hevc.h:351
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:549
int video_format
Definition: hevc.h:314
uint8_t weighted_pred_flag
Definition: hevc.h:506
unsigned int * col_bd
ColBd.
Definition: hevc.h:548
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:546
uint8_t slice_header_extension_present_flag
Definition: hevc.h:534
static void remove_vps(HEVCContext *s, int id)
Definition: hevc_ps.c:96
int den
denominator
Definition: rational.h:45
int video_full_range_flag
Definition: hevc.h:315
PTLCommon sub_layer_ptl[MAX_SUB_LAYERS]
Definition: hevc.h:364
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2910
AVRational sar
Definition: hevc.h:308
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc.h:539
int num_delta_pocs
Definition: hevc.h:278
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:447
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2568
int min_pu_width
Definition: hevc.h:476
int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:110
unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS]
Definition: hevc.h:377
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:434
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:379
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1342
static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:318
int vui_hrd_parameters_present_flag
Definition: hevc.h:337
unsigned int right_offset
Definition: hevc.h:302
int diff_cu_qp_delta_depth
Definition: hevc.h:501
#define av_freep(p)
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_cabac.c:451
void INT64 start
Definition: avisynth_c.h:553
int num_reorder_pics
Definition: hevc.h:418
struct HEVCSPS::@50 temporal_layer[MAX_SUB_LAYERS]
uint8_t progressive_source_flag
Definition: hevc.h:356
int cb_qp_offset
Definition: hevc.h:503
#define av_malloc_array(a, b)
int video_signal_type_present_flag
Definition: hevc.h:313
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:523
int bit_depth
Definition: hevc.h:408
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:525
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:2011
int min_tb_height
Definition: hevc.h:475
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc.h:556
uint8_t non_packed_constraint_flag
Definition: hevc.h:358
int intra_smoothing_disabled_flag
Definition: hevc.h:463
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:413
int tiles_fixed_structure_flag
Definition: hevc.h:340
uint8_t interlaced_source_flag
Definition: hevc.h:357
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:250
int field_seq_flag
Definition: hevc.h:326
Not part of ABI.
Definition: pixfmt.h:512
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:400
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_cabac.c:437
unsigned int bottom_offset
Definition: hevc.h:304
int vps_sub_layer_ordering_info_present_flag
Definition: hevc.h:376
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:511