FFmpeg  2.6.9
 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 
73  const HEVCSPS *sps, int is_slice_header)
74 {
75  HEVCLocalContext *lc = s->HEVClc;
76  uint8_t rps_predict = 0;
77  int delta_poc;
78  int k0 = 0;
79  int k1 = 0;
80  int k = 0;
81  int i;
82 
83  GetBitContext *gb = &lc->gb;
84 
85  if (rps != sps->st_rps && sps->nb_st_rps)
86  rps_predict = get_bits1(gb);
87 
88  if (rps_predict) {
89  const ShortTermRPS *rps_ridx;
90  int delta_rps;
91  unsigned abs_delta_rps;
92  uint8_t use_delta_flag = 0;
93  uint8_t delta_rps_sign;
94 
95  if (is_slice_header) {
96  unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
97  if (delta_idx > sps->nb_st_rps) {
99  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
100  delta_idx, sps->nb_st_rps);
101  return AVERROR_INVALIDDATA;
102  }
103  rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
104  } else
105  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
106 
107  delta_rps_sign = get_bits1(gb);
108  abs_delta_rps = get_ue_golomb_long(gb) + 1;
109  if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
111  "Invalid value of abs_delta_rps: %d\n",
112  abs_delta_rps);
113  return AVERROR_INVALIDDATA;
114  }
115  delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
116  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
117  int used = rps->used[k] = get_bits1(gb);
118 
119  if (!used)
120  use_delta_flag = get_bits1(gb);
121 
122  if (used || use_delta_flag) {
123  if (i < rps_ridx->num_delta_pocs)
124  delta_poc = delta_rps + rps_ridx->delta_poc[i];
125  else
126  delta_poc = delta_rps;
127  rps->delta_poc[k] = delta_poc;
128  if (delta_poc < 0)
129  k0++;
130  else
131  k1++;
132  k++;
133  }
134  }
135 
136  rps->num_delta_pocs = k;
137  rps->num_negative_pics = k0;
138  // sort in increasing order (smallest first)
139  if (rps->num_delta_pocs != 0) {
140  int used, tmp;
141  for (i = 1; i < rps->num_delta_pocs; i++) {
142  delta_poc = rps->delta_poc[i];
143  used = rps->used[i];
144  for (k = i - 1; k >= 0; k--) {
145  tmp = rps->delta_poc[k];
146  if (delta_poc < tmp) {
147  rps->delta_poc[k + 1] = tmp;
148  rps->used[k + 1] = rps->used[k];
149  rps->delta_poc[k] = delta_poc;
150  rps->used[k] = used;
151  }
152  }
153  }
154  }
155  if ((rps->num_negative_pics >> 1) != 0) {
156  int used;
157  k = rps->num_negative_pics - 1;
158  // flip the negative values to largest first
159  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
160  delta_poc = rps->delta_poc[i];
161  used = rps->used[i];
162  rps->delta_poc[i] = rps->delta_poc[k];
163  rps->used[i] = rps->used[k];
164  rps->delta_poc[k] = delta_poc;
165  rps->used[k] = used;
166  k--;
167  }
168  }
169  } else {
170  unsigned int prev, nb_positive_pics;
172  nb_positive_pics = get_ue_golomb_long(gb);
173 
174  if (rps->num_negative_pics >= MAX_REFS ||
175  nb_positive_pics >= MAX_REFS) {
176  av_log(s->avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
177  return AVERROR_INVALIDDATA;
178  }
179 
180  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
181  if (rps->num_delta_pocs) {
182  prev = 0;
183  for (i = 0; i < rps->num_negative_pics; i++) {
184  delta_poc = get_ue_golomb_long(gb) + 1;
185  prev -= delta_poc;
186  rps->delta_poc[i] = prev;
187  rps->used[i] = get_bits1(gb);
188  }
189  prev = 0;
190  for (i = 0; i < nb_positive_pics; i++) {
191  delta_poc = get_ue_golomb_long(gb) + 1;
192  prev += delta_poc;
193  rps->delta_poc[rps->num_negative_pics + i] = prev;
194  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
195  }
196  }
197  }
198  return 0;
199 }
200 
201 
203 {
204  int i;
205  HEVCLocalContext *lc = s->HEVClc;
206  GetBitContext *gb = &lc->gb;
207 
208  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
209  return -1;
210 
211  ptl->profile_space = get_bits(gb, 2);
212  ptl->tier_flag = get_bits1(gb);
213  ptl->profile_idc = get_bits(gb, 5);
214  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
215  av_log(s->avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
216  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
217  av_log(s->avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
219  av_log(s->avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
220  else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
221  av_log(s->avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
222  else
223  av_log(s->avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
224 
225  for (i = 0; i < 32; i++)
231 
232  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
233  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
234  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
235 
236  return 0;
237 }
238 
239 static int parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
240 {
241  int i;
242  HEVCLocalContext *lc = s->HEVClc;
243  GetBitContext *gb = &lc->gb;
244  if (decode_profile_tier_level(s, &ptl->general_ptl) < 0 ||
245  get_bits_left(gb) < 8 + 8*2) {
246  av_log(s->avctx, AV_LOG_ERROR, "PTL information too short\n");
247  return -1;
248  }
249 
250  ptl->general_ptl.level_idc = get_bits(gb, 8);
251 
252  for (i = 0; i < max_num_sub_layers - 1; i++) {
255  }
256 
257  if (max_num_sub_layers - 1> 0)
258  for (i = max_num_sub_layers - 1; i < 8; i++)
259  skip_bits(gb, 2); // reserved_zero_2bits[i]
260  for (i = 0; i < max_num_sub_layers - 1; i++) {
261  if (ptl->sub_layer_profile_present_flag[i] &&
262  decode_profile_tier_level(s, &ptl->sub_layer_ptl[i]) < 0) {
264  "PTL information for sublayer %i too short\n", i);
265  return -1;
266  }
267  if (ptl->sub_layer_level_present_flag[i]) {
268  if (get_bits_left(gb) < 8) {
270  "Not enough data for sublayer %i level_idc\n", i);
271  return -1;
272  } else
273  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
274  }
275  }
276 
277  return 0;
278 }
279 
280 static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb,
281  int subpic_params_present)
282 {
283  GetBitContext *gb = &s->HEVClc->gb;
284  int i;
285 
286  for (i = 0; i < nb_cpb; i++) {
287  get_ue_golomb_long(gb); // bit_rate_value_minus1
288  get_ue_golomb_long(gb); // cpb_size_value_minus1
289 
290  if (subpic_params_present) {
291  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
292  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
293  }
294  skip_bits1(gb); // cbr_flag
295  }
296 }
297 
298 static int decode_hrd(HEVCContext *s, int common_inf_present,
299  int max_sublayers)
300 {
301  GetBitContext *gb = &s->HEVClc->gb;
302  int nal_params_present = 0, vcl_params_present = 0;
303  int subpic_params_present = 0;
304  int i;
305 
306  if (common_inf_present) {
307  nal_params_present = get_bits1(gb);
308  vcl_params_present = get_bits1(gb);
309 
310  if (nal_params_present || vcl_params_present) {
311  subpic_params_present = get_bits1(gb);
312 
313  if (subpic_params_present) {
314  skip_bits(gb, 8); // tick_divisor_minus2
315  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
316  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
317  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
318  }
319 
320  skip_bits(gb, 4); // bit_rate_scale
321  skip_bits(gb, 4); // cpb_size_scale
322 
323  if (subpic_params_present)
324  skip_bits(gb, 4); // cpb_size_du_scale
325 
326  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
327  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
328  skip_bits(gb, 5); // dpb_output_delay_length_minus1
329  }
330  }
331 
332  for (i = 0; i < max_sublayers; i++) {
333  int low_delay = 0;
334  unsigned int nb_cpb = 1;
335  int fixed_rate = get_bits1(gb);
336 
337  if (!fixed_rate)
338  fixed_rate = get_bits1(gb);
339 
340  if (fixed_rate)
341  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
342  else
343  low_delay = get_bits1(gb);
344 
345  if (!low_delay) {
346  nb_cpb = get_ue_golomb_long(gb) + 1;
347  if (nb_cpb < 1 || nb_cpb > 32) {
348  av_log(s->avctx, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
349  return AVERROR_INVALIDDATA;
350  }
351  }
352 
353  if (nal_params_present)
354  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
355  if (vcl_params_present)
356  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
357  }
358  return 0;
359 }
360 
362 {
363  int i,j;
364  GetBitContext *gb = &s->HEVClc->gb;
365  int vps_id = 0;
366  HEVCVPS *vps;
367  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
368 
369  if (!vps_buf)
370  return AVERROR(ENOMEM);
371  vps = (HEVCVPS*)vps_buf->data;
372 
373  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VPS\n");
374 
375  vps_id = get_bits(gb, 4);
376  if (vps_id >= MAX_VPS_COUNT) {
377  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
378  goto err;
379  }
380 
381  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
382  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
383  goto err;
384  }
385 
386  vps->vps_max_layers = get_bits(gb, 6) + 1;
387  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
389 
390  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
391  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
392  goto err;
393  }
394 
395  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
396  av_log(s->avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
397  vps->vps_max_sub_layers);
398  goto err;
399  }
400 
401  if (parse_ptl(s, &vps->ptl, vps->vps_max_sub_layers) < 0)
402  goto err;
403 
405 
407  for (; i < vps->vps_max_sub_layers; i++) {
411 
413  av_log(s->avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
414  vps->vps_max_dec_pic_buffering[i] - 1);
415  goto err;
416  }
417  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
418  av_log(s->avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
419  vps->vps_num_reorder_pics[i]);
421  goto err;
422  }
423  }
424 
425  vps->vps_max_layer_id = get_bits(gb, 6);
426  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
427  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
428  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
429  av_log(s->avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
430  goto err;
431  }
432 
433  for (i = 1; i < vps->vps_num_layer_sets; i++)
434  for (j = 0; j <= vps->vps_max_layer_id; j++)
435  skip_bits(gb, 1); // layer_id_included_flag[i][j]
436 
438  if (vps->vps_timing_info_present_flag) {
439  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
440  vps->vps_time_scale = get_bits_long(gb, 32);
445  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
447  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
448  goto err;
449  }
450  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
451  int common_inf_present = 1;
452 
453  get_ue_golomb_long(gb); // hrd_layer_set_idx
454  if (i)
455  common_inf_present = get_bits1(gb);
456  decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
457  }
458  }
459  get_bits1(gb); /* vps_extension_flag */
460 
461  if (get_bits_left(gb) < 0) {
463  "Overread VPS by %d bits\n", -get_bits_left(gb));
464  if (s->vps_list[vps_id])
465  goto err;
466  }
467 
468  av_buffer_unref(&s->vps_list[vps_id]);
469  s->vps_list[vps_id] = vps_buf;
470  return 0;
471 
472 err:
473  av_buffer_unref(&vps_buf);
474  return AVERROR_INVALIDDATA;
475 }
476 
477 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
478 {
479  VUI *vui = &sps->vui;
480  GetBitContext *gb = &s->HEVClc->gb;
481  GetBitContext backup;
482  int sar_present, alt = 0;
483 
484  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
485 
486  sar_present = get_bits1(gb);
487  if (sar_present) {
488  uint8_t sar_idx = get_bits(gb, 8);
489  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
490  vui->sar = vui_sar[sar_idx];
491  else if (sar_idx == 255) {
492  vui->sar.num = get_bits(gb, 16);
493  vui->sar.den = get_bits(gb, 16);
494  } else
496  "Unknown SAR index: %u.\n", sar_idx);
497  }
498 
502 
505  vui->video_format = get_bits(gb, 3);
506  vui->video_full_range_flag = get_bits1(gb);
511  vui->colour_primaries = get_bits(gb, 8);
512  vui->transfer_characteristic = get_bits(gb, 8);
513  vui->matrix_coeffs = get_bits(gb, 8);
514 
515  // Set invalid values to "unspecified"
516  if (vui->colour_primaries >= AVCOL_PRI_NB)
520  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
522  }
523  }
524 
526  if (vui->chroma_loc_info_present_flag) {
529  }
530 
532  vui->field_seq_flag = get_bits1(gb);
534 
535  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
537  av_log(s->avctx, AV_LOG_WARNING, "Invalid default display window\n");
538  } else
540  // Backup context in case an alternate header is detected
541  memcpy(&backup, gb, sizeof(backup));
542 
543  if (vui->default_display_window_flag) {
544  //TODO: * 2 is only valid for 420
549 
550  if (s->apply_defdispwin &&
553  "discarding vui default display window, "
554  "original values are l:%u r:%u t:%u b:%u\n",
559 
562  vui->def_disp_win.top_offset =
563  vui->def_disp_win.bottom_offset = 0;
564  }
565  }
566 
568 
569  if (vui->vui_timing_info_present_flag) {
570  if( get_bits_left(gb) < 66) {
571  // The alternate syntax seem to have timing info located
572  // at where def_disp_win is normally located
574  "Strange VUI timing information, retrying...\n");
576  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
577  memcpy(gb, &backup, sizeof(backup));
578  alt = 1;
579  }
580  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
581  vui->vui_time_scale = get_bits_long(gb, 32);
582  if (alt) {
583  av_log(s->avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
585  }
591  decode_hrd(s, 1, sps->max_sub_layers);
592  }
593 
595  if (vui->bitstream_restriction_flag) {
604  }
605 }
606 
608 {
609  int matrixId;
610 
611  for (matrixId = 0; matrixId < 6; matrixId++) {
612  // 4x4 default is 16
613  memset(sl->sl[0][matrixId], 16, 16);
614  sl->sl_dc[0][matrixId] = 16; // default for 16x16
615  sl->sl_dc[1][matrixId] = 16; // default for 32x32
616  }
617  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
618  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
619  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
620  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
621  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
622  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
623  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
624  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
625  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
626  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
627  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
628  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
629  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
630  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
631  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
632  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
633  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
634  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
635 }
636 
638 {
639  GetBitContext *gb = &s->HEVClc->gb;
640  uint8_t scaling_list_pred_mode_flag;
641  int32_t scaling_list_dc_coef[2][6];
642  int size_id, matrix_id, pos;
643  int i;
644 
645  for (size_id = 0; size_id < 4; size_id++)
646  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
647  scaling_list_pred_mode_flag = get_bits1(gb);
648  if (!scaling_list_pred_mode_flag) {
649  unsigned int delta = get_ue_golomb_long(gb);
650  /* Only need to handle non-zero delta. Zero means default,
651  * which should already be in the arrays. */
652  if (delta) {
653  // Copy from previous array.
654  if (matrix_id < delta) {
656  "Invalid delta in scaling list data: %d.\n", delta);
657  return AVERROR_INVALIDDATA;
658  }
659 
660  memcpy(sl->sl[size_id][matrix_id],
661  sl->sl[size_id][matrix_id - delta],
662  size_id > 0 ? 64 : 16);
663  if (size_id > 1)
664  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
665  }
666  } else {
667  int next_coef, coef_num;
668  int32_t scaling_list_delta_coef;
669 
670  next_coef = 8;
671  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
672  if (size_id > 1) {
673  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
674  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
675  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
676  }
677  for (i = 0; i < coef_num; i++) {
678  if (size_id == 0)
679  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
681  else
682  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
684 
685  scaling_list_delta_coef = get_se_golomb(gb);
686  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
687  sl->sl[size_id][matrix_id][pos] = next_coef;
688  }
689  }
690  }
691 
692  if (sps->chroma_format_idc == 3) {
693  for (i = 0; i < 64; i++) {
694  sl->sl[3][1][i] = sl->sl[2][1][i];
695  sl->sl[3][2][i] = sl->sl[2][2][i];
696  sl->sl[3][4][i] = sl->sl[2][4][i];
697  sl->sl[3][5][i] = sl->sl[2][5][i];
698  }
699  sl->sl_dc[1][1] = sl->sl_dc[0][1];
700  sl->sl_dc[1][2] = sl->sl_dc[0][2];
701  sl->sl_dc[1][4] = sl->sl_dc[0][4];
702  sl->sl_dc[1][5] = sl->sl_dc[0][5];
703  }
704 
705 
706  return 0;
707 }
708 
710 {
711  const AVPixFmtDescriptor *desc;
712  GetBitContext *gb = &s->HEVClc->gb;
713  int ret = 0;
714  unsigned int sps_id = 0;
715  int log2_diff_max_min_transform_block_size;
716  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
717  int i;
718 
719  HEVCSPS *sps;
720  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
721 
722  if (!sps_buf)
723  return AVERROR(ENOMEM);
724  sps = (HEVCSPS*)sps_buf->data;
725 
726  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
727 
728  // Coded parameters
729 
730  sps->vps_id = get_bits(gb, 4);
731  if (sps->vps_id >= MAX_VPS_COUNT) {
732  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
733  ret = AVERROR_INVALIDDATA;
734  goto err;
735  }
736 
737  if (!s->vps_list[sps->vps_id]) {
738  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
739  sps->vps_id);
740  ret = AVERROR_INVALIDDATA;
741  goto err;
742  }
743 
744  sps->max_sub_layers = get_bits(gb, 3) + 1;
745  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
746  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
747  sps->max_sub_layers);
748  ret = AVERROR_INVALIDDATA;
749  goto err;
750  }
751 
752  skip_bits1(gb); // temporal_id_nesting_flag
753 
754  if (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)
755  goto err;
756 
757  sps_id = get_ue_golomb_long(gb);
758  if (sps_id >= MAX_SPS_COUNT) {
759  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
760  ret = AVERROR_INVALIDDATA;
761  goto err;
762  }
763 
765  if (sps->chroma_format_idc > 3U) {
766  return AVERROR_INVALIDDATA;
767  }
768 
769  if (sps->chroma_format_idc == 3)
771 
773  sps->chroma_format_idc = 0;
774 
775  sps->width = get_ue_golomb_long(gb);
776  sps->height = get_ue_golomb_long(gb);
777  if ((ret = av_image_check_size(sps->width,
778  sps->height, 0, s->avctx)) < 0)
779  goto err;
780 
781  if (get_bits1(gb)) { // pic_conformance_flag
782  //TODO: * 2 is only valid for 420
787 
790  "discarding sps conformance window, "
791  "original values are l:%u r:%u t:%u b:%u\n",
796 
799  sps->pic_conf_win.top_offset =
800  sps->pic_conf_win.bottom_offset = 0;
801  }
802  sps->output_window = sps->pic_conf_win;
803  }
804 
805  sps->bit_depth = get_ue_golomb_long(gb) + 8;
806  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
807  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
809  "Luma bit depth (%d) is different from chroma bit depth (%d), "
810  "this is unsupported.\n",
811  sps->bit_depth, bit_depth_chroma);
812  ret = AVERROR_INVALIDDATA;
813  goto err;
814  }
815 
816  switch (sps->bit_depth) {
817  case 8:
818  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
819  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
820  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
821  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
822  break;
823  case 9:
824  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
825  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
826  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
827  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
828  break;
829  case 10:
830  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
831  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
832  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
833  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
834  break;
835  case 12:
836  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
837  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
838  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
839  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
840  break;
841  default:
843  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
844  ret = AVERROR_PATCHWELCOME;
845  goto err;
846  }
847 
848  desc = av_pix_fmt_desc_get(sps->pix_fmt);
849  if (!desc) {
850  ret = AVERROR(EINVAL);
851  goto err;
852  }
853 
854  sps->hshift[0] = sps->vshift[0] = 0;
855  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
856  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
857 
858  sps->pixel_shift = sps->bit_depth > 8;
859 
860  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
861  if (sps->log2_max_poc_lsb > 16) {
862  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
863  sps->log2_max_poc_lsb - 4);
864  ret = AVERROR_INVALIDDATA;
865  goto err;
866  }
867 
868  sublayer_ordering_info = get_bits1(gb);
869  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
870  for (i = start; i < sps->max_sub_layers; i++) {
875  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
877  ret = AVERROR_INVALIDDATA;
878  goto err;
879  }
881  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
883  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
885  ret = AVERROR_INVALIDDATA;
886  goto err;
887  }
889  }
890  }
891 
892  if (!sublayer_ordering_info) {
893  for (i = 0; i < start; i++) {
897  }
898  }
899 
900  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
902  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
903  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
904  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
905  sps->log2_min_tb_size;
906 
907  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
908  av_log(s->avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
909  ret = AVERROR_INVALIDDATA;
910  goto err;
911  }
912 
913  if (sps->log2_diff_max_min_coding_block_size > 30) {
914  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);
915  ret = AVERROR_INVALIDDATA;
916  goto err;
917  }
918 
919  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
920  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
921  ret = AVERROR_INVALIDDATA;
922  goto err;
923  }
924 
925  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
926  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);
927  ret = AVERROR_INVALIDDATA;
928  goto err;
929  }
930 
933 
935  if (sps->scaling_list_enable_flag) {
937 
938  if (get_bits1(gb)) {
939  ret = scaling_list_data(s, &sps->scaling_list, sps);
940  if (ret < 0)
941  goto err;
942  }
943  }
944 
945  sps->amp_enabled_flag = get_bits1(gb);
946  sps->sao_enabled = get_bits1(gb);
947 
948  sps->pcm_enabled_flag = get_bits1(gb);
949  if (sps->pcm_enabled_flag) {
950  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
951  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
954  get_ue_golomb_long(gb);
955  if (sps->pcm.bit_depth > sps->bit_depth) {
957  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
958  sps->pcm.bit_depth, sps->bit_depth);
959  ret = AVERROR_INVALIDDATA;
960  goto err;
961  }
962 
964  }
965 
966  sps->nb_st_rps = get_ue_golomb_long(gb);
967  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
968  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
969  sps->nb_st_rps);
970  ret = AVERROR_INVALIDDATA;
971  goto err;
972  }
973  for (i = 0; i < sps->nb_st_rps; i++) {
974  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
975  sps, 0)) < 0)
976  goto err;
977  }
978 
982  if (sps->num_long_term_ref_pics_sps > 31U) {
983  av_log(s->avctx, AV_LOG_ERROR, "num_long_term_ref_pics_sps %d is out of range.\n",
985  goto err;
986  }
987  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
990  }
991  }
992 
995  sps->vui.sar = (AVRational){0, 1};
996  vui_present = get_bits1(gb);
997  if (vui_present)
998  decode_vui(s, sps);
999 
1000  if (get_bits1(gb)) { // sps_extension_flag
1001  int sps_extension_flag[1];
1002  for (i = 0; i < 1; i++)
1003  sps_extension_flag[i] = get_bits1(gb);
1004  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1005  if (sps_extension_flag[0]) {
1006  int extended_precision_processing_flag;
1007  int high_precision_offsets_enabled_flag;
1008  int cabac_bypass_alignment_enabled_flag;
1009 
1013 
1015 
1016  extended_precision_processing_flag = get_bits1(gb);
1017  if (extended_precision_processing_flag)
1019  "extended_precision_processing_flag not yet implemented\n");
1020 
1022  high_precision_offsets_enabled_flag = get_bits1(gb);
1023  if (high_precision_offsets_enabled_flag)
1025  "high_precision_offsets_enabled_flag not yet implemented\n");
1026 
1028 
1029  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1030  if (cabac_bypass_alignment_enabled_flag)
1032  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1033  }
1034  }
1035  if (s->apply_defdispwin) {
1040  }
1041  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1042  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
1043  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1044  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1045  "chroma samples to preserve alignment.\n",
1046  sps->output_window.left_offset);
1047  }
1048  sps->output_width = sps->width -
1050  sps->output_height = sps->height -
1052  if (sps->width <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset ||
1053  sps->height <= sps->output_window.top_offset + (int64_t)sps->output_window.bottom_offset) {
1054  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1055  sps->output_width, sps->output_height);
1056  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1057  ret = AVERROR_INVALIDDATA;
1058  goto err;
1059  }
1061  "Displaying the whole video surface.\n");
1062  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1063  memset(&sps->output_window, 0, sizeof(sps->output_window));
1064  sps->output_width = sps->width;
1065  sps->output_height = sps->height;
1066  }
1067 
1068  // Inferred parameters
1069  sps->log2_ctb_size = sps->log2_min_cb_size +
1071  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1072 
1073  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1074  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1075  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1076 
1077  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1078  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1079  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1080  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1081  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1082  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1083  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1084 
1085  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1086 
1087  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
1088  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
1089  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1090  goto err;
1091  }
1092 
1093  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1094  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1095  goto err;
1096  }
1097  if (sps->log2_ctb_size < 4) {
1098  av_log(s->avctx,
1099  AV_LOG_ERROR,
1100  "log2_ctb_size %d differs from the bounds of any known profile\n",
1101  sps->log2_ctb_size);
1102  avpriv_request_sample(s->avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1103  goto err;
1104  }
1106  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1108  goto err;
1109  }
1111  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1113  goto err;
1114  }
1115  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1117  "max transform block size out of range: %d\n",
1118  sps->log2_max_trafo_size);
1119  goto err;
1120  }
1121 
1122  if (get_bits_left(gb) < 0) {
1124  "Overread SPS by %d bits\n", -get_bits_left(gb));
1125  goto err;
1126  }
1127 
1128  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
1130  "Parsed SPS: id %d; coded wxh: %dx%d; "
1131  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1132  sps_id, sps->width, sps->height,
1133  sps->output_width, sps->output_height,
1135  }
1136 
1137  /* check if this is a repeat of an already parsed SPS, then keep the
1138  * original one.
1139  * otherwise drop all PPSes that depend on it */
1140  if (s->sps_list[sps_id] &&
1141  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1142  av_buffer_unref(&sps_buf);
1143  } else {
1144  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
1145  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
1146  av_buffer_unref(&s->pps_list[i]);
1147  }
1148  if (s->sps_list[sps_id] && s->sps == (HEVCSPS*)s->sps_list[sps_id]->data) {
1150  s->current_sps = av_buffer_ref(s->sps_list[sps_id]);
1151  if (!s->current_sps)
1152  s->sps = NULL;
1153  }
1154  av_buffer_unref(&s->sps_list[sps_id]);
1155  s->sps_list[sps_id] = sps_buf;
1156  }
1157 
1158  return 0;
1159 
1160 err:
1161  av_buffer_unref(&sps_buf);
1162  return ret;
1163 }
1164 
1165 static void hevc_pps_free(void *opaque, uint8_t *data)
1166 {
1167  HEVCPPS *pps = (HEVCPPS*)data;
1168 
1169  av_freep(&pps->column_width);
1170  av_freep(&pps->row_height);
1171  av_freep(&pps->col_bd);
1172  av_freep(&pps->row_bd);
1173  av_freep(&pps->col_idxX);
1174  av_freep(&pps->ctb_addr_rs_to_ts);
1175  av_freep(&pps->ctb_addr_ts_to_rs);
1176  av_freep(&pps->tile_pos_rs);
1177  av_freep(&pps->tile_id);
1179 
1180  av_freep(&pps);
1181 }
1182 
1184  GetBitContext *gb = &s->HEVClc->gb;
1185  int i;
1186 
1187  if (pps->transform_skip_enabled_flag) {
1189  }
1197  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1198  return AVERROR_INVALIDDATA;
1199  }
1200  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1201  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1202  if (pps->cb_qp_offset_list[i]) {
1204  "cb_qp_offset_list not tested yet.\n");
1205  }
1206  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1207  if (pps->cr_qp_offset_list[i]) {
1209  "cb_qp_offset_list not tested yet.\n");
1210  }
1211  }
1212  }
1215 
1216  return(0);
1217 }
1218 
1220 {
1221  GetBitContext *gb = &s->HEVClc->gb;
1222  HEVCSPS *sps = NULL;
1223  int pic_area_in_ctbs;
1224  int log2_diff_ctb_min_tb_size;
1225  int i, j, x, y, ctb_addr_rs, tile_id;
1226  int ret = 0;
1227  unsigned int pps_id = 0;
1228 
1229  AVBufferRef *pps_buf;
1230  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1231 
1232  if (!pps)
1233  return AVERROR(ENOMEM);
1234 
1235  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1236  hevc_pps_free, NULL, 0);
1237  if (!pps_buf) {
1238  av_freep(&pps);
1239  return AVERROR(ENOMEM);
1240  }
1241 
1242  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1243 
1244  // Default values
1246  pps->num_tile_columns = 1;
1247  pps->num_tile_rows = 1;
1248  pps->uniform_spacing_flag = 1;
1249  pps->disable_dbf = 0;
1250  pps->beta_offset = 0;
1251  pps->tc_offset = 0;
1253 
1254  // Coded parameters
1255  pps_id = get_ue_golomb_long(gb);
1256  if (pps_id >= MAX_PPS_COUNT) {
1257  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1258  ret = AVERROR_INVALIDDATA;
1259  goto err;
1260  }
1261  pps->sps_id = get_ue_golomb_long(gb);
1262  if (pps->sps_id >= MAX_SPS_COUNT) {
1263  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1264  ret = AVERROR_INVALIDDATA;
1265  goto err;
1266  }
1267  if (!s->sps_list[pps->sps_id]) {
1268  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1269  ret = AVERROR_INVALIDDATA;
1270  goto err;
1271  }
1272  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1273 
1276  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1277 
1278  pps->sign_data_hiding_flag = get_bits1(gb);
1279 
1281 
1284 
1286 
1289 
1291  pps->diff_cu_qp_delta_depth = 0;
1292  if (pps->cu_qp_delta_enabled_flag)
1294 
1295  if (pps->diff_cu_qp_delta_depth < 0 ||
1297  av_log(s->avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1298  pps->diff_cu_qp_delta_depth);
1299  ret = AVERROR_INVALIDDATA;
1300  goto err;
1301  }
1302 
1303  pps->cb_qp_offset = get_se_golomb(gb);
1304  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1305  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1306  pps->cb_qp_offset);
1307  ret = AVERROR_INVALIDDATA;
1308  goto err;
1309  }
1310  pps->cr_qp_offset = get_se_golomb(gb);
1311  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1312  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1313  pps->cr_qp_offset);
1314  ret = AVERROR_INVALIDDATA;
1315  goto err;
1316  }
1318 
1319  pps->weighted_pred_flag = get_bits1(gb);
1320  pps->weighted_bipred_flag = get_bits1(gb);
1321 
1323  pps->tiles_enabled_flag = get_bits1(gb);
1325 
1326  if (pps->tiles_enabled_flag) {
1327  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1328  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1329  if (pps->num_tile_columns <= 0 ||
1330  pps->num_tile_columns >= sps->width) {
1331  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1332  pps->num_tile_columns - 1);
1333  ret = AVERROR_INVALIDDATA;
1334  goto err;
1335  }
1336  if (pps->num_tile_rows <= 0 ||
1337  pps->num_tile_rows >= sps->height) {
1338  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1339  pps->num_tile_rows - 1);
1340  ret = AVERROR_INVALIDDATA;
1341  goto err;
1342  }
1343 
1344  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1345  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1346  if (!pps->column_width || !pps->row_height) {
1347  ret = AVERROR(ENOMEM);
1348  goto err;
1349  }
1350 
1351  pps->uniform_spacing_flag = get_bits1(gb);
1352  if (!pps->uniform_spacing_flag) {
1353  uint64_t sum = 0;
1354  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1355  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1356  sum += pps->column_width[i];
1357  }
1358  if (sum >= sps->ctb_width) {
1359  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1360  ret = AVERROR_INVALIDDATA;
1361  goto err;
1362  }
1363  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1364 
1365  sum = 0;
1366  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1367  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1368  sum += pps->row_height[i];
1369  }
1370  if (sum >= sps->ctb_height) {
1371  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1372  ret = AVERROR_INVALIDDATA;
1373  goto err;
1374  }
1375  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1376  }
1378  }
1379 
1381 
1385  pps->disable_dbf = get_bits1(gb);
1386  if (!pps->disable_dbf) {
1387  pps->beta_offset = get_se_golomb(gb) * 2;
1388  pps->tc_offset = get_se_golomb(gb) * 2;
1389  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1390  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1391  pps->beta_offset/2);
1392  ret = AVERROR_INVALIDDATA;
1393  goto err;
1394  }
1395  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1396  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1397  pps->tc_offset/2);
1398  ret = AVERROR_INVALIDDATA;
1399  goto err;
1400  }
1401  }
1402  }
1403 
1405  if (pps->scaling_list_data_present_flag) {
1407  ret = scaling_list_data(s, &pps->scaling_list, sps);
1408  if (ret < 0)
1409  goto err;
1410  }
1413  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1414  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1415  pps->log2_parallel_merge_level - 2);
1416  ret = AVERROR_INVALIDDATA;
1417  goto err;
1418  }
1419 
1421 
1422  if (get_bits1(gb)) { // pps_extension_present_flag
1423  int pps_range_extensions_flag = get_bits1(gb);
1424  /* int pps_extension_7bits = */ get_bits(gb, 7);
1425  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1426  if ((ret = pps_range_extensions(s, pps, sps)) < 0)
1427  goto err;
1428  }
1429  }
1430 
1431  // Inferred parameters
1432  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1433  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1434  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1435  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1436  ret = AVERROR(ENOMEM);
1437  goto err;
1438  }
1439 
1440  if (pps->uniform_spacing_flag) {
1441  if (!pps->column_width) {
1442  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1443  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1444  }
1445  if (!pps->column_width || !pps->row_height) {
1446  ret = AVERROR(ENOMEM);
1447  goto err;
1448  }
1449 
1450  for (i = 0; i < pps->num_tile_columns; i++) {
1451  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1452  (i * sps->ctb_width) / pps->num_tile_columns;
1453  }
1454 
1455  for (i = 0; i < pps->num_tile_rows; i++) {
1456  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1457  (i * sps->ctb_height) / pps->num_tile_rows;
1458  }
1459  }
1460 
1461  pps->col_bd[0] = 0;
1462  for (i = 0; i < pps->num_tile_columns; i++)
1463  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1464 
1465  pps->row_bd[0] = 0;
1466  for (i = 0; i < pps->num_tile_rows; i++)
1467  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1468 
1469  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1470  if (i > pps->col_bd[j])
1471  j++;
1472  pps->col_idxX[i] = j;
1473  }
1474 
1475  /**
1476  * 6.5
1477  */
1478  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1479 
1480  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1481  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1482  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1483  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1484  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1485  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1486  ret = AVERROR(ENOMEM);
1487  goto err;
1488  }
1489 
1490  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1491  int tb_x = ctb_addr_rs % sps->ctb_width;
1492  int tb_y = ctb_addr_rs / sps->ctb_width;
1493  int tile_x = 0;
1494  int tile_y = 0;
1495  int val = 0;
1496 
1497  for (i = 0; i < pps->num_tile_columns; i++) {
1498  if (tb_x < pps->col_bd[i + 1]) {
1499  tile_x = i;
1500  break;
1501  }
1502  }
1503 
1504  for (i = 0; i < pps->num_tile_rows; i++) {
1505  if (tb_y < pps->row_bd[i + 1]) {
1506  tile_y = i;
1507  break;
1508  }
1509  }
1510 
1511  for (i = 0; i < tile_x; i++)
1512  val += pps->row_height[tile_y] * pps->column_width[i];
1513  for (i = 0; i < tile_y; i++)
1514  val += sps->ctb_width * pps->row_height[i];
1515 
1516  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1517  tb_x - pps->col_bd[tile_x];
1518 
1519  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1520  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1521  }
1522 
1523  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1524  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1525  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1526  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1527  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1528 
1529  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1530  if (!pps->tile_pos_rs) {
1531  ret = AVERROR(ENOMEM);
1532  goto err;
1533  }
1534 
1535  for (j = 0; j < pps->num_tile_rows; j++)
1536  for (i = 0; i < pps->num_tile_columns; i++)
1537  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1538 
1539  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1540  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1541  for (y = 0; y < sps->tb_mask+2; y++) {
1542  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1543  pps->min_tb_addr_zs_tab[y] = -1;
1544  }
1545  for (y = 0; y < sps->tb_mask+1; y++) {
1546  for (x = 0; x < sps->tb_mask+1; x++) {
1547  int tb_x = x >> log2_diff_ctb_min_tb_size;
1548  int tb_y = y >> log2_diff_ctb_min_tb_size;
1549  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1550  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1551  (log2_diff_ctb_min_tb_size * 2);
1552  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1553  int m = 1 << i;
1554  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1555  }
1556  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1557  }
1558  }
1559 
1560  if (get_bits_left(gb) < 0) {
1562  "Overread PPS by %d bits\n", -get_bits_left(gb));
1563  goto err;
1564  }
1565 
1566  av_buffer_unref(&s->pps_list[pps_id]);
1567  s->pps_list[pps_id] = pps_buf;
1568 
1569  return 0;
1570 
1571 err:
1572  av_buffer_unref(&pps_buf);
1573  return ret;
1574 }
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:672
uint8_t log2_sao_offset_scale_luma
Definition: hevc.h:542
const char * s
Definition: avisynth_c.h:669
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:2029
static int parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:239
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:709
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
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:73
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:181
#define CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:767
int8_t cb_qp_offset_list[5]
Definition: hevc.h:540
int ff_hevc_decode_nal_sps(HEVCContext *s)
Definition: hevc_ps.c:709
unsigned int * row_height
RowHeight.
Definition: hevc.h:547
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2909
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:298
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:361
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
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:908
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:202
static int pps_range_extensions(HEVCContext *s, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1183
int ff_hevc_decode_nal_vps(HEVCContext *s)
Definition: hevc_ps.c:361
uint8_t loop_filter_disable_flag
Definition: hevc.h:444
int ff_hevc_decode_nal_pps(HEVCContext *s)
Definition: hevc_ps.c:1219
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:362
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
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
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:2621
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:332
AVBufferRef * current_sps
Definition: hevc.h:822
uint8_t amp_enabled_flag
Definition: hevc.h:431
struct HEVCSPS::@51 temporal_layer[MAX_SUB_LAYERS]
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:196
#define MAX_SHORT_TERM_RPS_COUNT
Definition: hevc.h:52
Not part of ABI.
Definition: pixfmt.h:463
unsigned int log2_ctb_size
Definition: hevc.h:453
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1333
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:335
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:360
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:72
uint32_t vps_num_units_in_tick
Definition: hevc.h:383
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:356
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:637
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2610
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:342
int max_transform_hierarchy_depth_inter
Definition: hevc.h:456
#define FFMIN(a, b)
Definition: common.h:81
float y
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
Definition: pixfmt.h:80
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:2908
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:357
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:607
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:186
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
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:2563
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
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
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:358
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:486
GetBitContext gb
Definition: hevc.h:754
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:1165
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:2910
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:355
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:359
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:450
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:363
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:477
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:68
Y , 8bpp.
Definition: pixfmt.h:76
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
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
uint8_t slice_header_extension_present_flag
Definition: hevc.h:534
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:2907
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
struct HEVCSPS::@52 pcm
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2566
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:72
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:1340
static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:280
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:595
int num_reorder_pics
Definition: hevc.h:418
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:1950
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:504
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