FFmpeg  2.6.3
 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  goto err;
465  }
466 
467  av_buffer_unref(&s->vps_list[vps_id]);
468  s->vps_list[vps_id] = vps_buf;
469  return 0;
470 
471 err:
472  av_buffer_unref(&vps_buf);
473  return AVERROR_INVALIDDATA;
474 }
475 
476 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
477 {
478  VUI *vui = &sps->vui;
479  GetBitContext *gb = &s->HEVClc->gb;
480  GetBitContext backup;
481  int sar_present, alt = 0;
482 
483  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
484 
485  sar_present = get_bits1(gb);
486  if (sar_present) {
487  uint8_t sar_idx = get_bits(gb, 8);
488  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
489  vui->sar = vui_sar[sar_idx];
490  else if (sar_idx == 255) {
491  vui->sar.num = get_bits(gb, 16);
492  vui->sar.den = get_bits(gb, 16);
493  } else
495  "Unknown SAR index: %u.\n", sar_idx);
496  }
497 
501 
504  vui->video_format = get_bits(gb, 3);
505  vui->video_full_range_flag = get_bits1(gb);
510  vui->colour_primaries = get_bits(gb, 8);
511  vui->transfer_characteristic = get_bits(gb, 8);
512  vui->matrix_coeffs = get_bits(gb, 8);
513 
514  // Set invalid values to "unspecified"
515  if (vui->colour_primaries >= AVCOL_PRI_NB)
519  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
521  }
522  }
523 
525  if (vui->chroma_loc_info_present_flag) {
528  }
529 
531  vui->field_seq_flag = get_bits1(gb);
533 
534  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
536  av_log(s->avctx, AV_LOG_WARNING, "Invalid default display window\n");
537  } else
539  // Backup context in case an alternate header is detected
540  memcpy(&backup, gb, sizeof(backup));
541 
542  if (vui->default_display_window_flag) {
543  //TODO: * 2 is only valid for 420
548 
549  if (s->apply_defdispwin &&
552  "discarding vui default display window, "
553  "original values are l:%u r:%u t:%u b:%u\n",
558 
561  vui->def_disp_win.top_offset =
562  vui->def_disp_win.bottom_offset = 0;
563  }
564  }
565 
567 
568  if (vui->vui_timing_info_present_flag) {
569  if( get_bits_left(gb) < 66) {
570  // The alternate syntax seem to have timing info located
571  // at where def_disp_win is normally located
573  "Strange VUI timing information, retrying...\n");
575  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
576  memcpy(gb, &backup, sizeof(backup));
577  alt = 1;
578  }
579  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
580  vui->vui_time_scale = get_bits_long(gb, 32);
581  if (alt) {
582  av_log(s->avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
584  }
590  decode_hrd(s, 1, sps->max_sub_layers);
591  }
592 
594  if (vui->bitstream_restriction_flag) {
603  }
604 }
605 
607 {
608  int matrixId;
609 
610  for (matrixId = 0; matrixId < 6; matrixId++) {
611  // 4x4 default is 16
612  memset(sl->sl[0][matrixId], 16, 16);
613  sl->sl_dc[0][matrixId] = 16; // default for 16x16
614  sl->sl_dc[1][matrixId] = 16; // default for 32x32
615  }
616  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
617  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
618  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
619  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
620  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
621  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
622  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
623  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
624  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
625  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
626  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
627  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
628  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
629  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
630  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
631  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
632  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
633  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
634 }
635 
637 {
638  GetBitContext *gb = &s->HEVClc->gb;
639  uint8_t scaling_list_pred_mode_flag;
640  int32_t scaling_list_dc_coef[2][6];
641  int size_id, matrix_id, pos;
642  int i;
643 
644  for (size_id = 0; size_id < 4; size_id++)
645  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
646  scaling_list_pred_mode_flag = get_bits1(gb);
647  if (!scaling_list_pred_mode_flag) {
648  unsigned int delta = get_ue_golomb_long(gb);
649  /* Only need to handle non-zero delta. Zero means default,
650  * which should already be in the arrays. */
651  if (delta) {
652  // Copy from previous array.
653  if (matrix_id < delta) {
655  "Invalid delta in scaling list data: %d.\n", delta);
656  return AVERROR_INVALIDDATA;
657  }
658 
659  memcpy(sl->sl[size_id][matrix_id],
660  sl->sl[size_id][matrix_id - delta],
661  size_id > 0 ? 64 : 16);
662  if (size_id > 1)
663  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
664  }
665  } else {
666  int next_coef, coef_num;
667  int32_t scaling_list_delta_coef;
668 
669  next_coef = 8;
670  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
671  if (size_id > 1) {
672  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
673  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
674  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
675  }
676  for (i = 0; i < coef_num; i++) {
677  if (size_id == 0)
678  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
680  else
681  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
683 
684  scaling_list_delta_coef = get_se_golomb(gb);
685  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
686  sl->sl[size_id][matrix_id][pos] = next_coef;
687  }
688  }
689  }
690 
691  if (sps->chroma_format_idc == 3) {
692  for (i = 0; i < 64; i++) {
693  sl->sl[3][1][i] = sl->sl[2][1][i];
694  sl->sl[3][2][i] = sl->sl[2][2][i];
695  sl->sl[3][4][i] = sl->sl[2][4][i];
696  sl->sl[3][5][i] = sl->sl[2][5][i];
697  }
698  sl->sl_dc[1][1] = sl->sl_dc[0][1];
699  sl->sl_dc[1][2] = sl->sl_dc[0][2];
700  sl->sl_dc[1][4] = sl->sl_dc[0][4];
701  sl->sl_dc[1][5] = sl->sl_dc[0][5];
702  }
703 
704 
705  return 0;
706 }
707 
709 {
710  const AVPixFmtDescriptor *desc;
711  GetBitContext *gb = &s->HEVClc->gb;
712  int ret = 0;
713  unsigned int sps_id = 0;
714  int log2_diff_max_min_transform_block_size;
715  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
716  int i;
717 
718  HEVCSPS *sps;
719  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
720 
721  if (!sps_buf)
722  return AVERROR(ENOMEM);
723  sps = (HEVCSPS*)sps_buf->data;
724 
725  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
726 
727  // Coded parameters
728 
729  sps->vps_id = get_bits(gb, 4);
730  if (sps->vps_id >= MAX_VPS_COUNT) {
731  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
732  ret = AVERROR_INVALIDDATA;
733  goto err;
734  }
735 
736  if (!s->vps_list[sps->vps_id]) {
737  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
738  sps->vps_id);
739  ret = AVERROR_INVALIDDATA;
740  goto err;
741  }
742 
743  sps->max_sub_layers = get_bits(gb, 3) + 1;
744  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
745  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
746  sps->max_sub_layers);
747  ret = AVERROR_INVALIDDATA;
748  goto err;
749  }
750 
751  skip_bits1(gb); // temporal_id_nesting_flag
752 
753  if (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)
754  goto err;
755 
756  sps_id = get_ue_golomb_long(gb);
757  if (sps_id >= MAX_SPS_COUNT) {
758  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
759  ret = AVERROR_INVALIDDATA;
760  goto err;
761  }
762 
764 
765  if (sps->chroma_format_idc == 3)
767 
769  sps->chroma_format_idc = 0;
770 
771  sps->width = get_ue_golomb_long(gb);
772  sps->height = get_ue_golomb_long(gb);
773  if ((ret = av_image_check_size(sps->width,
774  sps->height, 0, s->avctx)) < 0)
775  goto err;
776 
777  if (get_bits1(gb)) { // pic_conformance_flag
778  //TODO: * 2 is only valid for 420
783 
786  "discarding sps conformance window, "
787  "original values are l:%u r:%u t:%u b:%u\n",
792 
795  sps->pic_conf_win.top_offset =
796  sps->pic_conf_win.bottom_offset = 0;
797  }
798  sps->output_window = sps->pic_conf_win;
799  }
800 
801  sps->bit_depth = get_ue_golomb_long(gb) + 8;
802  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
803  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
805  "Luma bit depth (%d) is different from chroma bit depth (%d), "
806  "this is unsupported.\n",
807  sps->bit_depth, bit_depth_chroma);
808  ret = AVERROR_INVALIDDATA;
809  goto err;
810  }
811 
812  switch (sps->bit_depth) {
813  case 8:
814  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
815  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
816  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
817  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
818  break;
819  case 9:
820  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
821  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
822  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
823  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
824  break;
825  case 10:
826  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
827  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
828  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
829  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
830  break;
831  case 12:
832  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY16;
833  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
834  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
835  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
836  break;
837  default:
839  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
840  ret = AVERROR_PATCHWELCOME;
841  goto err;
842  }
843 
844  desc = av_pix_fmt_desc_get(sps->pix_fmt);
845  if (!desc) {
846  ret = AVERROR(EINVAL);
847  goto err;
848  }
849 
850  sps->hshift[0] = sps->vshift[0] = 0;
851  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
852  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
853 
854  sps->pixel_shift = sps->bit_depth > 8;
855 
856  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
857  if (sps->log2_max_poc_lsb > 16) {
858  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
859  sps->log2_max_poc_lsb - 4);
860  ret = AVERROR_INVALIDDATA;
861  goto err;
862  }
863 
864  sublayer_ordering_info = get_bits1(gb);
865  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
866  for (i = start; i < sps->max_sub_layers; i++) {
871  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
873  ret = AVERROR_INVALIDDATA;
874  goto err;
875  }
877  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
879  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
881  ret = AVERROR_INVALIDDATA;
882  goto err;
883  }
885  }
886  }
887 
888  if (!sublayer_ordering_info) {
889  for (i = 0; i < start; i++) {
893  }
894  }
895 
896  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
898  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
899  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
900  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
901  sps->log2_min_tb_size;
902 
903  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
904  av_log(s->avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
905  ret = AVERROR_INVALIDDATA;
906  goto err;
907  }
908 
909  if (sps->log2_diff_max_min_coding_block_size > 30) {
910  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);
911  ret = AVERROR_INVALIDDATA;
912  goto err;
913  }
914 
915  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
916  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
917  ret = AVERROR_INVALIDDATA;
918  goto err;
919  }
920 
921  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
922  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);
923  ret = AVERROR_INVALIDDATA;
924  goto err;
925  }
926 
929 
931  if (sps->scaling_list_enable_flag) {
933 
934  if (get_bits1(gb)) {
935  ret = scaling_list_data(s, &sps->scaling_list, sps);
936  if (ret < 0)
937  goto err;
938  }
939  }
940 
941  sps->amp_enabled_flag = get_bits1(gb);
942  sps->sao_enabled = get_bits1(gb);
943 
944  sps->pcm_enabled_flag = get_bits1(gb);
945  if (sps->pcm_enabled_flag) {
946  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
947  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
950  get_ue_golomb_long(gb);
951  if (sps->pcm.bit_depth > sps->bit_depth) {
953  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
954  sps->pcm.bit_depth, sps->bit_depth);
955  ret = AVERROR_INVALIDDATA;
956  goto err;
957  }
958 
960  }
961 
962  sps->nb_st_rps = get_ue_golomb_long(gb);
963  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
964  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
965  sps->nb_st_rps);
966  ret = AVERROR_INVALIDDATA;
967  goto err;
968  }
969  for (i = 0; i < sps->nb_st_rps; i++) {
970  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
971  sps, 0)) < 0)
972  goto err;
973  }
974 
978  if (sps->num_long_term_ref_pics_sps > 31U) {
979  av_log(s->avctx, AV_LOG_ERROR, "num_long_term_ref_pics_sps %d is out of range.\n",
981  goto err;
982  }
983  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
986  }
987  }
988 
991  sps->vui.sar = (AVRational){0, 1};
992  vui_present = get_bits1(gb);
993  if (vui_present)
994  decode_vui(s, sps);
995 
996  if (get_bits1(gb)) { // sps_extension_flag
997  int sps_extension_flag[1];
998  for (i = 0; i < 1; i++)
999  sps_extension_flag[i] = get_bits1(gb);
1000  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1001  if (sps_extension_flag[0]) {
1002  int extended_precision_processing_flag;
1003  int high_precision_offsets_enabled_flag;
1004  int cabac_bypass_alignment_enabled_flag;
1005 
1009 
1011 
1012  extended_precision_processing_flag = get_bits1(gb);
1013  if (extended_precision_processing_flag)
1015  "extended_precision_processing_flag not yet implemented\n");
1016 
1018  high_precision_offsets_enabled_flag = get_bits1(gb);
1019  if (high_precision_offsets_enabled_flag)
1021  "high_precision_offsets_enabled_flag not yet implemented\n");
1022 
1024 
1025  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1026  if (cabac_bypass_alignment_enabled_flag)
1028  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1029  }
1030  }
1031  if (s->apply_defdispwin) {
1036  }
1037  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1038  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
1039  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1040  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1041  "chroma samples to preserve alignment.\n",
1042  sps->output_window.left_offset);
1043  }
1044  sps->output_width = sps->width -
1046  sps->output_height = sps->height -
1048  if (sps->width <= sps->output_window.left_offset + (int64_t)sps->output_window.right_offset ||
1049  sps->height <= sps->output_window.top_offset + (int64_t)sps->output_window.bottom_offset) {
1050  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1051  sps->output_width, sps->output_height);
1052  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1053  ret = AVERROR_INVALIDDATA;
1054  goto err;
1055  }
1057  "Displaying the whole video surface.\n");
1058  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1059  memset(&sps->output_window, 0, sizeof(sps->output_window));
1060  sps->output_width = sps->width;
1061  sps->output_height = sps->height;
1062  }
1063 
1064  // Inferred parameters
1065  sps->log2_ctb_size = sps->log2_min_cb_size +
1067  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1068 
1069  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1070  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1071  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1072 
1073  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1074  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1075  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1076  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1077  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1078  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1079  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1080 
1081  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1082 
1083  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
1084  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
1085  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1086  goto err;
1087  }
1088 
1089  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1090  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1091  goto err;
1092  }
1093  if (sps->log2_ctb_size < 4) {
1094  av_log(s->avctx,
1095  AV_LOG_ERROR,
1096  "log2_ctb_size %d differs from the bounds of any known profile\n",
1097  sps->log2_ctb_size);
1098  avpriv_request_sample(s->avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1099  goto err;
1100  }
1102  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1104  goto err;
1105  }
1107  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1109  goto err;
1110  }
1111  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1113  "max transform block size out of range: %d\n",
1114  sps->log2_max_trafo_size);
1115  goto err;
1116  }
1117 
1118  if (get_bits_left(gb) < 0) {
1120  "Overread SPS by %d bits\n", -get_bits_left(gb));
1121  goto err;
1122  }
1123 
1124  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
1126  "Parsed SPS: id %d; coded wxh: %dx%d; "
1127  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1128  sps_id, sps->width, sps->height,
1129  sps->output_width, sps->output_height,
1131  }
1132 
1133  /* check if this is a repeat of an already parsed SPS, then keep the
1134  * original one.
1135  * otherwise drop all PPSes that depend on it */
1136  if (s->sps_list[sps_id] &&
1137  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1138  av_buffer_unref(&sps_buf);
1139  } else {
1140  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
1141  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
1142  av_buffer_unref(&s->pps_list[i]);
1143  }
1144  if (s->sps_list[sps_id] && s->sps == (HEVCSPS*)s->sps_list[sps_id]->data) {
1146  s->current_sps = av_buffer_ref(s->sps_list[sps_id]);
1147  if (!s->current_sps)
1148  s->sps = NULL;
1149  }
1150  av_buffer_unref(&s->sps_list[sps_id]);
1151  s->sps_list[sps_id] = sps_buf;
1152  }
1153 
1154  return 0;
1155 
1156 err:
1157  av_buffer_unref(&sps_buf);
1158  return ret;
1159 }
1160 
1161 static void hevc_pps_free(void *opaque, uint8_t *data)
1162 {
1163  HEVCPPS *pps = (HEVCPPS*)data;
1164 
1165  av_freep(&pps->column_width);
1166  av_freep(&pps->row_height);
1167  av_freep(&pps->col_bd);
1168  av_freep(&pps->row_bd);
1169  av_freep(&pps->col_idxX);
1170  av_freep(&pps->ctb_addr_rs_to_ts);
1171  av_freep(&pps->ctb_addr_ts_to_rs);
1172  av_freep(&pps->tile_pos_rs);
1173  av_freep(&pps->tile_id);
1175 
1176  av_freep(&pps);
1177 }
1178 
1180  GetBitContext *gb = &s->HEVClc->gb;
1181  int i;
1182 
1183  if (pps->transform_skip_enabled_flag) {
1185  }
1193  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1194  return AVERROR_INVALIDDATA;
1195  }
1196  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1197  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1198  if (pps->cb_qp_offset_list[i]) {
1200  "cb_qp_offset_list not tested yet.\n");
1201  }
1202  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1203  if (pps->cr_qp_offset_list[i]) {
1205  "cb_qp_offset_list not tested yet.\n");
1206  }
1207  }
1208  }
1211 
1212  return(0);
1213 }
1214 
1216 {
1217  GetBitContext *gb = &s->HEVClc->gb;
1218  HEVCSPS *sps = NULL;
1219  int pic_area_in_ctbs;
1220  int log2_diff_ctb_min_tb_size;
1221  int i, j, x, y, ctb_addr_rs, tile_id;
1222  int ret = 0;
1223  unsigned int pps_id = 0;
1224 
1225  AVBufferRef *pps_buf;
1226  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1227 
1228  if (!pps)
1229  return AVERROR(ENOMEM);
1230 
1231  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1232  hevc_pps_free, NULL, 0);
1233  if (!pps_buf) {
1234  av_freep(&pps);
1235  return AVERROR(ENOMEM);
1236  }
1237 
1238  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1239 
1240  // Default values
1242  pps->num_tile_columns = 1;
1243  pps->num_tile_rows = 1;
1244  pps->uniform_spacing_flag = 1;
1245  pps->disable_dbf = 0;
1246  pps->beta_offset = 0;
1247  pps->tc_offset = 0;
1249 
1250  // Coded parameters
1251  pps_id = get_ue_golomb_long(gb);
1252  if (pps_id >= MAX_PPS_COUNT) {
1253  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1254  ret = AVERROR_INVALIDDATA;
1255  goto err;
1256  }
1257  pps->sps_id = get_ue_golomb_long(gb);
1258  if (pps->sps_id >= MAX_SPS_COUNT) {
1259  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1260  ret = AVERROR_INVALIDDATA;
1261  goto err;
1262  }
1263  if (!s->sps_list[pps->sps_id]) {
1264  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1265  ret = AVERROR_INVALIDDATA;
1266  goto err;
1267  }
1268  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1269 
1272  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1273 
1274  pps->sign_data_hiding_flag = get_bits1(gb);
1275 
1277 
1280 
1282 
1285 
1287  pps->diff_cu_qp_delta_depth = 0;
1288  if (pps->cu_qp_delta_enabled_flag)
1290 
1291  if (pps->diff_cu_qp_delta_depth < 0 ||
1293  av_log(s->avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1294  pps->diff_cu_qp_delta_depth);
1295  ret = AVERROR_INVALIDDATA;
1296  goto err;
1297  }
1298 
1299  pps->cb_qp_offset = get_se_golomb(gb);
1300  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1301  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1302  pps->cb_qp_offset);
1303  ret = AVERROR_INVALIDDATA;
1304  goto err;
1305  }
1306  pps->cr_qp_offset = get_se_golomb(gb);
1307  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1308  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1309  pps->cr_qp_offset);
1310  ret = AVERROR_INVALIDDATA;
1311  goto err;
1312  }
1314 
1315  pps->weighted_pred_flag = get_bits1(gb);
1316  pps->weighted_bipred_flag = get_bits1(gb);
1317 
1319  pps->tiles_enabled_flag = get_bits1(gb);
1321 
1322  if (pps->tiles_enabled_flag) {
1323  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1324  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1325  if (pps->num_tile_columns <= 0 ||
1326  pps->num_tile_columns >= sps->width) {
1327  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1328  pps->num_tile_columns - 1);
1329  ret = AVERROR_INVALIDDATA;
1330  goto err;
1331  }
1332  if (pps->num_tile_rows <= 0 ||
1333  pps->num_tile_rows >= sps->height) {
1334  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1335  pps->num_tile_rows - 1);
1336  ret = AVERROR_INVALIDDATA;
1337  goto err;
1338  }
1339 
1340  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1341  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1342  if (!pps->column_width || !pps->row_height) {
1343  ret = AVERROR(ENOMEM);
1344  goto err;
1345  }
1346 
1347  pps->uniform_spacing_flag = get_bits1(gb);
1348  if (!pps->uniform_spacing_flag) {
1349  uint64_t sum = 0;
1350  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1351  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1352  sum += pps->column_width[i];
1353  }
1354  if (sum >= sps->ctb_width) {
1355  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1356  ret = AVERROR_INVALIDDATA;
1357  goto err;
1358  }
1359  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1360 
1361  sum = 0;
1362  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1363  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1364  sum += pps->row_height[i];
1365  }
1366  if (sum >= sps->ctb_height) {
1367  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1368  ret = AVERROR_INVALIDDATA;
1369  goto err;
1370  }
1371  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1372  }
1374  }
1375 
1377 
1381  pps->disable_dbf = get_bits1(gb);
1382  if (!pps->disable_dbf) {
1383  pps->beta_offset = get_se_golomb(gb) * 2;
1384  pps->tc_offset = get_se_golomb(gb) * 2;
1385  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1386  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1387  pps->beta_offset/2);
1388  ret = AVERROR_INVALIDDATA;
1389  goto err;
1390  }
1391  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1392  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1393  pps->tc_offset/2);
1394  ret = AVERROR_INVALIDDATA;
1395  goto err;
1396  }
1397  }
1398  }
1399 
1401  if (pps->scaling_list_data_present_flag) {
1403  ret = scaling_list_data(s, &pps->scaling_list, sps);
1404  if (ret < 0)
1405  goto err;
1406  }
1409  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1410  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1411  pps->log2_parallel_merge_level - 2);
1412  ret = AVERROR_INVALIDDATA;
1413  goto err;
1414  }
1415 
1417 
1418  if (get_bits1(gb)) { // pps_extension_present_flag
1419  int pps_range_extensions_flag = get_bits1(gb);
1420  /* int pps_extension_7bits = */ get_bits(gb, 7);
1421  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1422  if ((ret = pps_range_extensions(s, pps, sps)) < 0)
1423  goto err;
1424  }
1425  }
1426 
1427  // Inferred parameters
1428  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1429  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1430  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1431  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1432  ret = AVERROR(ENOMEM);
1433  goto err;
1434  }
1435 
1436  if (pps->uniform_spacing_flag) {
1437  if (!pps->column_width) {
1438  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1439  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1440  }
1441  if (!pps->column_width || !pps->row_height) {
1442  ret = AVERROR(ENOMEM);
1443  goto err;
1444  }
1445 
1446  for (i = 0; i < pps->num_tile_columns; i++) {
1447  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1448  (i * sps->ctb_width) / pps->num_tile_columns;
1449  }
1450 
1451  for (i = 0; i < pps->num_tile_rows; i++) {
1452  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1453  (i * sps->ctb_height) / pps->num_tile_rows;
1454  }
1455  }
1456 
1457  pps->col_bd[0] = 0;
1458  for (i = 0; i < pps->num_tile_columns; i++)
1459  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1460 
1461  pps->row_bd[0] = 0;
1462  for (i = 0; i < pps->num_tile_rows; i++)
1463  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1464 
1465  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1466  if (i > pps->col_bd[j])
1467  j++;
1468  pps->col_idxX[i] = j;
1469  }
1470 
1471  /**
1472  * 6.5
1473  */
1474  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1475 
1476  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1477  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1478  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1479  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1480  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1481  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1482  ret = AVERROR(ENOMEM);
1483  goto err;
1484  }
1485 
1486  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1487  int tb_x = ctb_addr_rs % sps->ctb_width;
1488  int tb_y = ctb_addr_rs / sps->ctb_width;
1489  int tile_x = 0;
1490  int tile_y = 0;
1491  int val = 0;
1492 
1493  for (i = 0; i < pps->num_tile_columns; i++) {
1494  if (tb_x < pps->col_bd[i + 1]) {
1495  tile_x = i;
1496  break;
1497  }
1498  }
1499 
1500  for (i = 0; i < pps->num_tile_rows; i++) {
1501  if (tb_y < pps->row_bd[i + 1]) {
1502  tile_y = i;
1503  break;
1504  }
1505  }
1506 
1507  for (i = 0; i < tile_x; i++)
1508  val += pps->row_height[tile_y] * pps->column_width[i];
1509  for (i = 0; i < tile_y; i++)
1510  val += sps->ctb_width * pps->row_height[i];
1511 
1512  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1513  tb_x - pps->col_bd[tile_x];
1514 
1515  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1516  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1517  }
1518 
1519  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1520  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1521  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1522  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1523  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1524 
1525  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1526  if (!pps->tile_pos_rs) {
1527  ret = AVERROR(ENOMEM);
1528  goto err;
1529  }
1530 
1531  for (j = 0; j < pps->num_tile_rows; j++)
1532  for (i = 0; i < pps->num_tile_columns; i++)
1533  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1534 
1535  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1536  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1537  for (y = 0; y < sps->tb_mask+2; y++) {
1538  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1539  pps->min_tb_addr_zs_tab[y] = -1;
1540  }
1541  for (y = 0; y < sps->tb_mask+1; y++) {
1542  for (x = 0; x < sps->tb_mask+1; x++) {
1543  int tb_x = x >> log2_diff_ctb_min_tb_size;
1544  int tb_y = y >> log2_diff_ctb_min_tb_size;
1545  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1546  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1547  (log2_diff_ctb_min_tb_size * 2);
1548  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1549  int m = 1 << i;
1550  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1551  }
1552  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1553  }
1554  }
1555 
1556  if (get_bits_left(gb) < 0) {
1558  "Overread PPS by %d bits\n", -get_bits_left(gb));
1559  goto err;
1560  }
1561 
1562  av_buffer_unref(&s->pps_list[pps_id]);
1563  s->pps_list[pps_id] = pps_buf;
1564 
1565  return 0;
1566 
1567 err:
1568  av_buffer_unref(&pps_buf);
1569  return ret;
1570 }
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:708
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:907
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:1179
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:1215
#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:636
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:66
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:606
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:1161
#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:476
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