FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hevc_ps.c
Go to the documentation of this file.
1 /*
2  * HEVC Parameter Set decoding
3  *
4  * Copyright (C) 2012 - 2103 Guillaume Martres
5  * Copyright (C) 2012 - 2103 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2013 Vittorio Giovara
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/imgutils.h"
27 #include "golomb.h"
28 #include "hevc.h"
29 
31  16, 16, 16, 16, 17, 18, 21, 24,
32  16, 16, 16, 16, 17, 19, 22, 25,
33  16, 16, 17, 18, 20, 22, 25, 29,
34  16, 16, 18, 21, 24, 27, 31, 36,
35  17, 17, 20, 24, 30, 35, 41, 47,
36  18, 19, 22, 27, 35, 44, 54, 65,
37  21, 22, 25, 31, 41, 54, 70, 88,
38  24, 25, 29, 36, 47, 65, 88, 115
39 };
40 
42  16, 16, 16, 16, 17, 18, 20, 24,
43  16, 16, 16, 17, 18, 20, 24, 25,
44  16, 16, 17, 18, 20, 24, 25, 28,
45  16, 17, 18, 20, 24, 25, 28, 33,
46  17, 18, 20, 24, 25, 28, 33, 41,
47  18, 20, 24, 25, 28, 33, 41, 54,
48  20, 24, 25, 28, 33, 41, 54, 71,
49  24, 25, 28, 33, 41, 54, 71, 91
50 };
51 
52 static const AVRational vui_sar[] = {
53  { 0, 1 },
54  { 1, 1 },
55  { 12, 11 },
56  { 10, 11 },
57  { 16, 11 },
58  { 40, 33 },
59  { 24, 11 },
60  { 20, 11 },
61  { 32, 11 },
62  { 80, 33 },
63  { 18, 11 },
64  { 15, 11 },
65  { 64, 33 },
66  { 160, 99 },
67  { 4, 3 },
68  { 3, 2 },
69  { 2, 1 },
70 };
71 
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 }