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  if( get_bits_left(gb) >= 66)
531  memcpy(&backup, gb, sizeof(backup));
532 
533  if (vui->default_display_window_flag) {
534  //TODO: * 2 is only valid for 420
539 
540  if (s->apply_defdispwin &&
543  "discarding vui default display window, "
544  "original values are l:%u r:%u t:%u b:%u\n",
549 
552  vui->def_disp_win.top_offset =
553  vui->def_disp_win.bottom_offset = 0;
554  }
555  }
556 
558 
559  if (vui->vui_timing_info_present_flag) {
560  if( get_bits_left(gb) < 66) {
561  // The alternate syntax seem to have timing info located
562  // at where def_disp_win is normally located
564  "Strange VUI timing information, retrying...\n");
566  memset(&vui->def_disp_win, 0, sizeof(vui->def_disp_win));
567  memcpy(gb, &backup, sizeof(backup));
568  alt = 1;
569  }
570  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
571  vui->vui_time_scale = get_bits_long(gb, 32);
572  if (alt) {
573  av_log(s->avctx, AV_LOG_INFO, "Retry got %i/%i fps\n",
575  }
581  decode_hrd(s, 1, sps->max_sub_layers);
582  }
583 
585  if (vui->bitstream_restriction_flag) {
594  }
595 }
596 
598 {
599  int matrixId;
600 
601  for (matrixId = 0; matrixId < 6; matrixId++) {
602  // 4x4 default is 16
603  memset(sl->sl[0][matrixId], 16, 16);
604  sl->sl_dc[0][matrixId] = 16; // default for 16x16
605  sl->sl_dc[1][matrixId] = 16; // default for 32x32
606  }
607  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
608  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
609  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
610  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
611  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
612  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
613  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
614  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
615  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
616  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
617  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
618  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
619  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
620  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
621  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
622  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
623  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
624  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
625 }
626 
628 {
629  GetBitContext *gb = &s->HEVClc->gb;
630  uint8_t scaling_list_pred_mode_flag;
631  int32_t scaling_list_dc_coef[2][6];
632  int size_id, matrix_id, pos;
633  int i;
634 
635  for (size_id = 0; size_id < 4; size_id++)
636  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
637  scaling_list_pred_mode_flag = get_bits1(gb);
638  if (!scaling_list_pred_mode_flag) {
639  unsigned int delta = get_ue_golomb_long(gb);
640  /* Only need to handle non-zero delta. Zero means default,
641  * which should already be in the arrays. */
642  if (delta) {
643  // Copy from previous array.
644  if (matrix_id < delta) {
646  "Invalid delta in scaling list data: %d.\n", delta);
647  return AVERROR_INVALIDDATA;
648  }
649 
650  memcpy(sl->sl[size_id][matrix_id],
651  sl->sl[size_id][matrix_id - delta],
652  size_id > 0 ? 64 : 16);
653  if (size_id > 1)
654  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
655  }
656  } else {
657  int next_coef, coef_num;
658  int32_t scaling_list_delta_coef;
659 
660  next_coef = 8;
661  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
662  if (size_id > 1) {
663  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
664  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
665  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
666  }
667  for (i = 0; i < coef_num; i++) {
668  if (size_id == 0)
669  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
671  else
672  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
674 
675  scaling_list_delta_coef = get_se_golomb(gb);
676  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
677  sl->sl[size_id][matrix_id][pos] = next_coef;
678  }
679  }
680  }
681 
682  if (sps->chroma_format_idc == 3) {
683  for (i = 0; i < 64; i++) {
684  sl->sl[3][1][i] = sl->sl[2][1][i];
685  sl->sl[3][2][i] = sl->sl[2][2][i];
686  sl->sl[3][4][i] = sl->sl[2][4][i];
687  sl->sl[3][5][i] = sl->sl[2][5][i];
688  }
689  sl->sl_dc[1][1] = sl->sl_dc[0][1];
690  sl->sl_dc[1][2] = sl->sl_dc[0][2];
691  sl->sl_dc[1][4] = sl->sl_dc[0][4];
692  sl->sl_dc[1][5] = sl->sl_dc[0][5];
693  }
694 
695 
696  return 0;
697 }
698 
700 {
701  const AVPixFmtDescriptor *desc;
702  GetBitContext *gb = &s->HEVClc->gb;
703  int ret = 0;
704  unsigned int sps_id = 0;
705  int log2_diff_max_min_transform_block_size;
706  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
707  int i;
708 
709  HEVCSPS *sps;
710  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
711 
712  if (!sps_buf)
713  return AVERROR(ENOMEM);
714  sps = (HEVCSPS*)sps_buf->data;
715 
716  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
717 
718  // Coded parameters
719 
720  sps->vps_id = get_bits(gb, 4);
721  if (sps->vps_id >= MAX_VPS_COUNT) {
722  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
723  ret = AVERROR_INVALIDDATA;
724  goto err;
725  }
726 
727  if (!s->vps_list[sps->vps_id]) {
728  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
729  sps->vps_id);
730  ret = AVERROR_INVALIDDATA;
731  goto err;
732  }
733 
734  sps->max_sub_layers = get_bits(gb, 3) + 1;
735  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
736  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
737  sps->max_sub_layers);
738  ret = AVERROR_INVALIDDATA;
739  goto err;
740  }
741 
742  skip_bits1(gb); // temporal_id_nesting_flag
743 
744  if (parse_ptl(s, &sps->ptl, sps->max_sub_layers) < 0)
745  goto err;
746 
747  sps_id = get_ue_golomb_long(gb);
748  if (sps_id >= MAX_SPS_COUNT) {
749  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
750  ret = AVERROR_INVALIDDATA;
751  goto err;
752  }
753 
755  if (!(sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2 || sps->chroma_format_idc == 3)) {
756  avpriv_report_missing_feature(s->avctx, "chroma_format_idc != {1, 2, 3}\n");
757  ret = AVERROR_PATCHWELCOME;
758  goto err;
759  }
760 
761  if (sps->chroma_format_idc == 3)
763 
765  sps->chroma_format_idc = 0;
766 
767  sps->width = get_ue_golomb_long(gb);
768  sps->height = get_ue_golomb_long(gb);
769  if ((ret = av_image_check_size(sps->width,
770  sps->height, 0, s->avctx)) < 0)
771  goto err;
772 
773  if (get_bits1(gb)) { // pic_conformance_flag
774  //TODO: * 2 is only valid for 420
779 
782  "discarding sps conformance window, "
783  "original values are l:%u r:%u t:%u b:%u\n",
788 
791  sps->pic_conf_win.top_offset =
792  sps->pic_conf_win.bottom_offset = 0;
793  }
794  sps->output_window = sps->pic_conf_win;
795  }
796 
797  sps->bit_depth = get_ue_golomb_long(gb) + 8;
798  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
799  if (bit_depth_chroma != sps->bit_depth) {
801  "Luma bit depth (%d) is different from chroma bit depth (%d), "
802  "this is unsupported.\n",
803  sps->bit_depth, bit_depth_chroma);
804  ret = AVERROR_INVALIDDATA;
805  goto err;
806  }
807 
808  switch (sps->bit_depth) {
809  case 8:
810  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
811  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
812  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
813  break;
814  case 9:
815  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
816  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
817  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
818  break;
819  case 10:
820  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
821  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
822  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
823  break;
824  case 12:
825  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
826  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
827  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
828  break;
829  default:
831  "4:2:0, 4:2:2, 4:4:4 supports are currently specified for 8, 10 and 12 bits.\n");
832  ret = AVERROR_PATCHWELCOME;
833  goto err;
834  }
835 
836  desc = av_pix_fmt_desc_get(sps->pix_fmt);
837  if (!desc) {
838  ret = AVERROR(EINVAL);
839  goto err;
840  }
841 
842  sps->hshift[0] = sps->vshift[0] = 0;
843  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
844  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
845 
846  sps->pixel_shift = sps->bit_depth > 8;
847 
848  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
849  if (sps->log2_max_poc_lsb > 16) {
850  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
851  sps->log2_max_poc_lsb - 4);
852  ret = AVERROR_INVALIDDATA;
853  goto err;
854  }
855 
856  sublayer_ordering_info = get_bits1(gb);
857  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
858  for (i = start; i < sps->max_sub_layers; i++) {
863  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
865  ret = AVERROR_INVALIDDATA;
866  goto err;
867  }
869  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
871  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
873  ret = AVERROR_INVALIDDATA;
874  goto err;
875  }
877  }
878  }
879 
880  if (!sublayer_ordering_info) {
881  for (i = 0; i < start; i++) {
885  }
886  }
887 
888  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
890  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
891  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
892  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
893  sps->log2_min_tb_size;
894 
895  if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {
896  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
897  ret = AVERROR_INVALIDDATA;
898  goto err;
899  }
902 
904  if (sps->scaling_list_enable_flag) {
906 
907  if (get_bits1(gb)) {
908  ret = scaling_list_data(s, &sps->scaling_list, sps);
909  if (ret < 0)
910  goto err;
911  }
912  }
913 
914  sps->amp_enabled_flag = get_bits1(gb);
915  sps->sao_enabled = get_bits1(gb);
916 
917  sps->pcm_enabled_flag = get_bits1(gb);
918  if (sps->pcm_enabled_flag) {
919  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
920  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
923  get_ue_golomb_long(gb);
924  if (sps->pcm.bit_depth > sps->bit_depth) {
926  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
927  sps->pcm.bit_depth, sps->bit_depth);
928  ret = AVERROR_INVALIDDATA;
929  goto err;
930  }
931 
933  }
934 
935  sps->nb_st_rps = get_ue_golomb_long(gb);
936  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
937  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
938  sps->nb_st_rps);
939  ret = AVERROR_INVALIDDATA;
940  goto err;
941  }
942  for (i = 0; i < sps->nb_st_rps; i++) {
943  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
944  sps, 0)) < 0)
945  goto err;
946  }
947 
951  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
954  }
955  }
956 
959  sps->vui.sar = (AVRational){0, 1};
960  vui_present = get_bits1(gb);
961  if (vui_present)
962  decode_vui(s, sps);
963 
964  if (get_bits1(gb)) { // sps_extension_flag
965  int sps_extension_flag[1];
966  for (i = 0; i < 1; i++)
967  sps_extension_flag[i] = get_bits1(gb);
968  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
969  if (sps_extension_flag[0]) {
970  int extended_precision_processing_flag;
971  int high_precision_offsets_enabled_flag;
972  int cabac_bypass_alignment_enabled_flag;
973 
977 
979 
980  extended_precision_processing_flag = get_bits1(gb);
981  if (extended_precision_processing_flag)
983  "extended_precision_processing_flag not yet implemented\n");
984 
986  high_precision_offsets_enabled_flag = get_bits1(gb);
987  if (high_precision_offsets_enabled_flag)
989  "high_precision_offsets_enabled_flag not yet implemented\n");
990 
992 
993  cabac_bypass_alignment_enabled_flag = get_bits1(gb);
994  if (cabac_bypass_alignment_enabled_flag)
996  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
997  }
998  }
999  if (s->apply_defdispwin) {
1004  }
1005  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
1006  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
1007  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
1008  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
1009  "chroma samples to preserve alignment.\n",
1010  sps->output_window.left_offset);
1011  }
1012  sps->output_width = sps->width -
1014  sps->output_height = sps->height -
1016  if (sps->output_width <= 0 || sps->output_height <= 0) {
1017  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
1018  sps->output_width, sps->output_height);
1019  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
1020  ret = AVERROR_INVALIDDATA;
1021  goto err;
1022  }
1024  "Displaying the whole video surface.\n");
1025  sps->pic_conf_win.left_offset =
1026  sps->pic_conf_win.right_offset =
1027  sps->pic_conf_win.top_offset =
1028  sps->pic_conf_win.bottom_offset = 0;
1029  sps->output_width = sps->width;
1030  sps->output_height = sps->height;
1031  }
1032 
1033  // Inferred parameters
1034  sps->log2_ctb_size = sps->log2_min_cb_size +
1036  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1037 
1038  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1039  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1040  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1041 
1042  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1043  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1044  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1045  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1046  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1047  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1048  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1049 
1050  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1051 
1052  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
1053  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
1054  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1055  goto err;
1056  }
1057 
1058  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
1059  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1060  goto err;
1061  }
1063  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1065  goto err;
1066  }
1068  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1070  goto err;
1071  }
1072  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1074  "max transform block size out of range: %d\n",
1075  sps->log2_max_trafo_size);
1076  goto err;
1077  }
1078 
1079  if (get_bits_left(gb) < 0) {
1081  "Overread SPS by %d bits\n", -get_bits_left(gb));
1082  goto err;
1083  }
1084 
1085  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
1087  "Parsed SPS: id %d; coded wxh: %dx%d; "
1088  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1089  sps_id, sps->width, sps->height,
1090  sps->output_width, sps->output_height,
1092  }
1093 
1094  /* check if this is a repeat of an already parsed SPS, then keep the
1095  * original one.
1096  * otherwise drop all PPSes that depend on it */
1097  if (s->sps_list[sps_id] &&
1098  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1099  av_buffer_unref(&sps_buf);
1100  } else {
1101  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
1102  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
1103  av_buffer_unref(&s->pps_list[i]);
1104  }
1105  if (s->sps_list[sps_id] && s->sps == (HEVCSPS*)s->sps_list[sps_id]->data) {
1107  s->current_sps = av_buffer_ref(s->sps_list[sps_id]);
1108  if (!s->current_sps)
1109  s->sps = NULL;
1110  }
1111  av_buffer_unref(&s->sps_list[sps_id]);
1112  s->sps_list[sps_id] = sps_buf;
1113  }
1114 
1115  return 0;
1116 
1117 err:
1118  av_buffer_unref(&sps_buf);
1119  return ret;
1120 }
1121 
1122 static void hevc_pps_free(void *opaque, uint8_t *data)
1123 {
1124  HEVCPPS *pps = (HEVCPPS*)data;
1125 
1126  av_freep(&pps->column_width);
1127  av_freep(&pps->row_height);
1128  av_freep(&pps->col_bd);
1129  av_freep(&pps->row_bd);
1130  av_freep(&pps->col_idxX);
1131  av_freep(&pps->ctb_addr_rs_to_ts);
1132  av_freep(&pps->ctb_addr_ts_to_rs);
1133  av_freep(&pps->tile_pos_rs);
1134  av_freep(&pps->tile_id);
1136 
1137  av_freep(&pps);
1138 }
1139 
1141  GetBitContext *gb = &s->HEVClc->gb;
1142  int i;
1143 
1144  if (pps->transform_skip_enabled_flag) {
1146  }
1154  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1155  return AVERROR_INVALIDDATA;
1156  }
1157  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1158  pps->cb_qp_offset_list[i] = get_se_golomb_long(gb);
1159  if (pps->cb_qp_offset_list[i]) {
1161  "cb_qp_offset_list not tested yet.\n");
1162  }
1163  pps->cr_qp_offset_list[i] = get_se_golomb_long(gb);
1164  if (pps->cr_qp_offset_list[i]) {
1166  "cb_qp_offset_list not tested yet.\n");
1167  }
1168  }
1169  }
1172 
1173  return(0);
1174 }
1175 
1177 {
1178  GetBitContext *gb = &s->HEVClc->gb;
1179  HEVCSPS *sps = NULL;
1180  int pic_area_in_ctbs;
1181  int log2_diff_ctb_min_tb_size;
1182  int i, j, x, y, ctb_addr_rs, tile_id;
1183  int ret = 0;
1184  unsigned int pps_id = 0;
1185 
1186  AVBufferRef *pps_buf;
1187  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1188 
1189  if (!pps)
1190  return AVERROR(ENOMEM);
1191 
1192  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1193  hevc_pps_free, NULL, 0);
1194  if (!pps_buf) {
1195  av_freep(&pps);
1196  return AVERROR(ENOMEM);
1197  }
1198 
1199  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1200 
1201  // Default values
1203  pps->num_tile_columns = 1;
1204  pps->num_tile_rows = 1;
1205  pps->uniform_spacing_flag = 1;
1206  pps->disable_dbf = 0;
1207  pps->beta_offset = 0;
1208  pps->tc_offset = 0;
1210 
1211  // Coded parameters
1212  pps_id = get_ue_golomb_long(gb);
1213  if (pps_id >= MAX_PPS_COUNT) {
1214  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1215  ret = AVERROR_INVALIDDATA;
1216  goto err;
1217  }
1218  pps->sps_id = get_ue_golomb_long(gb);
1219  if (pps->sps_id >= MAX_SPS_COUNT) {
1220  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1221  ret = AVERROR_INVALIDDATA;
1222  goto err;
1223  }
1224  if (!s->sps_list[pps->sps_id]) {
1225  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1226  ret = AVERROR_INVALIDDATA;
1227  goto err;
1228  }
1229  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1230 
1233  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1234 
1235  pps->sign_data_hiding_flag = get_bits1(gb);
1236 
1238 
1241 
1243 
1246 
1248  pps->diff_cu_qp_delta_depth = 0;
1249  if (pps->cu_qp_delta_enabled_flag)
1251 
1252  pps->cb_qp_offset = get_se_golomb(gb);
1253  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1254  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1255  pps->cb_qp_offset);
1256  ret = AVERROR_INVALIDDATA;
1257  goto err;
1258  }
1259  pps->cr_qp_offset = get_se_golomb(gb);
1260  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1261  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1262  pps->cr_qp_offset);
1263  ret = AVERROR_INVALIDDATA;
1264  goto err;
1265  }
1267 
1268  pps->weighted_pred_flag = get_bits1(gb);
1269  pps->weighted_bipred_flag = get_bits1(gb);
1270 
1272  pps->tiles_enabled_flag = get_bits1(gb);
1274 
1275  if (pps->tiles_enabled_flag) {
1276  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1277  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1278  if (pps->num_tile_columns == 0 ||
1279  pps->num_tile_columns >= sps->width) {
1280  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1281  pps->num_tile_columns - 1);
1282  ret = AVERROR_INVALIDDATA;
1283  goto err;
1284  }
1285  if (pps->num_tile_rows == 0 ||
1286  pps->num_tile_rows >= sps->height) {
1287  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1288  pps->num_tile_rows - 1);
1289  ret = AVERROR_INVALIDDATA;
1290  goto err;
1291  }
1292 
1293  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1294  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1295  if (!pps->column_width || !pps->row_height) {
1296  ret = AVERROR(ENOMEM);
1297  goto err;
1298  }
1299 
1300  pps->uniform_spacing_flag = get_bits1(gb);
1301  if (!pps->uniform_spacing_flag) {
1302  uint64_t sum = 0;
1303  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1304  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1305  sum += pps->column_width[i];
1306  }
1307  if (sum >= sps->ctb_width) {
1308  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1309  ret = AVERROR_INVALIDDATA;
1310  goto err;
1311  }
1312  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1313 
1314  sum = 0;
1315  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1316  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1317  sum += pps->row_height[i];
1318  }
1319  if (sum >= sps->ctb_height) {
1320  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1321  ret = AVERROR_INVALIDDATA;
1322  goto err;
1323  }
1324  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1325  }
1327  }
1328 
1330 
1334  pps->disable_dbf = get_bits1(gb);
1335  if (!pps->disable_dbf) {
1336  pps->beta_offset = get_se_golomb(gb) * 2;
1337  pps->tc_offset = get_se_golomb(gb) * 2;
1338  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1339  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1340  pps->beta_offset/2);
1341  ret = AVERROR_INVALIDDATA;
1342  goto err;
1343  }
1344  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1345  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1346  pps->tc_offset/2);
1347  ret = AVERROR_INVALIDDATA;
1348  goto err;
1349  }
1350  }
1351  }
1352 
1354  if (pps->scaling_list_data_present_flag) {
1356  ret = scaling_list_data(s, &pps->scaling_list, sps);
1357  if (ret < 0)
1358  goto err;
1359  }
1362  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1363  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1364  pps->log2_parallel_merge_level - 2);
1365  ret = AVERROR_INVALIDDATA;
1366  goto err;
1367  }
1368 
1370 
1371  if (get_bits1(gb)) { // pps_extension_present_flag
1372  int pps_range_extensions_flag = get_bits1(gb);
1373  /* int pps_extension_7bits = */ get_bits(gb, 7);
1374  if (sps->ptl.general_ptl.profile_idc == FF_PROFILE_HEVC_REXT && pps_range_extensions_flag) {
1375  pps_range_extensions(s, pps, sps);
1376  }
1377  }
1378 
1379  // Inferred parameters
1380  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1381  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1382  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1383  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1384  ret = AVERROR(ENOMEM);
1385  goto err;
1386  }
1387 
1388  if (pps->uniform_spacing_flag) {
1389  if (!pps->column_width) {
1390  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1391  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1392  }
1393  if (!pps->column_width || !pps->row_height) {
1394  ret = AVERROR(ENOMEM);
1395  goto err;
1396  }
1397 
1398  for (i = 0; i < pps->num_tile_columns; i++) {
1399  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1400  (i * sps->ctb_width) / pps->num_tile_columns;
1401  }
1402 
1403  for (i = 0; i < pps->num_tile_rows; i++) {
1404  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1405  (i * sps->ctb_height) / pps->num_tile_rows;
1406  }
1407  }
1408 
1409  pps->col_bd[0] = 0;
1410  for (i = 0; i < pps->num_tile_columns; i++)
1411  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1412 
1413  pps->row_bd[0] = 0;
1414  for (i = 0; i < pps->num_tile_rows; i++)
1415  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1416 
1417  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1418  if (i > pps->col_bd[j])
1419  j++;
1420  pps->col_idxX[i] = j;
1421  }
1422 
1423  /**
1424  * 6.5
1425  */
1426  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1427 
1428  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1429  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1430  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1431  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1432  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1433  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1434  ret = AVERROR(ENOMEM);
1435  goto err;
1436  }
1437 
1438  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1439  int tb_x = ctb_addr_rs % sps->ctb_width;
1440  int tb_y = ctb_addr_rs / sps->ctb_width;
1441  int tile_x = 0;
1442  int tile_y = 0;
1443  int val = 0;
1444 
1445  for (i = 0; i < pps->num_tile_columns; i++) {
1446  if (tb_x < pps->col_bd[i + 1]) {
1447  tile_x = i;
1448  break;
1449  }
1450  }
1451 
1452  for (i = 0; i < pps->num_tile_rows; i++) {
1453  if (tb_y < pps->row_bd[i + 1]) {
1454  tile_y = i;
1455  break;
1456  }
1457  }
1458 
1459  for (i = 0; i < tile_x; i++)
1460  val += pps->row_height[tile_y] * pps->column_width[i];
1461  for (i = 0; i < tile_y; i++)
1462  val += sps->ctb_width * pps->row_height[i];
1463 
1464  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1465  tb_x - pps->col_bd[tile_x];
1466 
1467  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1468  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1469  }
1470 
1471  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1472  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1473  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1474  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1475  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1476 
1477  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1478  if (!pps->tile_pos_rs) {
1479  ret = AVERROR(ENOMEM);
1480  goto err;
1481  }
1482 
1483  for (j = 0; j < pps->num_tile_rows; j++)
1484  for (i = 0; i < pps->num_tile_columns; i++)
1485  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1486 
1487  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1488  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1489  for (y = 0; y < sps->tb_mask+2; y++) {
1490  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1491  pps->min_tb_addr_zs_tab[y] = -1;
1492  }
1493  for (y = 0; y < sps->tb_mask+1; y++) {
1494  for (x = 0; x < sps->tb_mask+1; x++) {
1495  int tb_x = x >> log2_diff_ctb_min_tb_size;
1496  int tb_y = y >> log2_diff_ctb_min_tb_size;
1497  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1498  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1499  (log2_diff_ctb_min_tb_size * 2);
1500  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1501  int m = 1 << i;
1502  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1503  }
1504  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1505  }
1506  }
1507 
1508  if (get_bits_left(gb) < 0) {
1510  "Overread PPS by %d bits\n", -get_bits_left(gb));
1511  goto err;
1512  }
1513 
1514  av_buffer_unref(&s->pps_list[pps_id]);
1515  s->pps_list[pps_id] = pps_buf;
1516 
1517  return 0;
1518 
1519 err:
1520  av_buffer_unref(&pps_buf);
1521  return ret;
1522 }