FFmpeg
 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 - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
428  av_log(s->avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
429  goto err;
430  }
431 
432  for (i = 1; i < vps->vps_num_layer_sets; i++)
433  for (j = 0; j <= vps->vps_max_layer_id; j++)
434  skip_bits(gb, 1); // layer_id_included_flag[i][j]
435 
437  if (vps->vps_timing_info_present_flag) {
438  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
439  vps->vps_time_scale = get_bits_long(gb, 32);
444  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
445  int common_inf_present = 1;
446 
447  get_ue_golomb_long(gb); // hrd_layer_set_idx
448  if (i)
449  common_inf_present = get_bits1(gb);
450  decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
451  }
452  }
453  get_bits1(gb); /* vps_extension_flag */
454 
455  if (get_bits_left(gb) < 0) {
457  "Overread VPS by %d bits\n", -get_bits_left(gb));
458  goto err;
459  }
460 
461  av_buffer_unref(&s->vps_list[vps_id]);
462  s->vps_list[vps_id] = vps_buf;
463  return 0;
464 
465 err:
466  av_buffer_unref(&vps_buf);
467  return AVERROR_INVALIDDATA;
468 }
469 
470 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
471 {
472  VUI *vui = &sps->vui;
473  GetBitContext *gb = &s->HEVClc->gb;
474  GetBitContext backup;
475  int sar_present, alt = 0;
476 
477  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
478 
479  sar_present = get_bits1(gb);
480  if (sar_present) {
481  uint8_t sar_idx = get_bits(gb, 8);
482  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
483  vui->sar = vui_sar[sar_idx];
484  else if (sar_idx == 255) {
485  vui->sar.num = get_bits(gb, 16);
486  vui->sar.den = get_bits(gb, 16);
487  } else
489  "Unknown SAR index: %u.\n", sar_idx);
490  }
491 
495 
498  vui->video_format = get_bits(gb, 3);
499  vui->video_full_range_flag = get_bits1(gb);
504  vui->colour_primaries = get_bits(gb, 8);
505  vui->transfer_characteristic = get_bits(gb, 8);
506  vui->matrix_coeffs = get_bits(gb, 8);
507 
508  // Set invalid values to "unspecified"
509  if (vui->colour_primaries >= AVCOL_PRI_NB)
513  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
515  }
516  }
517 
519  if (vui->chroma_loc_info_present_flag) {
522  }
523 
525  vui->field_seq_flag = get_bits1(gb);
527 
529  // Backup context in case an alternate header is detected
530  memcpy(&backup, gb, sizeof(backup));
531 
532  if (vui->default_display_window_flag) {
533  //TODO: * 2 is only valid for 420
538 
539  if (s->apply_defdispwin &&
542  "discarding vui default display window, "
543  "original values are l:%u r:%u t:%u b:%u\n",
548 
551  vui->def_disp_win.top_offset =
552  vui->def_disp_win.bottom_offset = 0;
553  }
554  }
555 
557 
558  if (vui->vui_timing_info_present_flag) {
559  if( get_bits_left(gb) < 66) {
560  // The alternate syntax seem to have timing info located
561  // at where def_disp_win is normally located
563  "Strange VUI timing information, retrying...\n");
565  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
566  memcpy(gb, &backup, sizeof(backup));
567  alt = 1;
568  }
569  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
570  vui->vui_time_scale = get_bits_long(gb, 32);
571  if (alt) {
572  av_log(s->avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
574  }
580  decode_hrd(s, 1, sps->max_sub_layers);
581  }
582 
584  if (vui->bitstream_restriction_flag) {
593  }
594 }
595 
597 {
598  int matrixId;
599 
600  for (matrixId = 0; matrixId < 6; matrixId++) {
601  // 4x4 default is 16
602  memset(sl->sl[0][matrixId], 16, 16);
603  sl->sl_dc[0][matrixId] = 16; // default for 16x16
604  sl->sl_dc[1][matrixId] = 16; // default for 32x32
605  }
606  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
607  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
608  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
609  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
610  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
611  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
612  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
613  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
614  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
615  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
616  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
617  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
618  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
619  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
620  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
621  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
622  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
623  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
624 }
625 
627 {
628  GetBitContext *gb = &s->HEVClc->gb;
629  uint8_t scaling_list_pred_mode_flag;
630  int32_t scaling_list_dc_coef[2][6];
631  int size_id, matrix_id, pos;
632  int i;
633 
634  for (size_id = 0; size_id < 4; size_id++)
635  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
636  scaling_list_pred_mode_flag = get_bits1(gb);
637  if (!scaling_list_pred_mode_flag) {
638  unsigned int delta = get_ue_golomb_long(gb);
639  /* Only need to handle non-zero delta. Zero means default,
640  * which should already be in the arrays. */
641  if (delta) {
642  // Copy from previous array.
643  if (matrix_id < delta) {
645  "Invalid delta in scaling list data: %d.\n", delta);
646  return AVERROR_INVALIDDATA;
647  }
648 
649  memcpy(sl->sl[size_id][matrix_id],
650  sl->sl[size_id][matrix_id - delta],
651  size_id > 0 ? 64 : 16);
652  if (size_id > 1)
653  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
654  }
655  } else {
656  int next_coef, coef_num;
657  int32_t scaling_list_delta_coef;
658 
659  next_coef = 8;
660  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
661  if (size_id > 1) {
662  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
663  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
664  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
665  }
666  for (i = 0; i < coef_num; i++) {
667  if (size_id == 0)
668  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
670  else
671  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
673 
674  scaling_list_delta_coef = get_se_golomb(gb);
675  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
676  sl->sl[size_id][matrix_id][pos] = next_coef;
677  }
678  }
679  }
680 
681  if (sps->chroma_format_idc == 3) {
682  for (i = 0; i < 64; i++) {
683  sl->sl[3][1][i] = sl->sl[2][1][i];
684  sl->sl[3][2][i] = sl->sl[2][2][i];
685  sl->sl[3][4][i] = sl->sl[2][4][i];
686  sl->sl[3][5][i] = sl->sl[2][5][i];
687  }
688  sl->sl_dc[1][1] = sl->sl_dc[0][1];
689  sl->sl_dc[1][2] = sl->sl_dc[0][2];
690  sl->sl_dc[1][4] = sl->sl_dc[0][4];
691  sl->sl_dc[1][5] = sl->sl_dc[0][5];
692  }
693 
694 
695  return 0;
696 }
697 
699 {
700  const AVPixFmtDescriptor *desc;
701  GetBitContext *gb = &s->HEVClc->gb;
702  int ret = 0;
703  unsigned int sps_id = 0;
704  int log2_diff_max_min_transform_block_size;
705  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
706  int i;
707 
708  HEVCSPS *sps;
709  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
710 
711  if (!sps_buf)
712  return AVERROR(ENOMEM);
713  sps = (HEVCSPS*)sps_buf->data;
714 
715  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
716 
717  // Coded parameters
718 
719  sps->vps_id = get_bits(gb, 4);
720  if (sps->vps_id >= MAX_VPS_COUNT) {
721  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
722  ret = AVERROR_INVALIDDATA;
723  goto err;
724  }
725 
726  if (!s->vps_list[sps->vps_id]) {
727  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
728  sps->vps_id);
729  ret = AVERROR_INVALIDDATA;
730  goto err;
731  }
732 
733  sps->max_sub_layers = get_bits(gb, 3) + 1;
734  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
735  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
736  sps->max_sub_layers);
737  ret = AVERROR_INVALIDDATA;
738  goto err;
739  }
740 
741  skip_bits1(gb); // temporal_id_nesting_flag
742 
743  if (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)
744  goto err;
745 
746  sps_id = get_ue_golomb_long(gb);
747  if (sps_id >= MAX_SPS_COUNT) {
748  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
749  ret = AVERROR_INVALIDDATA;
750  goto err;
751  }
752 
754  if (!(sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2 || sps->chroma_format_idc == 3)) {
755  avpriv_report_missing_feature(s->avctx, "chroma_format_idc != {1, 2, 3}\n");
756  ret = AVERROR_PATCHWELCOME;
757  goto err;
758  }
759 
760  if (sps->chroma_format_idc == 3)
762 
764  sps->chroma_format_idc = 0;
765 
766  sps->width = get_ue_golomb_long(gb);
767  sps->height = get_ue_golomb_long(gb);
768  if ((ret = av_image_check_size(sps->width,
769  sps->height, 0, s->avctx)) < 0)
770  goto err;
771 
772  if (get_bits1(gb)) { // pic_conformance_flag
773  //TODO: * 2 is only valid for 420
778 
781  "discarding sps conformance window, "
782  "original values are l:%u r:%u t:%u b:%u\n",
787 
790  sps->pic_conf_win.top_offset =
791  sps->pic_conf_win.bottom_offset = 0;
792  }
793  sps->output_window = sps->pic_conf_win;
794  }
795 
796  sps->bit_depth = get_ue_golomb_long(gb) + 8;
797  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
798  if (bit_depth_chroma != sps->bit_depth) {
800  "Luma bit depth (%d) is different from chroma bit depth (%d), "
801  "this is unsupported.\n",
802  sps->bit_depth, bit_depth_chroma);
803  ret = AVERROR_INVALIDDATA;
804  goto err;
805  }
806 
807  switch (sps->bit_depth) {
808  case 8:
809  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
810  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
811  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
812  break;
813  case 9:
814  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
815  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
816  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
817  break;
818  case 10:
819  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
820  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
821  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
822  break;
823  case 12:
824  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
825  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
826  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
827  break;
828  default:
830  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
831  ret = AVERROR_PATCHWELCOME;
832  goto err;
833  }
834 
835  desc = av_pix_fmt_desc_get(sps->pix_fmt);
836  if (!desc) {
837  ret = AVERROR(EINVAL);
838  goto err;
839  }
840 
841  sps->hshift[0] = sps->vshift[0] = 0;
842  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
843  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
844 
845  sps->pixel_shift = sps->bit_depth > 8;
846 
847  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
848  if (sps->log2_max_poc_lsb > 16) {
849  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
850  sps->log2_max_poc_lsb - 4);
851  ret = AVERROR_INVALIDDATA;
852  goto err;
853  }
854 
855  sublayer_ordering_info = get_bits1(gb);
856  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
857  for (i = start; i < sps->max_sub_layers; i++) {
862  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
864  ret = AVERROR_INVALIDDATA;
865  goto err;
866  }
868  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
870  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
872  ret = AVERROR_INVALIDDATA;
873  goto err;
874  }
876  }
877  }
878 
879  if (!sublayer_ordering_info) {
880  for (i = 0; i < start; i++) {
884  }
885  }
886 
887  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
889  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
890  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
891  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
892  sps->log2_min_tb_size;
893 
894  if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {
895  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
896  ret = AVERROR_INVALIDDATA;
897  goto err;
898  }
901 
903  if (sps->scaling_list_enable_flag) {
905 
906  if (get_bits1(gb)) {
907  ret = scaling_list_data(s, &sps->scaling_list, sps);
908  if (ret < 0)
909  goto err;
910  }
911  }
912 
913  sps->amp_enabled_flag = get_bits1(gb);
914  sps->sao_enabled = get_bits1(gb);
915 
916  sps->pcm_enabled_flag = get_bits1(gb);
917  if (sps->pcm_enabled_flag) {
918  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
919  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
922  get_ue_golomb_long(gb);
923  if (sps->pcm.bit_depth > sps->bit_depth) {
925  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
926  sps->pcm.bit_depth, sps->bit_depth);
927  ret = AVERROR_INVALIDDATA;
928  goto err;
929  }
930 
932  }
933 
934  sps->nb_st_rps = get_ue_golomb_long(gb);
935  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
936  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
937  sps->nb_st_rps);
938  ret = AVERROR_INVALIDDATA;
939  goto err;
940  }
941  for (i = 0; i < sps->nb_st_rps; i++) {
942  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
943  sps, 0)) < 0)
944  goto err;
945  }
946 
950  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
953  }
954  }
955 
958  sps->vui.sar = (AVRational){0, 1};
959  vui_present = get_bits1(gb);
960  if (vui_present)
961  decode_vui(s, sps);
962 
963  if (get_bits1(gb)) { // sps_extension_flag
964  int sps_extension_flag[1];
965  for (i = 0; i < 1; i++)
966  sps_extension_flag[i] = get_bits1(gb);
967  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
968  if (sps_extension_flag[0]) {
969  int extended_precision_processing_flag;
970  int high_precision_offsets_enabled_flag;
971  int cabac_bypass_alignment_enabled_flag;
972 
976 
978 
979  extended_precision_processing_flag = get_bits1(gb);
980  if (extended_precision_processing_flag)
982  "extended_precision_processing_flag not yet implemented\n");
983 
985  high_precision_offsets_enabled_flag = get_bits1(gb);
986  if (high_precision_offsets_enabled_flag)
988  "high_precision_offsets_enabled_flag not yet implemented\n");
989 
991 
992  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
993  if (cabac_bypass_alignment_enabled_flag)
995  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
996  }
997  }
998  if (s->apply_defdispwin) {
1003  }
1004  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1005  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
1006  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1007  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1008  "chroma samples to preserve alignment.\n",
1009  sps->output_window.left_offset);
1010  }
1011  sps->output_width = sps->width -
1013  sps->output_height = sps->height -
1015  if (sps->output_width <= 0 || sps->output_height <= 0) {
1016  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1017  sps->output_width, sps->output_height);
1018  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1019  ret = AVERROR_INVALIDDATA;
1020  goto err;
1021  }
1023  "Displaying the whole video surface.\n");
1024  sps->pic_conf_win.left_offset =
1025  sps->pic_conf_win.right_offset =
1026  sps->pic_conf_win.top_offset =
1027  sps->pic_conf_win.bottom_offset = 0;
1028  sps->output_width = sps->width;
1029  sps->output_height = sps->height;
1030  }
1031 
1032  // Inferred parameters
1033  sps->log2_ctb_size = sps->log2_min_cb_size +
1035  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1036 
1037  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1038  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1039  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1040 
1041  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1042  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1043  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1044  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1045  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1046  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1047  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1048 
1049  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1050 
1051  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
1052  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
1053  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1054  goto err;
1055  }
1056 
1057  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1058  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1059  goto err;
1060  }
1062  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1064  goto err;
1065  }
1067  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1069  goto err;
1070  }
1071  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1073  "max transform block size out of range: %d\n",
1074  sps->log2_max_trafo_size);
1075  goto err;
1076  }
1077 
1078  if (get_bits_left(gb) < 0) {
1080  "Overread SPS by %d bits\n", -get_bits_left(gb));
1081  goto err;
1082  }
1083 
1084  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
1086  "Parsed SPS: id %d; coded wxh: %dx%d; "
1087  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1088  sps_id, sps->width, sps->height,
1089  sps->output_width, sps->output_height,
1091  }
1092 
1093  /* check if this is a repeat of an already parsed SPS, then keep the
1094  * original one.
1095  * otherwise drop all PPSes that depend on it */
1096  if (s->sps_list[sps_id] &&
1097  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1098  av_buffer_unref(&sps_buf);
1099  } else {
1100  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
1101  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
1102  av_buffer_unref(&s->pps_list[i]);
1103  }
1104  if (s->sps_list[sps_id] && s->sps == (HEVCSPS*)s->sps_list[sps_id]->data) {
1106  s->current_sps = av_buffer_ref(s->sps_list[sps_id]);
1107  if (!s->current_sps)
1108  s->sps = NULL;
1109  }
1110  av_buffer_unref(&s->sps_list[sps_id]);
1111  s->sps_list[sps_id] = sps_buf;
1112  }
1113 
1114  return 0;
1115 
1116 err:
1117  av_buffer_unref(&sps_buf);
1118  return ret;
1119 }
1120 
1121 static void hevc_pps_free(void *opaque, uint8_t *data)
1122 {
1123  HEVCPPS *pps = (HEVCPPS*)data;
1124 
1125  av_freep(&pps->column_width);
1126  av_freep(&pps->row_height);
1127  av_freep(&pps->col_bd);
1128  av_freep(&pps->row_bd);
1129  av_freep(&pps->col_idxX);
1130  av_freep(&pps->ctb_addr_rs_to_ts);
1131  av_freep(&pps->ctb_addr_ts_to_rs);
1132  av_freep(&pps->tile_pos_rs);
1133  av_freep(&pps->tile_id);
1135 
1136  av_freep(&pps);
1137 }
1138 
1140  GetBitContext *gb = &s->HEVClc->gb;
1141  int i;
1142 
1143  if (pps->transform_skip_enabled_flag) {
1145  }
1153  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1154  return AVERROR_INVALIDDATA;
1155  }
1156  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1157  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1158  if (pps->cb_qp_offset_list[i]) {
1160  "cb_qp_offset_list not tested yet.\n");
1161  }
1162  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1163  if (pps->cr_qp_offset_list[i]) {
1165  "cb_qp_offset_list not tested yet.\n");
1166  }
1167  }
1168  }
1171 
1172  return(0);
1173 }
1174 
1176 {
1177  GetBitContext *gb = &s->HEVClc->gb;
1178  HEVCSPS *sps = NULL;
1179  int pic_area_in_ctbs;
1180  int log2_diff_ctb_min_tb_size;
1181  int i, j, x, y, ctb_addr_rs, tile_id;
1182  int ret = 0;
1183  unsigned int pps_id = 0;
1184 
1185  AVBufferRef *pps_buf;
1186  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1187 
1188  if (!pps)
1189  return AVERROR(ENOMEM);
1190 
1191  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1192  hevc_pps_free, NULL, 0);
1193  if (!pps_buf) {
1194  av_freep(&pps);
1195  return AVERROR(ENOMEM);
1196  }
1197 
1198  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1199 
1200  // Default values
1202  pps->num_tile_columns = 1;
1203  pps->num_tile_rows = 1;
1204  pps->uniform_spacing_flag = 1;
1205  pps->disable_dbf = 0;
1206  pps->beta_offset = 0;
1207  pps->tc_offset = 0;
1209 
1210  // Coded parameters
1211  pps_id = get_ue_golomb_long(gb);
1212  if (pps_id >= MAX_PPS_COUNT) {
1213  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1214  ret = AVERROR_INVALIDDATA;
1215  goto err;
1216  }
1217  pps->sps_id = get_ue_golomb_long(gb);
1218  if (pps->sps_id >= MAX_SPS_COUNT) {
1219  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1220  ret = AVERROR_INVALIDDATA;
1221  goto err;
1222  }
1223  if (!s->sps_list[pps->sps_id]) {
1224  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1225  ret = AVERROR_INVALIDDATA;
1226  goto err;
1227  }
1228  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1229 
1232  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1233 
1234  pps->sign_data_hiding_flag = get_bits1(gb);
1235 
1237 
1240 
1242 
1245 
1247  pps->diff_cu_qp_delta_depth = 0;
1248  if (pps->cu_qp_delta_enabled_flag)
1250 
1251  pps->cb_qp_offset = get_se_golomb(gb);
1252  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1253  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1254  pps->cb_qp_offset);
1255  ret = AVERROR_INVALIDDATA;
1256  goto err;
1257  }
1258  pps->cr_qp_offset = get_se_golomb(gb);
1259  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1260  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1261  pps->cr_qp_offset);
1262  ret = AVERROR_INVALIDDATA;
1263  goto err;
1264  }
1266 
1267  pps->weighted_pred_flag = get_bits1(gb);
1268  pps->weighted_bipred_flag = get_bits1(gb);
1269 
1271  pps->tiles_enabled_flag = get_bits1(gb);
1273 
1274  if (pps->tiles_enabled_flag) {
1275  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1276  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1277  if (pps->num_tile_columns == 0 ||
1278  pps->num_tile_columns >= sps->width) {
1279  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1280  pps->num_tile_columns - 1);
1281  ret = AVERROR_INVALIDDATA;
1282  goto err;
1283  }
1284  if (pps->num_tile_rows == 0 ||
1285  pps->num_tile_rows >= sps->height) {
1286  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1287  pps->num_tile_rows - 1);
1288  ret = AVERROR_INVALIDDATA;
1289  goto err;
1290  }
1291 
1292  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1293  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1294  if (!pps->column_width || !pps->row_height) {
1295  ret = AVERROR(ENOMEM);
1296  goto err;
1297  }
1298 
1299  pps->uniform_spacing_flag = get_bits1(gb);
1300  if (!pps->uniform_spacing_flag) {
1301  uint64_t sum = 0;
1302  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1303  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1304  sum += pps->column_width[i];
1305  }
1306  if (sum >= sps->ctb_width) {
1307  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1308  ret = AVERROR_INVALIDDATA;
1309  goto err;
1310  }
1311  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1312 
1313  sum = 0;
1314  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1315  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1316  sum += pps->row_height[i];
1317  }
1318  if (sum >= sps->ctb_height) {
1319  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1320  ret = AVERROR_INVALIDDATA;
1321  goto err;
1322  }
1323  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1324  }
1326  }
1327 
1329 
1333  pps->disable_dbf = get_bits1(gb);
1334  if (!pps->disable_dbf) {
1335  pps->beta_offset = get_se_golomb(gb) * 2;
1336  pps->tc_offset = get_se_golomb(gb) * 2;
1337  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1338  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1339  pps->beta_offset/2);
1340  ret = AVERROR_INVALIDDATA;
1341  goto err;
1342  }
1343  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1344  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1345  pps->tc_offset/2);
1346  ret = AVERROR_INVALIDDATA;
1347  goto err;
1348  }
1349  }
1350  }
1351 
1353  if (pps->scaling_list_data_present_flag) {
1355  ret = scaling_list_data(s, &pps->scaling_list, sps);
1356  if (ret < 0)
1357  goto err;
1358  }
1361  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1362  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1363  pps->log2_parallel_merge_level - 2);
1364  ret = AVERROR_INVALIDDATA;
1365  goto err;
1366  }
1367 
1369 
1370  if (get_bits1(gb)) { // pps_extension_present_flag
1371  int pps_range_extensions_flag = get_bits1(gb);
1372  /* int pps_extension_7bits = */ get_bits(gb, 7);
1373  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1374  pps_range_extensions(s, pps, sps);
1375  }
1376  }
1377 
1378  // Inferred parameters
1379  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1380  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1381  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1382  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1383  ret = AVERROR(ENOMEM);
1384  goto err;
1385  }
1386 
1387  if (pps->uniform_spacing_flag) {
1388  if (!pps->column_width) {
1389  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1390  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1391  }
1392  if (!pps->column_width || !pps->row_height) {
1393  ret = AVERROR(ENOMEM);
1394  goto err;
1395  }
1396 
1397  for (i = 0; i < pps->num_tile_columns; i++) {
1398  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1399  (i * sps->ctb_width) / pps->num_tile_columns;
1400  }
1401 
1402  for (i = 0; i < pps->num_tile_rows; i++) {
1403  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1404  (i * sps->ctb_height) / pps->num_tile_rows;
1405  }
1406  }
1407 
1408  pps->col_bd[0] = 0;
1409  for (i = 0; i < pps->num_tile_columns; i++)
1410  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1411 
1412  pps->row_bd[0] = 0;
1413  for (i = 0; i < pps->num_tile_rows; i++)
1414  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1415 
1416  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1417  if (i > pps->col_bd[j])
1418  j++;
1419  pps->col_idxX[i] = j;
1420  }
1421 
1422  /**
1423  * 6.5
1424  */
1425  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1426 
1427  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1428  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1429  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1430  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1431  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1432  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1433  ret = AVERROR(ENOMEM);
1434  goto err;
1435  }
1436 
1437  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1438  int tb_x = ctb_addr_rs % sps->ctb_width;
1439  int tb_y = ctb_addr_rs / sps->ctb_width;
1440  int tile_x = 0;
1441  int tile_y = 0;
1442  int val = 0;
1443 
1444  for (i = 0; i < pps->num_tile_columns; i++) {
1445  if (tb_x < pps->col_bd[i + 1]) {
1446  tile_x = i;
1447  break;
1448  }
1449  }
1450 
1451  for (i = 0; i < pps->num_tile_rows; i++) {
1452  if (tb_y < pps->row_bd[i + 1]) {
1453  tile_y = i;
1454  break;
1455  }
1456  }
1457 
1458  for (i = 0; i < tile_x; i++)
1459  val += pps->row_height[tile_y] * pps->column_width[i];
1460  for (i = 0; i < tile_y; i++)
1461  val += sps->ctb_width * pps->row_height[i];
1462 
1463  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1464  tb_x - pps->col_bd[tile_x];
1465 
1466  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1467  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1468  }
1469 
1470  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1471  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1472  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1473  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1474  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1475 
1476  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1477  if (!pps->tile_pos_rs) {
1478  ret = AVERROR(ENOMEM);
1479  goto err;
1480  }
1481 
1482  for (j = 0; j < pps->num_tile_rows; j++)
1483  for (i = 0; i < pps->num_tile_columns; i++)
1484  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1485 
1486  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1487  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1488  for (y = 0; y < sps->tb_mask+2; y++) {
1489  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1490  pps->min_tb_addr_zs_tab[y] = -1;
1491  }
1492  for (y = 0; y < sps->tb_mask+1; y++) {
1493  for (x = 0; x < sps->tb_mask+1; x++) {
1494  int tb_x = x >> log2_diff_ctb_min_tb_size;
1495  int tb_y = y >> log2_diff_ctb_min_tb_size;
1496  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1497  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1498  (log2_diff_ctb_min_tb_size * 2);
1499  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1500  int m = 1 << i;
1501  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1502  }
1503  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1504  }
1505  }
1506 
1507  if (get_bits_left(gb) < 0) {
1509  "Overread PPS by %d bits\n", -get_bits_left(gb));
1510  goto err;
1511  }
1512 
1513  av_buffer_unref(&s->pps_list[pps_id]);
1514  s->pps_list[pps_id] = pps_buf;
1515 
1516  return 0;
1517 
1518 err:
1519  av_buffer_unref(&pps_buf);
1520  return ret;
1521 }