FFmpeg
ps.c
Go to the documentation of this file.
1 /*
2  * HEVC Parameter Set decoding
3  *
4  * Copyright (C) 2012 - 2013 Guillaume Martres
5  * Copyright (C) 2012 - 2013 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 "libavutil/mem.h"
28 #include "golomb.h"
29 #include "h2645_vui.h"
30 #include "data.h"
31 #include "ps.h"
32 #include "profiles.h"
33 #include "libavutil/refstruct.h"
34 
35 static const uint8_t default_scaling_list_intra[] = {
36  16, 16, 16, 16, 17, 18, 21, 24,
37  16, 16, 16, 16, 17, 19, 22, 25,
38  16, 16, 17, 18, 20, 22, 25, 29,
39  16, 16, 18, 21, 24, 27, 31, 36,
40  17, 17, 20, 24, 30, 35, 41, 47,
41  18, 19, 22, 27, 35, 44, 54, 65,
42  21, 22, 25, 31, 41, 54, 70, 88,
43  24, 25, 29, 36, 47, 65, 88, 115
44 };
45 
46 static const uint8_t default_scaling_list_inter[] = {
47  16, 16, 16, 16, 17, 18, 20, 24,
48  16, 16, 16, 17, 18, 20, 24, 25,
49  16, 16, 17, 18, 20, 24, 25, 28,
50  16, 17, 18, 20, 24, 25, 28, 33,
51  17, 18, 20, 24, 25, 28, 33, 41,
52  18, 20, 24, 25, 28, 33, 41, 54,
53  20, 24, 25, 28, 33, 41, 54, 71,
54  24, 25, 28, 33, 41, 54, 71, 91
55 };
56 
57 static const uint8_t hevc_sub_width_c[] = {
58  1, 2, 2, 1
59 };
60 
61 static const uint8_t hevc_sub_height_c[] = {
62  1, 2, 1, 1
63 };
64 
65 static void remove_sps(HEVCParamSets *s, int id)
66 {
67  int i;
68  if (s->sps_list[id]) {
69  /* drop all PPS that depend on this SPS */
70  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
71  if (s->pps_list[i] && s->pps_list[i]->sps_id == id)
72  av_refstruct_unref(&s->pps_list[i]);
73 
74  av_refstruct_unref(&s->sps_list[id]);
75  }
76 }
77 
78 static void remove_vps(HEVCParamSets *s, int id)
79 {
80  int i;
81  if (s->vps_list[id]) {
82  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
83  if (s->sps_list[i] && s->sps_list[i]->vps_id == id)
84  remove_sps(s, i);
85  av_refstruct_unref(&s->vps_list[id]);
86  }
87 }
88 
89 int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
90  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
91 {
92  int delta_poc;
93  int k0 = 0;
94  int k = 0;
95  int i;
96 
97  rps->used = 0;
98  rps->rps_predict = 0;
99 
100  if (rps != sps->st_rps && sps->nb_st_rps)
101  rps->rps_predict = get_bits1(gb);
102 
103  if (rps->rps_predict) {
104  const ShortTermRPS *rps_ridx;
105  uint8_t used[32] = { 0 };
106  int delta_rps;
107 
108  if (is_slice_header) {
109  rps->delta_idx = get_ue_golomb_long(gb) + 1;
110  if (rps->delta_idx > sps->nb_st_rps) {
111  av_log(avctx, AV_LOG_ERROR,
112  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
113  rps->delta_idx, sps->nb_st_rps);
114  return AVERROR_INVALIDDATA;
115  }
116  rps_ridx = &sps->st_rps[sps->nb_st_rps - rps->delta_idx];
117  rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
118  } else
119  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
120 
121  rps->delta_rps_sign = get_bits1(gb);
122  rps->abs_delta_rps = get_ue_golomb_long(gb) + 1;
123  if (rps->abs_delta_rps > 32768) {
124  av_log(avctx, AV_LOG_ERROR,
125  "Invalid value of abs_delta_rps: %d\n",
126  rps->abs_delta_rps);
127  return AVERROR_INVALIDDATA;
128  }
129  delta_rps = (1 - (rps->delta_rps_sign << 1)) * rps->abs_delta_rps;
130  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
131  used[k] = get_bits1(gb);
132 
133  rps->use_delta = 0;
134  if (!used[k])
135  rps->use_delta = get_bits1(gb);
136 
137  if (used[k] || rps->use_delta) {
138  if (i < rps_ridx->num_delta_pocs)
139  delta_poc = delta_rps + rps_ridx->delta_poc[i];
140  else
141  delta_poc = delta_rps;
142  rps->delta_poc[k] = delta_poc;
143  if (delta_poc < 0)
144  k0++;
145  k++;
146  }
147  }
148 
149  if (k >= FF_ARRAY_ELEMS(used)) {
150  av_log(avctx, AV_LOG_ERROR,
151  "Invalid num_delta_pocs: %d\n", k);
152  return AVERROR_INVALIDDATA;
153  }
154 
155  rps->num_delta_pocs = k;
156  rps->num_negative_pics = k0;
157  // sort in increasing order (smallest first)
158  if (rps->num_delta_pocs != 0) {
159  int u, tmp;
160  for (i = 1; i < rps->num_delta_pocs; i++) {
161  delta_poc = rps->delta_poc[i];
162  u = used[i];
163  for (k = i - 1; k >= 0; k--) {
164  tmp = rps->delta_poc[k];
165  if (delta_poc < tmp) {
166  rps->delta_poc[k + 1] = tmp;
167  used[k + 1] = used[k];
168  rps->delta_poc[k] = delta_poc;
169  used[k] = u;
170  }
171  }
172  }
173  }
174  if ((rps->num_negative_pics >> 1) != 0) {
175  int u;
176  k = rps->num_negative_pics - 1;
177  // flip the negative values to largest first
178  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
179  delta_poc = rps->delta_poc[i];
180  u = used[i];
181  rps->delta_poc[i] = rps->delta_poc[k];
182  used[i] = used[k];
183  rps->delta_poc[k] = delta_poc;
184  used[k] = u;
185  k--;
186  }
187  }
188 
189  for (unsigned i = 0; i < FF_ARRAY_ELEMS(used); i++)
190  rps->used |= (uint32_t)used[i] << i;
191  } else {
192  unsigned int nb_positive_pics;
193 
194  rps->num_negative_pics = get_ue_golomb_long(gb);
195  nb_positive_pics = get_ue_golomb_long(gb);
196 
197  if (rps->num_negative_pics >= HEVC_MAX_REFS ||
198  nb_positive_pics >= HEVC_MAX_REFS) {
199  av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
200  return AVERROR_INVALIDDATA;
201  }
202 
203  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
204  if (rps->num_delta_pocs) {
205  int prev = 0;
206 
207  for (i = 0; i < rps->num_negative_pics; i++) {
208  delta_poc = get_ue_golomb_long(gb) + 1;
209  if (delta_poc < 1 || delta_poc > 32768) {
210  av_log(avctx, AV_LOG_ERROR,
211  "Invalid value of delta_poc: %d\n",
212  delta_poc);
213  return AVERROR_INVALIDDATA;
214  }
215  prev -= delta_poc;
216  rps->delta_poc[i] = prev;
217  rps->used |= get_bits1(gb) * (1 << i);
218  }
219  prev = 0;
220  for (i = 0; i < nb_positive_pics; i++) {
221  delta_poc = get_ue_golomb_long(gb) + 1;
222  if (delta_poc < 1 || delta_poc > 32768) {
223  av_log(avctx, AV_LOG_ERROR,
224  "Invalid value of delta_poc: %d\n",
225  delta_poc);
226  return AVERROR_INVALIDDATA;
227  }
228  prev += delta_poc;
229  rps->delta_poc[rps->num_negative_pics + i] = prev;
230  rps->used |= get_bits1(gb) * (1 << (rps->num_negative_pics + i));
231  }
232  }
233  }
234  return 0;
235 }
236 
237 
238 static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx,
239  PTLCommon *ptl)
240 {
241  int i;
242 
243  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 43 + 1)
244  return -1;
245 
246  ptl->profile_space = get_bits(gb, 2);
247  ptl->tier_flag = get_bits1(gb);
248  ptl->profile_idc = get_bits(gb, 5);
249 
250 #if !CONFIG_SMALL
251  const char *profile_name = NULL;
252  for (int i = 0; ff_hevc_profiles[i].profile != AV_PROFILE_UNKNOWN; i++)
253  if (ff_hevc_profiles[i].profile == ptl->profile_idc) {
254  profile_name = ff_hevc_profiles[i].name;
255  break;
256  }
257  av_log(avctx, profile_name ? AV_LOG_DEBUG : AV_LOG_WARNING,
258  "%s profile bitstream\n", profile_name ? profile_name : "Unknown");
259 #endif
260 
261  for (i = 0; i < 32; i++) {
262  ptl->profile_compatibility_flag[i] = get_bits1(gb);
263 
264  if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i])
265  ptl->profile_idc = i;
266  }
267  ptl->progressive_source_flag = get_bits1(gb);
268  ptl->interlaced_source_flag = get_bits1(gb);
269  ptl->non_packed_constraint_flag = get_bits1(gb);
270  ptl->frame_only_constraint_flag = get_bits1(gb);
271 
272 #define check_profile_idc(idc) \
273  ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
274 
275  if (check_profile_idc(4) || check_profile_idc(5) || check_profile_idc(6) ||
276  check_profile_idc(7) || check_profile_idc(8) || check_profile_idc(9) ||
277  check_profile_idc(10)) {
278 
279  ptl->max_12bit_constraint_flag = get_bits1(gb);
280  ptl->max_10bit_constraint_flag = get_bits1(gb);
281  ptl->max_8bit_constraint_flag = get_bits1(gb);
282  ptl->max_422chroma_constraint_flag = get_bits1(gb);
283  ptl->max_420chroma_constraint_flag = get_bits1(gb);
284  ptl->max_monochrome_constraint_flag = get_bits1(gb);
285  ptl->intra_constraint_flag = get_bits1(gb);
286  ptl->one_picture_only_constraint_flag = get_bits1(gb);
287  ptl->lower_bit_rate_constraint_flag = get_bits1(gb);
288 
289  if (check_profile_idc(5) || check_profile_idc(9) || check_profile_idc(10)) {
290  ptl->max_14bit_constraint_flag = get_bits1(gb);
291  skip_bits_long(gb, 33); // XXX_reserved_zero_33bits[0..32]
292  } else {
293  skip_bits_long(gb, 34); // XXX_reserved_zero_34bits[0..33]
294  }
295  } else if (check_profile_idc(2)) {
296  skip_bits(gb, 7);
297  ptl->one_picture_only_constraint_flag = get_bits1(gb);
298  skip_bits_long(gb, 35); // XXX_reserved_zero_35bits[0..34]
299  } else {
300  skip_bits_long(gb, 43); // XXX_reserved_zero_43bits[0..42]
301  }
302 
303  if (check_profile_idc(1) || check_profile_idc(2) || check_profile_idc(3) ||
304  check_profile_idc(4) || check_profile_idc(5) || check_profile_idc(9))
305  ptl->inbld_flag = get_bits1(gb);
306  else
307  skip_bits1(gb);
308 #undef check_profile_idc
309 
310  return 0;
311 }
312 
313 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
314  int profile_present, PTL *ptl, int max_num_sub_layers)
315 {
316  int i, status = 0;
317 
318  if (profile_present) {
319  status = decode_profile_tier_level(gb, avctx, &ptl->general_ptl);
320  } else {
321  memset(&ptl->general_ptl, 0, sizeof(ptl->general_ptl));
322  }
323 
324  if (status < 0 || get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
325  av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
326  return -1;
327  }
328 
329  ptl->general_ptl.level_idc = get_bits(gb, 8);
330 
331  for (i = 0; i < max_num_sub_layers - 1; i++) {
332  ptl->sub_layer_profile_present_flag[i] = get_bits1(gb);
333  ptl->sub_layer_level_present_flag[i] = get_bits1(gb);
334  }
335 
336  if (max_num_sub_layers - 1> 0)
337  for (i = max_num_sub_layers - 1; i < 8; i++)
338  skip_bits(gb, 2); // reserved_zero_2bits[i]
339  for (i = 0; i < max_num_sub_layers - 1; i++) {
340  if (ptl->sub_layer_profile_present_flag[i] &&
341  decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
342  av_log(avctx, AV_LOG_ERROR,
343  "PTL information for sublayer %i too short\n", i);
344  return -1;
345  }
346  if (ptl->sub_layer_level_present_flag[i]) {
347  if (get_bits_left(gb) < 8) {
348  av_log(avctx, AV_LOG_ERROR,
349  "Not enough data for sublayer %i level_idc\n", i);
350  return -1;
351  } else
352  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
353  }
354  }
355 
356  return 0;
357 }
358 
359 static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
360  HEVCSublayerHdrParams *par, int subpic_params_present)
361 {
362  int i;
363 
364  for (i = 0; i < nb_cpb; i++) {
365  par->bit_rate_value_minus1[i] = get_ue_golomb_long(gb);
366  par->cpb_size_value_minus1[i] = get_ue_golomb_long(gb);
367 
368  if (subpic_params_present) {
369  par->cpb_size_du_value_minus1[i] = get_ue_golomb_long(gb);
370  par->bit_rate_du_value_minus1[i] = get_ue_golomb_long(gb);
371  }
372 
373  par->cbr_flag |= get_bits1(gb) << i;
374  }
375 }
376 
377 static int decode_hrd(GetBitContext *gb, int common_inf_present,
378  HEVCHdrParams *hdr, int max_sublayers)
379 {
380  if (common_inf_present) {
381  hdr->nal_hrd_parameters_present_flag = get_bits1(gb);
382  hdr->vcl_hrd_parameters_present_flag = get_bits1(gb);
383 
384  if (hdr->nal_hrd_parameters_present_flag ||
385  hdr->vcl_hrd_parameters_present_flag) {
386  hdr->sub_pic_hrd_params_present_flag = get_bits1(gb);
387 
388  if (hdr->sub_pic_hrd_params_present_flag) {
389  hdr->tick_divisor_minus2 = get_bits(gb, 8);
390  hdr->du_cpb_removal_delay_increment_length_minus1 = get_bits(gb, 5);
391  hdr->sub_pic_cpb_params_in_pic_timing_sei_flag = get_bits1(gb);
392  hdr->dpb_output_delay_du_length_minus1 = get_bits(gb, 5);
393  }
394 
395  hdr->bit_rate_scale = get_bits(gb, 4);
396  hdr->cpb_size_scale = get_bits(gb, 4);
397 
398  if (hdr->sub_pic_hrd_params_present_flag)
399  hdr->cpb_size_du_scale = get_bits(gb, 4);
400 
401  hdr->initial_cpb_removal_delay_length_minus1 = get_bits(gb, 5);
402  hdr->au_cpb_removal_delay_length_minus1 = get_bits(gb, 5);
403  hdr->dpb_output_delay_length_minus1 = get_bits(gb, 5);
404  }
405  }
406 
407  for (int i = 0; i < max_sublayers; i++) {
408  unsigned fixed_pic_rate_general_flag = get_bits1(gb);
409  unsigned fixed_pic_rate_within_cvs_flag = 0;
410  unsigned low_delay_hrd_flag = 0;
411  hdr->flags.fixed_pic_rate_general_flag |= fixed_pic_rate_general_flag << i;
412 
413  if (!fixed_pic_rate_general_flag)
414  fixed_pic_rate_within_cvs_flag = get_bits1(gb);
415  hdr->flags.fixed_pic_rate_within_cvs_flag |= fixed_pic_rate_within_cvs_flag << i;
416 
417  if (fixed_pic_rate_within_cvs_flag || fixed_pic_rate_general_flag)
418  hdr->elemental_duration_in_tc_minus1[i] = get_ue_golomb_long(gb);
419  else
420  low_delay_hrd_flag = get_bits1(gb);
421  hdr->flags.low_delay_hrd_flag |= low_delay_hrd_flag << i;
422 
423  if (!low_delay_hrd_flag) {
424  unsigned cpb_cnt_minus1 = get_ue_golomb_long(gb);
425  if (cpb_cnt_minus1 > 31) {
426  av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n",
427  cpb_cnt_minus1);
428  return AVERROR_INVALIDDATA;
429  }
430  hdr->cpb_cnt_minus1[i] = cpb_cnt_minus1;
431  }
432 
433  if (hdr->nal_hrd_parameters_present_flag)
434  decode_sublayer_hrd(gb, hdr->cpb_cnt_minus1[i]+1, &hdr->nal_params[i],
435  hdr->sub_pic_hrd_params_present_flag);
436 
437  if (hdr->vcl_hrd_parameters_present_flag)
438  decode_sublayer_hrd(gb, hdr->cpb_cnt_minus1[i]+1, &hdr->vcl_params[i],
439  hdr->sub_pic_hrd_params_present_flag);
440  }
441 
442  return 0;
443 }
444 
445 static void hevc_vps_free(AVRefStructOpaque opaque, void *obj)
446 {
447  HEVCVPS *vps = obj;
448 
449  av_freep(&vps->hdr);
450  av_freep(&vps->data);
451 }
452 
453 enum DependencyType {
454  HEVC_DEP_TYPE_SAMPLE = 0,
455  HEVC_DEP_TYPE_MV = 1,
456  HEVC_DEP_TYPE_BOTH = 2,
457 };
458 
459 static int decode_vps_ext(GetBitContext *gb, AVCodecContext *avctx, HEVCVPS *vps,
460  uint64_t layer1_id_included)
461 {
462  PTL ptl_dummy;
463  uint8_t max_sub_layers[HEVC_MAX_LAYERS] = {1, 1};
464  uint8_t dimension_id_len[16] = {0};
465  uint8_t dimension_id[16] = {0};
466  unsigned n;
467 
468  int splitting_flag, view_id_len, num_add_olss, num_scalability_types,
469  default_output_layer_idc, direct_dep_type_len, direct_dep_type,
470  sub_layers_max_present, sub_layer_flag_info_present_flag, nb_ptl;
471  unsigned non_vui_extension_length;
472 
473  if (vps->vps_max_layers == 1) {
474  av_log(avctx, AV_LOG_VERBOSE, "Ignoring VPS extensions with a single layer\n");
475  return 0;
476  }
477 
478  if (vps->vps_max_layers > 2) {
479  av_log(avctx, AV_LOG_ERROR,
480  "VPS has %d layers, only 2 layers are supported\n",
481  vps->vps_max_layers);
482  return AVERROR_PATCHWELCOME;
483  }
484  if (vps->vps_num_layer_sets > 2) {
485  av_log(avctx, AV_LOG_ERROR,
486  "VPS has %d layer sets, only 2 layer sets are supported\n",
487  vps->vps_num_layer_sets);
488  return AVERROR_PATCHWELCOME;
489  }
490 
491  align_get_bits(gb);
492 
493  /**
494  * For stereoscopic MV-HEVC, the following simplifying assumptions are made:
495  *
496  * - vps_max_layers = 2 (one base layer, one multiview layer)
497  * - vps_num_layer_sets = 2 (one output layer set for each view)
498  * - NumScalabilityTypes = 1 (only HEVC_SCALABILITY_MULTIVIEW)
499  * - direct_dependency_flag[1][0] = 1 (second layer depends on first)
500  * - num_add_olss = 0 (no extra output layer sets)
501  * - default_output_layer_idc = 0 (1:1 mapping between OLSs and layers)
502  * - layer_id_included_flag[1] = {1, 1} (consequence of layer dependencies)
503  * - vps_num_rep_formats_minus1 = 0 (all layers have the same size)
504  *
505  * Which results in the following derived variables:
506  * - ViewOrderIdx = {0, 1}
507  * - NumViews = 2
508  * - DependencyFlag[1][0] = 1
509  * - NumDirectRefLayers = {0, 1}
510  * - NumRefLayers = {0, 1}
511  * - NumPredictedLayers = {1, 0}
512  * - NumIndependentLayers = 1
513  * - NumLayersInTreePartition = {2}
514  * - NumLayerSets = 2
515  * - NumOutputLayerSets = 2
516  * - OlsIdxToLsIdx = {0, 1}
517  * - LayerIdxInVps = {0, 1}
518  * - NumLayersInIdList = {1, 2}
519  * - NumNecessaryLayers = {1, 2}
520  * - NecessaryLayerFlag = {{1, 0}, {1, 1}}
521  * - NumOutputLayersInOutputLayerSet = {1, 2}
522  * - OutputLayerFlag = {{1, 0}, {1, 1}}
523  */
524  vps->nb_layers = 2;
525 
526  /* vps_base_layer_internal_flag is true has been checked before */
527  if (parse_ptl(gb, avctx, 0, &ptl_dummy, vps->vps_max_sub_layers) < 0)
528  return AVERROR_INVALIDDATA;
529 
530  splitting_flag = get_bits1(gb);
531  vps->scalability_mask_flag = get_bits(gb, 16);
532  num_scalability_types = av_popcount(vps->scalability_mask_flag);
533  if (!num_scalability_types) {
534  av_log(avctx, AV_LOG_ERROR, "Missing scalability mask\n");
535  return AVERROR_INVALIDDATA;
536  }
537 
538  if (!(vps->scalability_mask_flag &
539  (HEVC_SCALABILITY_MULTIVIEW | HEVC_SCALABILITY_AUXILIARY))) {
540  av_log(avctx, AV_LOG_ERROR, "Scalability type %d not supported\n",
541  15 - ff_ctz(vps->scalability_mask_flag));
542  return AVERROR_PATCHWELCOME;
543  }
544  // x265 specify MULTIVIEW when the stream really is alpha video only.
545  if (num_scalability_types > 1)
546  av_log(avctx, AV_LOG_WARNING, "Multiple scalability types presented\n");
547 
548  n = 0;
549  for (int i = 0; i < num_scalability_types - splitting_flag; i++) {
550  dimension_id_len[i] = get_bits(gb, 3) + 1;
551  n += dimension_id_len[i];
552  }
553  if (splitting_flag)
554  dimension_id_len[num_scalability_types - 1] = 5 - n;
555 
556  if (get_bits1(gb)) { /* vps_nuh_layer_id_present_flag */
557  int layer_id_in_nuh = get_bits(gb, 6);
558  if (layer_id_in_nuh >= FF_ARRAY_ELEMS(vps->layer_idx)) {
559  av_log(avctx, AV_LOG_ERROR, "Invalid layer_id_in_nuh[1]: %d\n",
560  layer_id_in_nuh);
561  return AVERROR_INVALIDDATA;
562  }
563  vps->layer_idx[layer_id_in_nuh] = 1;
564  vps->layer_id_in_nuh[1] = layer_id_in_nuh;
565  } else {
566  vps->layer_idx[1] = 1;
567  vps->layer_id_in_nuh[1] = 1;
568  }
569 
570  if (!splitting_flag) {
571  int index = 0;
572 
573  for (int i = 0; i < num_scalability_types; i++)
574  dimension_id[i] = get_bits(gb, dimension_id_len[i]);
575 
576  if (vps->scalability_mask_flag & HEVC_SCALABILITY_MULTIVIEW)
577  index++;
578 
579  /* AuxId 1 is alpha, 2 is depth. Only support alpha */
580  if (vps->scalability_mask_flag & HEVC_SCALABILITY_AUXILIARY &&
581  dimension_id[index] != HEVC_AUX_ALPHA) {
582  av_log(avctx, AV_LOG_WARNING,
583  "Unsupported dimension_id %d for HEVC_SCALABILITY_AUXILIARY\n",
584  dimension_id[index]);
585  return AVERROR_PATCHWELCOME;
586  }
587  }
588 
589  view_id_len = get_bits(gb, 4);
590  if (view_id_len) {
591  n = (vps->scalability_mask_flag & HEVC_SCALABILITY_MULTIVIEW) ? 2 : 1;
592  for (int i = 0; i < n; i++)
593  vps->view_id[i] = get_bits(gb, view_id_len);
594  }
595 
596  /* direct_dependency_flag */
597  vps->num_direct_ref_layers[1] = get_bits1(gb);
598  if (!vps->num_direct_ref_layers[1]) {
599  vps->num_add_layer_sets = get_ue_golomb(gb);
600  if (vps->num_add_layer_sets > 1) {
601  av_log(avctx, AV_LOG_WARNING,
602  "Unsupported num_add_layer_sets: %d\n", vps->num_add_layer_sets);
603  return AVERROR_PATCHWELCOME;
604  }
605 
606  if (vps->num_add_layer_sets) {
607  /* highest_layer_idx_plus1 */
608  if (!get_bits1(gb))
609  return AVERROR_PATCHWELCOME;
610  }
611  }
612  vps->num_output_layer_sets = vps->vps_num_layer_sets + vps->num_add_layer_sets;
613  if (vps->num_output_layer_sets != 2)
614  return AVERROR_INVALIDDATA;
615 
616  sub_layers_max_present = get_bits1(gb); // vps_sub_layers_max_minus1_present_flag
617  if (sub_layers_max_present) {
618  for (int i = 0; i < vps->vps_max_layers; i++)
619  max_sub_layers[i] = sub_layers_max_present ? get_bits(gb, 3) + 1 :
620  vps->vps_max_sub_layers;
621  }
622 
623  if (get_bits1(gb) /* max_tid_ref_present_flag */)
624  skip_bits(gb, 3); // max_tid_il_ref_pics_plus1
625 
626  vps->default_ref_layers_active = get_bits1(gb);
627 
628  nb_ptl = get_ue_golomb(gb) + 1;
629  /* idx [0] is signalled in base VPS, idx [1] is signalled at the
630  * start of VPS extension, indices 2+ are signalled here;
631  * we ignore all but the first one anyway */
632  for (int i = 2; i < nb_ptl; i++) {
633  int profile_present = get_bits1(gb);
634  if (parse_ptl(gb, avctx, profile_present, &ptl_dummy, vps->vps_max_sub_layers) < 0)
635  return AVERROR_INVALIDDATA;
636  }
637 
638  num_add_olss = get_ue_golomb(gb);
639  if (num_add_olss != 0) {
640  /* Since we don't implement support for independent output layer sets
641  * and auxiliary layers, this should never nonzero */
642  av_log(avctx, AV_LOG_ERROR, "Unexpected num_add_olss: %d\n", num_add_olss);
643  return AVERROR_PATCHWELCOME;
644  }
645 
646  default_output_layer_idc = get_bits(gb, 2);
647  if (default_output_layer_idc != 0) {
648  av_log(avctx, AV_LOG_WARNING, "Unsupported default_output_layer_idc: %d\n",
649  default_output_layer_idc);
650  return AVERROR_PATCHWELCOME;
651  }
652 
653  /* Consequence of established layer dependencies */
654  if (layer1_id_included &&
655  layer1_id_included != ((1ULL << vps->layer_id_in_nuh[0]) |
656  (1ULL << vps->layer_id_in_nuh[1]))) {
657  av_log(avctx, AV_LOG_ERROR,
658  "Dependent layer not included in layer ID?\n");
659  return AVERROR_PATCHWELCOME;
660  }
661  if (!layer1_id_included)
662  vps->ols[1] = 2;
663  else
664  vps->ols[1] = 3;
665 
666  if (vps->vps_num_layer_sets == 1 || default_output_layer_idc == 2)
667  skip_bits1(gb);
668 
669  if (nb_ptl > 1)
670  for (int j = 0; j < av_popcount64(vps->ols[1]); j++) {
671  int ptl_idx = get_bits(gb, av_ceil_log2(nb_ptl));
672  if (ptl_idx >= nb_ptl) {
673  av_log(avctx, AV_LOG_ERROR, "Invalid PTL index: %d\n", ptl_idx);
674  return AVERROR_INVALIDDATA;
675  }
676  }
677 
678  if (get_ue_golomb_31(gb) != 0 /* vps_num_rep_formats_minus1 */) {
679  av_log(avctx, AV_LOG_ERROR, "Unexpected extra rep formats\n");
680  return AVERROR_INVALIDDATA;
681  }
682 
683  vps->rep_format.pic_width_in_luma_samples = get_bits(gb, 16);
684  vps->rep_format.pic_height_in_luma_samples = get_bits(gb, 16);
685 
686  if (!get_bits1(gb) /* chroma_and_bit_depth_vps_present_flag */) {
687  av_log(avctx, AV_LOG_ERROR,
688  "chroma_and_bit_depth_vps_present_flag=0 in first rep_format\n");
689  return AVERROR_INVALIDDATA;
690  }
691  vps->rep_format.chroma_format_idc = get_bits(gb, 2);
692  if (vps->rep_format.chroma_format_idc == 3)
693  vps->rep_format.separate_colour_plane_flag = get_bits1(gb);
694  vps->rep_format.bit_depth_luma = get_bits(gb, 4) + 8;
695  vps->rep_format.bit_depth_chroma = get_bits(gb, 4) + 8;
696  if (vps->rep_format.bit_depth_luma > 16 ||
697  vps->rep_format.bit_depth_chroma > 16 ||
698  vps->rep_format.bit_depth_luma != vps->rep_format.bit_depth_chroma) {
699  av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %"PRIu8" %"PRIu8"\n",
700  vps->rep_format.bit_depth_luma, vps->rep_format.bit_depth_chroma);
701  return AVERROR_PATCHWELCOME;
702  }
703 
704  if (get_bits1(gb) /* conformance_window_vps_flag */) {
705  int vert_mult = hevc_sub_height_c[vps->rep_format.chroma_format_idc];
706  int horiz_mult = hevc_sub_width_c[vps->rep_format.chroma_format_idc];
707  vps->rep_format.conf_win_left_offset = get_ue_golomb(gb) * horiz_mult;
708  vps->rep_format.conf_win_right_offset = get_ue_golomb(gb) * horiz_mult;
709  vps->rep_format.conf_win_top_offset = get_ue_golomb(gb) * vert_mult;
710  vps->rep_format.conf_win_bottom_offset = get_ue_golomb(gb) * vert_mult;
711  }
712 
713  vps->max_one_active_ref_layer = get_bits1(gb);
714  vps->poc_lsb_aligned = get_bits1(gb);
715  if (!vps->num_direct_ref_layers[1])
716  vps->poc_lsb_not_present = get_bits1(gb) << 1;
717 
718  sub_layer_flag_info_present_flag = get_bits1(gb);
719  for (int j = 0; j < FFMAX(max_sub_layers[0], max_sub_layers[1]); j++) {
720  int sub_layer_dpb_info_present_flag = 1;
721  if (j > 0 && sub_layer_flag_info_present_flag)
722  sub_layer_dpb_info_present_flag = get_bits1(gb);
723  if (sub_layer_dpb_info_present_flag) {
724  for (int k = 0; k < av_popcount64(vps->ols[1]); k++)
725  vps->dpb_size.max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
726  vps->dpb_size.max_num_reorder_pics = get_ue_golomb_long(gb);
727  vps->dpb_size.max_latency_increase = get_ue_golomb_long(gb) - 1;
728  }
729  }
730 
731  direct_dep_type_len = get_ue_golomb_31(gb) + 2;
732  if (direct_dep_type_len > 32) {
733  av_log(avctx, AV_LOG_ERROR, "Invalid direct_dep_type_len: %d\n",
734  direct_dep_type_len);
735  return AVERROR_INVALIDDATA;
736  }
737 
738  /* direct_depenency_all_layers_flag */
739  if (get_bits1(gb)) {
740  direct_dep_type = get_bits_long(gb, direct_dep_type_len);
741  if (direct_dep_type > HEVC_DEP_TYPE_BOTH) {
742  av_log(avctx, AV_LOG_WARNING, "Unsupported direct_dep_type: %d\n",
743  direct_dep_type);
744  return AVERROR_PATCHWELCOME;
745  }
746  }
747 
748  non_vui_extension_length = get_ue_golomb(gb);
749  if (non_vui_extension_length > 4096) {
750  av_log(avctx, AV_LOG_ERROR, "vps_non_vui_extension_length too large: %u\n",
751  non_vui_extension_length);
752  return AVERROR_INVALIDDATA;
753  }
754  skip_bits_long(gb, non_vui_extension_length * 8);
755 
756  if (get_bits1(gb)) // vps_vui_present_flag
757  av_log(avctx, AV_LOG_WARNING, "VPS VUI not supported\n");
758 
759  return 0;
760 }
761 
762 int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
763  HEVCParamSets *ps)
764 {
765  int i;
766  int vps_id = get_bits(gb, 4);
767  ptrdiff_t nal_size = get_bits_bytesize(gb, 1);
768  int ret = AVERROR_INVALIDDATA;
769  uint64_t layer1_id_included = 0;
770  unsigned vps_base_layer_internal_flag, vps_base_layer_available_flag;
771  HEVCVPS *vps;
772 
773  if (ps->vps_list[vps_id]) {
774  const HEVCVPS *vps1 = ps->vps_list[vps_id];
775  if (vps1->data_size == nal_size &&
776  !memcmp(vps1->data, gb->buffer, vps1->data_size))
777  return 0;
778  }
779 
780  vps = av_refstruct_alloc_ext(sizeof(*vps), 0, NULL, hevc_vps_free);
781  if (!vps)
782  return AVERROR(ENOMEM);
783 
784  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
785 
786  vps->data_size = nal_size;
787  vps->data = av_memdup(gb->buffer, nal_size);
788  if (!vps->data) {
789  ret = AVERROR(ENOMEM);
790  goto err;
791  }
792  vps->vps_id = vps_id;
793 
794  vps_base_layer_internal_flag = get_bits1(gb);
795  vps_base_layer_available_flag = get_bits1(gb);
796  if (!vps_base_layer_internal_flag || !vps_base_layer_available_flag) {
797  av_log(avctx, AV_LOG_ERROR,
798  "vps_base_layer_internal_flag or vps_base_layer_available_flag not set\n");
799  ret = AVERROR_PATCHWELCOME;
800  goto err;
801  }
802 
803  vps->vps_max_layers = get_bits(gb, 6) + 1;
804  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
805  vps->vps_temporal_id_nesting_flag = get_bits1(gb);
806 
807  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
808  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
809  goto err;
810  }
811 
812  if (vps->vps_max_sub_layers > HEVC_MAX_SUB_LAYERS) {
813  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
814  vps->vps_max_sub_layers);
815  goto err;
816  }
817 
818  if (parse_ptl(gb, avctx, 1, &vps->ptl, vps->vps_max_sub_layers) < 0)
819  goto err;
820 
821  vps->vps_sub_layer_ordering_info_present_flag = get_bits1(gb);
822 
823  i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1;
824  for (; i < vps->vps_max_sub_layers; i++) {
825  vps->vps_max_dec_pic_buffering[i] = get_ue_golomb_long(gb) + 1;
826  vps->vps_num_reorder_pics[i] = get_ue_golomb_long(gb);
827  vps->vps_max_latency_increase[i] = get_ue_golomb_long(gb) - 1;
828 
829  if (vps->vps_max_dec_pic_buffering[i] > HEVC_MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
830  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
831  vps->vps_max_dec_pic_buffering[i] - 1);
832  goto err;
833  }
834  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
835  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
836  vps->vps_num_reorder_pics[i]);
837  if (avctx->err_recognition & AV_EF_EXPLODE)
838  goto err;
839  }
840  }
841 
842  vps->vps_max_layer_id = get_bits(gb, 6);
843  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
844  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
845  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
846  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
847  goto err;
848  }
849 
850  vps->num_output_layer_sets = 1;
851  vps->ols[0] = 1;
852 
853  // we support at most 2 layers, so ignore the others
854  if (vps->vps_num_layer_sets > 1)
855  layer1_id_included = get_bits64(gb, vps->vps_max_layer_id + 1); // layer_id_included_flag
856  if (vps->vps_num_layer_sets > 2)
857  skip_bits_long(gb, (vps->vps_num_layer_sets - 2) * (vps->vps_max_layer_id + 1));
858 
859  vps->vps_timing_info_present_flag = get_bits1(gb);
860  if (vps->vps_timing_info_present_flag) {
861  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
862  vps->vps_time_scale = get_bits_long(gb, 32);
863  vps->vps_poc_proportional_to_timing_flag = get_bits1(gb);
864  if (vps->vps_poc_proportional_to_timing_flag)
865  vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1;
866  vps->vps_num_hrd_parameters = get_ue_golomb_long(gb);
867  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
868  av_log(avctx, AV_LOG_ERROR,
869  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
870  goto err;
871  }
872 
873  if (vps->vps_num_hrd_parameters) {
874  vps->hdr = av_calloc(vps->vps_num_hrd_parameters, sizeof(*vps->hdr));
875  if (!vps->hdr)
876  goto err;
877  }
878 
879  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
880  int common_inf_present = 1;
881 
882  get_ue_golomb_long(gb); // hrd_layer_set_idx
883  if (i)
884  common_inf_present = get_bits1(gb);
885  decode_hrd(gb, common_inf_present, &vps->hdr[i],
886  vps->vps_max_sub_layers);
887  }
888  }
889 
890  vps->nb_layers = 1;
891  vps->layer_idx[0] = 0;
892  for (int i = 1; i < FF_ARRAY_ELEMS(vps->layer_idx); i++)
893  vps->layer_idx[i] = -1;
894 
895  if (vps->vps_max_layers > 1 && get_bits1(gb)) { /* vps_extension_flag */
896  int ret = decode_vps_ext(gb, avctx, vps, layer1_id_included);
897  if (ret == AVERROR_PATCHWELCOME) {
898  vps->nb_layers = 1;
899  av_log(avctx, AV_LOG_WARNING, "Ignoring unsupported VPS extension\n");
900  ret = 0;
901  } else if (ret < 0)
902  goto err;
903  }
904 
905  if (get_bits_left(gb) < 0) {
906  av_log(avctx, AV_LOG_ERROR,
907  "Overread VPS by %d bits\n", -get_bits_left(gb));
908  if (ps->vps_list[vps_id])
909  goto err;
910  }
911 
912  remove_vps(ps, vps_id);
913  ps->vps_list[vps_id] = vps;
914 
915  return 0;
916 
917 err:
918  av_refstruct_unref(&vps);
919  return ret;
920 }
921 
922 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
923  int apply_defdispwin, HEVCSPS *sps)
924 {
925  VUI backup_vui, *vui = &sps->vui;
926  GetBitContext backup;
927  int alt = 0;
928 
929  ff_h2645_decode_common_vui_params(gb, &sps->vui.common, avctx);
930 
931  if (vui->common.video_signal_type_present_flag) {
932  if (vui->common.video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
933  sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
934  if (vui->common.colour_description_present_flag) {
935  if (vui->common.matrix_coeffs == AVCOL_SPC_RGB) {
936  switch (sps->pix_fmt) {
937  case AV_PIX_FMT_YUV444P:
938  sps->pix_fmt = AV_PIX_FMT_GBRP;
939  break;
940  case AV_PIX_FMT_YUV444P10:
941  sps->pix_fmt = AV_PIX_FMT_GBRP10;
942  break;
943  case AV_PIX_FMT_YUV444P12:
944  sps->pix_fmt = AV_PIX_FMT_GBRP12;
945  break;
946  }
947  }
948  }
949  }
950 
951  vui->neutra_chroma_indication_flag = get_bits1(gb);
952  vui->field_seq_flag = get_bits1(gb);
953  vui->frame_field_info_present_flag = get_bits1(gb);
954 
955  // Backup context in case an alternate header is detected
956  memcpy(&backup, gb, sizeof(backup));
957  memcpy(&backup_vui, vui, sizeof(backup_vui));
958  if (get_bits_left(gb) >= 68 && show_bits(gb, 21) == 0x100000) {
959  vui->default_display_window_flag = 0;
960  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
961  } else
962  vui->default_display_window_flag = get_bits1(gb);
963 
964  if (vui->default_display_window_flag) {
965  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
966  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
967  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
968  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
969  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
970  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
971 
972  if (apply_defdispwin &&
973  avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
974  av_log(avctx, AV_LOG_DEBUG,
975  "discarding vui default display window, "
976  "original values are l:%u r:%u t:%u b:%u\n",
977  vui->def_disp_win.left_offset,
978  vui->def_disp_win.right_offset,
979  vui->def_disp_win.top_offset,
980  vui->def_disp_win.bottom_offset);
981 
982  vui->def_disp_win.left_offset =
983  vui->def_disp_win.right_offset =
984  vui->def_disp_win.top_offset =
985  vui->def_disp_win.bottom_offset = 0;
986  }
987  }
988 
989 timing_info:
990  vui->vui_timing_info_present_flag = get_bits1(gb);
991 
992  if (vui->vui_timing_info_present_flag) {
993  if( get_bits_left(gb) < 66 && !alt) {
994  // The alternate syntax seem to have timing info located
995  // at where def_disp_win is normally located
996  av_log(avctx, AV_LOG_WARNING,
997  "Strange VUI timing information, retrying...\n");
998  memcpy(vui, &backup_vui, sizeof(backup_vui));
999  memcpy(gb, &backup, sizeof(backup));
1000  alt = 1;
1001  goto timing_info;
1002  }
1003  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
1004  vui->vui_time_scale = get_bits_long(gb, 32);
1005  if (alt) {
1006  av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
1007  vui->vui_time_scale, vui->vui_num_units_in_tick);
1008  }
1009  vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
1010  if (vui->vui_poc_proportional_to_timing_flag)
1011  vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb);
1012  vui->vui_hrd_parameters_present_flag = get_bits1(gb);
1013  if (vui->vui_hrd_parameters_present_flag)
1014  decode_hrd(gb, 1, &sps->hdr, sps->max_sub_layers);
1015  }
1016 
1017  vui->bitstream_restriction_flag = get_bits1(gb);
1018  if (vui->bitstream_restriction_flag) {
1019  if (get_bits_left(gb) < 8 && !alt) {
1020  av_log(avctx, AV_LOG_WARNING,
1021  "Strange VUI bitstream restriction information, retrying"
1022  " from timing information...\n");
1023  memcpy(vui, &backup_vui, sizeof(backup_vui));
1024  memcpy(gb, &backup, sizeof(backup));
1025  alt = 1;
1026  goto timing_info;
1027  }
1028  vui->tiles_fixed_structure_flag = get_bits1(gb);
1029  vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
1030  vui->restricted_ref_pic_lists_flag = get_bits1(gb);
1031  vui->min_spatial_segmentation_idc = get_ue_golomb_long(gb);
1032  vui->max_bytes_per_pic_denom = get_ue_golomb_long(gb);
1033  vui->max_bits_per_min_cu_denom = get_ue_golomb_long(gb);
1034  vui->log2_max_mv_length_horizontal = get_ue_golomb_long(gb);
1035  vui->log2_max_mv_length_vertical = get_ue_golomb_long(gb);
1036  }
1037 
1038  if (get_bits_left(gb) < 1 && !alt) {
1039  // XXX: Alternate syntax when sps_range_extension_flag != 0?
1040  av_log(avctx, AV_LOG_WARNING,
1041  "Overread in VUI, retrying from timing information...\n");
1042  memcpy(vui, &backup_vui, sizeof(backup_vui));
1043  memcpy(gb, &backup, sizeof(backup));
1044  alt = 1;
1045  goto timing_info;
1046  }
1047 }
1048 
1049 static void set_default_scaling_list_data(ScalingList *sl)
1050 {
1051  int matrixId;
1052 
1053  for (matrixId = 0; matrixId < 6; matrixId++) {
1054  // 4x4 default is 16
1055  memset(sl->sl[0][matrixId], 16, 16);
1056  sl->sl_dc[0][matrixId] = 16; // default for 16x16
1057  sl->sl_dc[1][matrixId] = 16; // default for 32x32
1058  }
1059  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
1060  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
1061  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
1062  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
1063  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
1064  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
1065  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
1066  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
1067  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
1068  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
1069  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
1070  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
1071  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
1072  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
1073  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
1074  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
1075  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
1076  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
1077 }
1078 
1079 static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx,
1080  ScalingList *sl, const HEVCSPS *sps)
1081 {
1082  uint8_t scaling_list_pred_mode_flag;
1083  uint8_t scaling_list_dc_coef[2][6];
1084  int size_id, matrix_id, pos;
1085  int i;
1086 
1087  for (size_id = 0; size_id < 4; size_id++)
1088  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
1089  scaling_list_pred_mode_flag = get_bits1(gb);
1090  if (!scaling_list_pred_mode_flag) {
1091  unsigned int delta = get_ue_golomb_long(gb);
1092  /* Only need to handle non-zero delta. Zero means default,
1093  * which should already be in the arrays. */
1094  if (delta) {
1095  // Copy from previous array.
1096  delta *= (size_id == 3) ? 3 : 1;
1097  if (matrix_id < delta) {
1098  av_log(avctx, AV_LOG_ERROR,
1099  "Invalid delta in scaling list data: %d.\n", delta);
1100  return AVERROR_INVALIDDATA;
1101  }
1102 
1103  memcpy(sl->sl[size_id][matrix_id],
1104  sl->sl[size_id][matrix_id - delta],
1105  size_id > 0 ? 64 : 16);
1106  if (size_id > 1)
1107  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
1108  }
1109  } else {
1110  int next_coef, coef_num;
1111  int32_t scaling_list_delta_coef;
1112 
1113  next_coef = 8;
1114  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
1115  if (size_id > 1) {
1116  int scaling_list_coeff_minus8 = get_se_golomb(gb);
1117  if (scaling_list_coeff_minus8 < -7 ||
1118  scaling_list_coeff_minus8 > 247)
1119  return AVERROR_INVALIDDATA;
1120  scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
1121  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
1122  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
1123  }
1124  for (i = 0; i < coef_num; i++) {
1125  if (size_id == 0)
1126  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
1127  ff_hevc_diag_scan4x4_x[i];
1128  else
1129  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
1130  ff_hevc_diag_scan8x8_x[i];
1131 
1132  scaling_list_delta_coef = get_se_golomb(gb);
1133  next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
1134  sl->sl[size_id][matrix_id][pos] = next_coef;
1135  }
1136  }
1137  }
1138 
1139  if (sps->chroma_format_idc == 3) {
1140  for (i = 0; i < 64; i++) {
1141  sl->sl[3][1][i] = sl->sl[2][1][i];
1142  sl->sl[3][2][i] = sl->sl[2][2][i];
1143  sl->sl[3][4][i] = sl->sl[2][4][i];
1144  sl->sl[3][5][i] = sl->sl[2][5][i];
1145  }
1146  sl->sl_dc[1][1] = sl->sl_dc[0][1];
1147  sl->sl_dc[1][2] = sl->sl_dc[0][2];
1148  sl->sl_dc[1][4] = sl->sl_dc[0][4];
1149  sl->sl_dc[1][5] = sl->sl_dc[0][5];
1150  }
1151 
1152 
1153  return 0;
1154 }
1155 
1156 static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
1157 {
1158  const AVPixFmtDescriptor *desc;
1159  switch (sps->bit_depth) {
1160  case 8:
1161  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
1162  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
1163  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
1164  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
1165  break;
1166  case 9:
1167  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
1168  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
1169  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
1170  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
1171  break;
1172  case 10:
1173  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
1174  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
1175  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
1176  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
1177  break;
1178  case 12:
1179  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
1180  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
1181  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
1182  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
1183  break;
1184  default:
1185  av_log(avctx, AV_LOG_ERROR,
1186  "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
1187  "chroma_format_idc is %d, depth is %d\n",
1188  sps->chroma_format_idc, sps->bit_depth);
1189  return AVERROR_INVALIDDATA;
1190  }
1191 
1192  desc = av_pix_fmt_desc_get(sps->pix_fmt);
1193  if (!desc)
1194  return AVERROR(EINVAL);
1195 
1196  sps->hshift[0] = sps->vshift[0] = 0;
1197  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
1198  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
1199 
1200  sps->pixel_shift = sps->bit_depth > 8;
1201 
1202  return 0;
1203 }
1204 
1205 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
1206  unsigned nuh_layer_id, int apply_defdispwin,
1207  const HEVCVPS * const *vps_list, AVCodecContext *avctx)
1208 {
1209  HEVCWindow *ow;
1210  int ret = 0;
1211  int bit_depth_chroma, num_comps, multi_layer_ext;
1212  int vps_max_sub_layers;
1213  int i;
1214 
1215  // Coded parameters
1216 
1217  sps->vps_id = get_bits(gb, 4);
1218 
1219  if (vps_list) {
1220  if (!vps_list[sps->vps_id]) {
1221  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
1222  sps->vps_id);
1223  return AVERROR_INVALIDDATA;
1224  }
1225  sps->vps = av_refstruct_ref_c(vps_list[sps->vps_id]);
1226  }
1227 
1228  sps->max_sub_layers = get_bits(gb, 3) + 1;
1229  multi_layer_ext = nuh_layer_id > 0 &&
1230  sps->max_sub_layers == HEVC_MAX_SUB_LAYERS + 1;
1231  if (multi_layer_ext) {
1232  if (!sps->vps)
1233  return AVERROR(EINVAL);
1234 
1235  sps->max_sub_layers = sps->vps->vps_max_sub_layers;
1236  }
1237  vps_max_sub_layers = sps->vps ? sps->vps->vps_max_sub_layers
1238  : FFMIN(sps->max_sub_layers, HEVC_MAX_SUB_LAYERS);
1239 
1240  if (sps->max_sub_layers > vps_max_sub_layers) {
1241  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
1242  sps->max_sub_layers);
1243  return AVERROR_INVALIDDATA;
1244  }
1245 
1246  if (!multi_layer_ext) {
1247  sps->temporal_id_nesting = get_bits(gb, 1);
1248 
1249  if ((ret = parse_ptl(gb, avctx, 1, &sps->ptl, sps->max_sub_layers)) < 0)
1250  return ret;
1251  } else {
1252  sps->temporal_id_nesting = sps->max_sub_layers > 1 ?
1253  sps->vps->vps_max_sub_layers : 1;
1254  }
1255 
1256  *sps_id = get_ue_golomb_long(gb);
1257  if (*sps_id >= HEVC_MAX_SPS_COUNT) {
1258  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
1259  return AVERROR_INVALIDDATA;
1260  }
1261 
1262  if (multi_layer_ext) {
1263  const RepFormat *rf = &sps->vps->rep_format;
1264 
1265  if (sps->vps->nb_layers == 1) {
1266  av_log(avctx, AV_LOG_WARNING, "SPS %d references an unsupported VPS extension. Ignoring\n",
1267  *sps_id);
1268  return AVERROR(ENOSYS);
1269  }
1270 
1271  if (get_bits1(gb) && // update_rep_format_flag
1272  get_bits(gb, 8)) { // sps_rep_format_idx
1273  av_log(avctx, AV_LOG_ERROR, "sps_rep_format_idx!=0\n");
1274  return AVERROR_PATCHWELCOME;
1275  }
1276 
1277  sps->separate_colour_plane = rf->separate_colour_plane_flag;
1278  sps->chroma_format_idc = sps->separate_colour_plane ? 0 :
1279  rf->chroma_format_idc;
1280  sps->bit_depth = rf->bit_depth_luma;
1281  sps->width = rf->pic_width_in_luma_samples;
1282  sps->height = rf->pic_height_in_luma_samples;
1283 
1284  sps->pic_conf_win.left_offset = rf->conf_win_left_offset;
1285  sps->pic_conf_win.right_offset = rf->conf_win_right_offset;
1286  sps->pic_conf_win.top_offset = rf->conf_win_top_offset;
1287  sps->pic_conf_win.bottom_offset = rf->conf_win_bottom_offset;
1288 
1289  } else {
1290  sps->chroma_format_idc = get_ue_golomb_long(gb);
1291  if (sps->chroma_format_idc > 3U) {
1292  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
1293  return AVERROR_INVALIDDATA;
1294  }
1295 
1296  if (sps->chroma_format_idc == 3)
1297  sps->separate_colour_plane = get_bits1(gb);
1298 
1299  if (sps->separate_colour_plane)
1300  sps->chroma_format_idc = 0;
1301 
1302  sps->width = get_ue_golomb_long(gb);
1303  sps->height = get_ue_golomb_long(gb);
1304  if ((ret = av_image_check_size(sps->width,
1305  sps->height, 0, avctx)) < 0)
1306  return ret;
1307 
1308  sps->conformance_window = get_bits1(gb);
1309  if (sps->conformance_window) {
1310  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
1311  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
1312  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
1313  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
1314  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
1315  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
1316 
1317  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
1318  av_log(avctx, AV_LOG_DEBUG,
1319  "discarding sps conformance window, "
1320  "original values are l:%u r:%u t:%u b:%u\n",
1321  sps->pic_conf_win.left_offset,
1322  sps->pic_conf_win.right_offset,
1323  sps->pic_conf_win.top_offset,
1324  sps->pic_conf_win.bottom_offset);
1325 
1326  sps->pic_conf_win.left_offset =
1327  sps->pic_conf_win.right_offset =
1328  sps->pic_conf_win.top_offset =
1329  sps->pic_conf_win.bottom_offset = 0;
1330  }
1331  }
1332 
1333  sps->bit_depth = get_ue_golomb_31(gb) + 8;
1334  if (sps->bit_depth > 16) {
1335  av_log(avctx, AV_LOG_ERROR, "Luma bit depth (%d) is out of range\n",
1336  sps->bit_depth);
1337  return AVERROR_INVALIDDATA;
1338  }
1339  bit_depth_chroma = get_ue_golomb_31(gb) + 8;
1340  if (bit_depth_chroma > 16) {
1341  av_log(avctx, AV_LOG_ERROR, "Chroma bit depth (%d) is out of range\n",
1342  bit_depth_chroma);
1343  return AVERROR_INVALIDDATA;
1344  }
1345  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
1346  av_log(avctx, AV_LOG_ERROR,
1347  "Luma bit depth (%d) is different from chroma bit depth (%d), "
1348  "this is unsupported.\n",
1349  sps->bit_depth, bit_depth_chroma);
1350  return AVERROR_INVALIDDATA;
1351  }
1352  sps->bit_depth_chroma = bit_depth_chroma;
1353  }
1354 
1355  sps->output_window = sps->pic_conf_win;
1356 
1357  ret = map_pixel_format(avctx, sps);
1358  if (ret < 0)
1359  return ret;
1360 
1361  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
1362  if (sps->log2_max_poc_lsb > 16) {
1363  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
1364  sps->log2_max_poc_lsb - 4);
1365  return AVERROR_INVALIDDATA;
1366  }
1367 
1368  if (!multi_layer_ext) {
1369  int start;
1370 
1371  sps->sublayer_ordering_info = get_bits1(gb);
1372  start = sps->sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
1373  for (i = start; i < sps->max_sub_layers; i++) {
1374  sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
1375  sps->temporal_layer[i].num_reorder_pics = get_ue_golomb_long(gb);
1376  sps->temporal_layer[i].max_latency_increase = get_ue_golomb_long(gb) - 1;
1377  if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
1378  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
1379  sps->temporal_layer[i].max_dec_pic_buffering - 1U);
1380  return AVERROR_INVALIDDATA;
1381  }
1382  if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
1383  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
1384  sps->temporal_layer[i].num_reorder_pics);
1385  if (avctx->err_recognition & AV_EF_EXPLODE ||
1386  sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
1387  return AVERROR_INVALIDDATA;
1388  }
1389  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
1390  }
1391  }
1392 
1393  if (!sps->sublayer_ordering_info) {
1394  for (i = 0; i < start; i++) {
1395  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
1396  sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics;
1397  sps->temporal_layer[i].max_latency_increase = sps->temporal_layer[start].max_latency_increase;
1398  }
1399  }
1400  } else {
1401  for (int i = 0; i < sps->max_sub_layers; i++) {
1402  sps->temporal_layer[i].max_dec_pic_buffering = sps->vps->dpb_size.max_dec_pic_buffering;
1403  sps->temporal_layer[i].num_reorder_pics = sps->vps->dpb_size.max_num_reorder_pics;
1404  sps->temporal_layer[i].max_latency_increase = sps->vps->dpb_size.max_latency_increase;
1405  }
1406  }
1407 
1408  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
1409  sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);
1410  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
1411  sps->log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
1412  sps->log2_max_trafo_size = sps->log2_diff_max_min_transform_block_size +
1413  sps->log2_min_tb_size;
1414 
1415  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1416  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1417  return AVERROR_INVALIDDATA;
1418  }
1419 
1420  if (sps->log2_diff_max_min_coding_block_size > 30) {
1421  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_coding_block_size", sps->log2_diff_max_min_coding_block_size);
1422  return AVERROR_INVALIDDATA;
1423  }
1424 
1425  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1426  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1427  return AVERROR_INVALIDDATA;
1428  }
1429 
1430  if (sps->log2_diff_max_min_transform_block_size > 30) {
1431  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size",
1432  sps->log2_diff_max_min_transform_block_size);
1433  return AVERROR_INVALIDDATA;
1434  }
1435 
1436  sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
1437  sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
1438 
1439  sps->scaling_list_enabled = get_bits1(gb);
1440  if (sps->scaling_list_enabled) {
1441  set_default_scaling_list_data(&sps->scaling_list);
1442 
1443  if (multi_layer_ext && get_bits1(gb)) { // sps_infer_scaling_list_flag
1444  av_log(avctx, AV_LOG_ERROR, "sps_infer_scaling_list_flag=1 not supported\n");
1445  return AVERROR_PATCHWELCOME;
1446  }
1447 
1448  if (get_bits1(gb)) {
1449  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1450  if (ret < 0)
1451  return ret;
1452  }
1453  }
1454 
1455  sps->amp_enabled = get_bits1(gb);
1456  sps->sao_enabled = get_bits1(gb);
1457 
1458  sps->pcm_enabled = get_bits1(gb);
1459  if (sps->pcm_enabled) {
1460  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1461  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1462  sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
1463  sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
1464  get_ue_golomb_long(gb);
1465  if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1466  av_log(avctx, AV_LOG_ERROR,
1467  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1468  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1469  return AVERROR_INVALIDDATA;
1470  }
1471 
1472  sps->pcm_loop_filter_disabled = get_bits1(gb);
1473  }
1474 
1475  sps->nb_st_rps = get_ue_golomb_long(gb);
1476  if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {
1477  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1478  sps->nb_st_rps);
1479  return AVERROR_INVALIDDATA;
1480  }
1481  for (i = 0; i < sps->nb_st_rps; i++) {
1482  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1483  sps, 0)) < 0)
1484  return ret;
1485  }
1486 
1487  sps->long_term_ref_pics_present = get_bits1(gb);
1488  if (sps->long_term_ref_pics_present) {
1489  sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
1490  if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) {
1491  av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1492  sps->num_long_term_ref_pics_sps);
1493  return AVERROR_INVALIDDATA;
1494  }
1495 
1496  sps->used_by_curr_pic_lt = 0;
1497  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1498  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1499  sps->used_by_curr_pic_lt |= get_bits1(gb) << i;
1500  }
1501  }
1502 
1503  sps->temporal_mvp_enabled = get_bits1(gb);
1504  sps->strong_intra_smoothing_enabled = get_bits1(gb);
1505  sps->vui.common.sar = (AVRational){0, 1};
1506  sps->vui_present = get_bits1(gb);
1507  if (sps->vui_present)
1508  decode_vui(gb, avctx, apply_defdispwin, sps);
1509 
1510  sps->extension_present = get_bits1(gb);
1511  if (sps->extension_present) {
1512  sps->range_extension = get_bits1(gb);
1513  sps->multilayer_extension = get_bits1(gb);
1514  sps->sps_3d_extension = get_bits1(gb);
1515  sps->scc_extension = get_bits1(gb);
1516  skip_bits(gb, 4); // sps_extension_4bits
1517 
1518  if (sps->range_extension) {
1519  sps->transform_skip_rotation_enabled = get_bits1(gb);
1520  sps->transform_skip_context_enabled = get_bits1(gb);
1521  sps->implicit_rdpcm_enabled = get_bits1(gb);
1522  sps->explicit_rdpcm_enabled = get_bits1(gb);
1523 
1524  sps->extended_precision_processing = get_bits1(gb);
1525  if (sps->extended_precision_processing)
1526  av_log(avctx, AV_LOG_WARNING,
1527  "extended_precision_processing_flag not yet implemented\n");
1528 
1529  sps->intra_smoothing_disabled = get_bits1(gb);
1530  sps->high_precision_offsets_enabled = get_bits1(gb);
1531  if (sps->high_precision_offsets_enabled)
1532  av_log(avctx, AV_LOG_WARNING,
1533  "high_precision_offsets_enabled_flag not yet implemented\n");
1534 
1535  sps->persistent_rice_adaptation_enabled = get_bits1(gb);
1536 
1537  sps->cabac_bypass_alignment_enabled = get_bits1(gb);
1538  if (sps->cabac_bypass_alignment_enabled)
1539  av_log(avctx, AV_LOG_WARNING,
1540  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1541  }
1542 
1543  if (sps->multilayer_extension) {
1544  skip_bits1(gb); // inter_view_mv_vert_constraint_flag
1545  }
1546 
1547  if (sps->sps_3d_extension) {
1548  for (i = 0; i <= 1; i++) {
1549  skip_bits1(gb); // iv_di_mc_enabled_flag
1550  skip_bits1(gb); // iv_mv_scal_enabled_flag
1551  if (i == 0) {
1552  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1553  skip_bits1(gb); // iv_res_pred_enabled_flag
1554  skip_bits1(gb); // depth_ref_enabled_flag
1555  skip_bits1(gb); // vsp_mc_enabled_flag
1556  skip_bits1(gb); // dbbp_enabled_flag
1557  } else {
1558  skip_bits1(gb); // tex_mc_enabled_flag
1559  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1560  skip_bits1(gb); // intra_contour_enabled_flag
1561  skip_bits1(gb); // intra_dc_only_wedge_enabled_flag
1562  skip_bits1(gb); // cqt_cu_part_pred_enabled_flag
1563  skip_bits1(gb); // inter_dc_only_enabled_flag
1564  skip_bits1(gb); // skip_intra_enabled_flag
1565  }
1566  }
1567  av_log(avctx, AV_LOG_WARNING,
1568  "sps_3d_extension_flag not yet implemented\n");
1569  }
1570 
1571  if (sps->scc_extension) {
1572  sps->curr_pic_ref_enabled = get_bits1(gb);
1573  sps->palette_mode_enabled = get_bits1(gb);
1574  if (sps->palette_mode_enabled) {
1575  sps->palette_max_size = get_ue_golomb(gb);
1576  sps->delta_palette_max_predictor_size = get_ue_golomb(gb);
1577  sps->palette_predictor_initializers_present = get_bits1(gb);
1578 
1579  if (sps->palette_predictor_initializers_present) {
1580  sps->sps_num_palette_predictor_initializers = get_ue_golomb(gb) + 1;
1581  if (sps->sps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1582  av_log(avctx, AV_LOG_ERROR,
1583  "sps_num_palette_predictor_initializers out of range: %u\n",
1584  sps->sps_num_palette_predictor_initializers);
1585  return AVERROR_INVALIDDATA;
1586  }
1587  num_comps = !sps->chroma_format_idc ? 1 : 3;
1588  for (int comp = 0; comp < num_comps; comp++) {
1589  int bit_depth = !comp ? sps->bit_depth : sps->bit_depth_chroma;
1590  for (i = 0; i < sps->sps_num_palette_predictor_initializers; i++)
1591  sps->sps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
1592  }
1593  }
1594  }
1595  sps->motion_vector_resolution_control_idc = get_bits(gb, 2);
1596  sps->intra_boundary_filtering_disabled = get_bits1(gb);
1597  }
1598  }
1599  if (apply_defdispwin) {
1600  sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
1601  sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;
1602  sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;
1603  sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
1604  }
1605 
1606  ow = &sps->output_window;
1607  if (ow->left_offset >= INT_MAX - ow->right_offset ||
1608  ow->top_offset >= INT_MAX - ow->bottom_offset ||
1609  ow->left_offset + ow->right_offset >= sps->width ||
1610  ow->top_offset + ow->bottom_offset >= sps->height) {
1611  av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
1612  ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1613  if (avctx->err_recognition & AV_EF_EXPLODE) {
1614  return AVERROR_INVALIDDATA;
1615  }
1616  av_log(avctx, AV_LOG_WARNING,
1617  "Displaying the whole video surface.\n");
1618  memset(ow, 0, sizeof(*ow));
1619  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1620  }
1621 
1622  // Inferred parameters
1623  sps->log2_ctb_size = sps->log2_min_cb_size +
1624  sps->log2_diff_max_min_coding_block_size;
1625  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1626 
1627  if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {
1628  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1629  return AVERROR_INVALIDDATA;
1630  }
1631  if (sps->log2_ctb_size < 4) {
1632  av_log(avctx,
1633  AV_LOG_ERROR,
1634  "log2_ctb_size %d differs from the bounds of any known profile\n",
1635  sps->log2_ctb_size);
1636  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1637  return AVERROR_INVALIDDATA;
1638  }
1639 
1640  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1641  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1642  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1643 
1644  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1645  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1646  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1647  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1648  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1649  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1650  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1651 
1652  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1653 
1654  if (av_zero_extend(sps->width, sps->log2_min_cb_size) ||
1655  av_zero_extend(sps->height, sps->log2_min_cb_size)) {
1656  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1657  return AVERROR_INVALIDDATA;
1658  }
1659 
1660  if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) {
1661  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1662  sps->max_transform_hierarchy_depth_inter);
1663  return AVERROR_INVALIDDATA;
1664  }
1665  if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) {
1666  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1667  sps->max_transform_hierarchy_depth_intra);
1668  return AVERROR_INVALIDDATA;
1669  }
1670  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1671  av_log(avctx, AV_LOG_ERROR,
1672  "max transform block size out of range: %d\n",
1673  sps->log2_max_trafo_size);
1674  return AVERROR_INVALIDDATA;
1675  }
1676 
1677  if (get_bits_left(gb) < 0) {
1678  av_log(avctx, AV_LOG_ERROR,
1679  "Overread SPS by %d bits\n", -get_bits_left(gb));
1680  return AVERROR_INVALIDDATA;
1681  }
1682 
1683  return 0;
1684 }
1685 
1686 static void hevc_sps_free(AVRefStructOpaque opaque, void *obj)
1687 {
1688  HEVCSPS *sps = obj;
1689 
1690  av_refstruct_unref(&sps->vps);
1691 
1692  av_freep(&sps->data);
1693 }
1694 
1695 static int compare_sps(const HEVCSPS *sps1, const HEVCSPS *sps2)
1696 {
1697  return sps1->data_size == sps2->data_size &&
1698  !memcmp(sps1->data, sps2->data, sps1->data_size);
1699 }
1700 
1701 int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
1702  HEVCParamSets *ps, unsigned nuh_layer_id,
1703  int apply_defdispwin)
1704 {
1705  HEVCSPS *sps = av_refstruct_alloc_ext(sizeof(*sps), 0, NULL, hevc_sps_free);
1706  unsigned int sps_id;
1707  int ret;
1708 
1709  if (!sps)
1710  return AVERROR(ENOMEM);
1711 
1712  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1713 
1714  sps->data_size = get_bits_bytesize(gb, 1);
1715  sps->data = av_memdup(gb->buffer, sps->data_size);
1716  if (!sps->data) {
1717  ret = AVERROR(ENOMEM);
1718  goto err;
1719  }
1720 
1721  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1722  nuh_layer_id, apply_defdispwin,
1723  ps->vps_list, avctx);
1724  if (ret < 0)
1725  goto err;
1726 
1727  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1728  av_log(avctx, AV_LOG_DEBUG,
1729  "Parsed SPS: id %d; coded wxh: %dx%d; "
1730  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1731  sps_id, sps->width, sps->height,
1732  sps->width - (sps->output_window.left_offset + sps->output_window.right_offset),
1733  sps->height - (sps->output_window.top_offset + sps->output_window.bottom_offset),
1734  av_get_pix_fmt_name(sps->pix_fmt));
1735  }
1736 
1737  /* check if this is a repeat of an already parsed SPS, then keep the
1738  * original one.
1739  * otherwise drop all PPSes that depend on it */
1740  if (ps->sps_list[sps_id] &&
1741  compare_sps(ps->sps_list[sps_id], sps)) {
1742  av_refstruct_unref(&sps);
1743  } else {
1744  remove_sps(ps, sps_id);
1745  ps->sps_list[sps_id] = sps;
1746  }
1747 
1748  return 0;
1749 err:
1750  av_refstruct_unref(&sps);
1751  return ret;
1752 }
1753 
1754 static void hevc_pps_free(AVRefStructOpaque unused, void *obj)
1755 {
1756  HEVCPPS *pps = obj;
1757 
1758  av_refstruct_unref(&pps->sps);
1759 
1760  av_freep(&pps->column_width);
1761  av_freep(&pps->row_height);
1762  av_freep(&pps->col_bd);
1763  av_freep(&pps->row_bd);
1764  av_freep(&pps->col_idxX);
1765  av_freep(&pps->ctb_addr_rs_to_ts);
1766  av_freep(&pps->ctb_addr_ts_to_rs);
1767  av_freep(&pps->tile_pos_rs);
1768  av_freep(&pps->tile_id);
1769  av_freep(&pps->min_tb_addr_zs_tab);
1770  av_freep(&pps->data);
1771 }
1772 
1773 static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
1774  int idx_y, int idx_cb, int idx_cr, int inp_length)
1775 {
1776  unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1777  int cm_res_bits;
1778 
1779  part_num_y = 1 << pps->cm_y_part_num_log2;
1780 
1781  split_octant_flag = inp_depth < pps->cm_octant_depth ? get_bits1(gb) : 0;
1782 
1783  if (split_octant_flag)
1784  for (int k = 0; k < 2; k++)
1785  for (int m = 0; m < 2; m++)
1786  for (int n = 0; n < 2; n++)
1787  colour_mapping_octants(gb, pps, inp_depth + 1,
1788  idx_y + part_num_y * k * inp_length / 2,
1789  idx_cb + m * inp_length / 2,
1790  idx_cr + n * inp_length / 2,
1791  inp_length / 2);
1792  else
1793  for (int i = 0; i < part_num_y; i++) {
1794  for (int j = 0; j < 4; j++) {
1795  coded_res_flag = get_bits1(gb);
1796  if (coded_res_flag)
1797  for (int c = 0; c < 3; c++) {
1798  res_coeff_q = get_ue_golomb_long(gb);
1799  cm_res_bits = FFMAX(0, 10 + pps->luma_bit_depth_cm_input -
1800  pps->luma_bit_depth_cm_output -
1801  pps->cm_res_quant_bits - pps->cm_delta_flc_bits);
1802  res_coeff_r = cm_res_bits ? get_bits(gb, cm_res_bits) : 0;
1803  if (res_coeff_q || res_coeff_r)
1804  skip_bits1(gb);
1805  }
1806  }
1807  }
1808 }
1809 
1810 static int colour_mapping_table(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps)
1811 {
1812  pps->num_cm_ref_layers = get_ue_golomb(gb) + 1;
1813  if (pps->num_cm_ref_layers > 62) {
1814  av_log(avctx, AV_LOG_ERROR,
1815  "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1816  return AVERROR_INVALIDDATA;
1817  }
1818  for (int i = 0; i < pps->num_cm_ref_layers; i++)
1819  pps->cm_ref_layer_id[i] = get_bits(gb, 6);
1820 
1821  pps->cm_octant_depth = get_bits(gb, 2);
1822  pps->cm_y_part_num_log2 = get_bits(gb, 2);
1823 
1824  pps->luma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1825  pps->chroma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1826  pps->luma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1827  pps->chroma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1828 
1829  pps->cm_res_quant_bits = get_bits(gb, 2);
1830  pps->cm_delta_flc_bits = get_bits(gb, 2) + 1;
1831 
1832  if (pps->cm_octant_depth == 1) {
1833  pps->cm_adapt_threshold_u_delta = get_se_golomb_long(gb);
1834  pps->cm_adapt_threshold_v_delta = get_se_golomb_long(gb);
1835  }
1836 
1837  colour_mapping_octants(gb, pps, 0, 0, 0, 0, 1 << pps->cm_octant_depth);
1838 
1839  return 0;
1840 }
1841 
1842 static int pps_multilayer_extension(GetBitContext *gb, AVCodecContext *avctx,
1843  HEVCPPS *pps, const HEVCSPS *sps, const HEVCVPS *vps)
1844 {
1845  pps->poc_reset_info_present_flag = get_bits1(gb);
1846  pps->pps_infer_scaling_list_flag = get_bits1(gb);
1847  if (pps->pps_infer_scaling_list_flag)
1848  pps->pps_scaling_list_ref_layer_id = get_bits(gb, 6);
1849 
1850  pps->num_ref_loc_offsets = get_ue_golomb(gb);
1851  if (pps->num_ref_loc_offsets > vps->vps_max_layers - 1)
1852  return AVERROR_INVALIDDATA;
1853 
1854  for (int i = 0; i < pps->num_ref_loc_offsets; i++) {
1855  pps->ref_loc_offset_layer_id[i] = get_bits(gb, 6);
1856  pps->scaled_ref_layer_offset_present_flag[i] = get_bits1(gb);
1857  if (pps->scaled_ref_layer_offset_present_flag[i]) {
1858  pps->scaled_ref_layer_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1859  pps->scaled_ref_layer_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1860  pps->scaled_ref_layer_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1861  pps->scaled_ref_layer_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1862  }
1863 
1864  pps->ref_region_offset_present_flag[i] = get_bits1(gb);
1865  if (pps->ref_region_offset_present_flag[i]) {
1866  pps->ref_region_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1867  pps->ref_region_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1868  pps->ref_region_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1869  pps->ref_region_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1870  }
1871 
1872  pps->resample_phase_set_present_flag[i] = get_bits1(gb);
1873  if (pps->resample_phase_set_present_flag[i]) {
1874  pps->phase_hor_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1875  pps->phase_ver_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1876  pps->phase_hor_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1877  pps->phase_ver_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1878  }
1879  }
1880 
1881  pps->colour_mapping_enabled_flag = get_bits1(gb);
1882  if (pps->colour_mapping_enabled_flag) {
1883  int ret = colour_mapping_table(gb, avctx, pps);
1884  if (ret < 0)
1885  return ret;
1886  }
1887 
1888  return 0;
1889 }
1890 
1891 static void delta_dlt(GetBitContext *gb, HEVCPPS *pps)
1892 {
1893  unsigned int num_val_delta_dlt, max_diff = 0;
1894  int min_diff_minus1 = -1;
1895  unsigned int len;
1896 
1897  num_val_delta_dlt = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1898  if (num_val_delta_dlt) {
1899  if (num_val_delta_dlt > 1)
1900  max_diff = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1901  if (num_val_delta_dlt > 2 && max_diff) {
1902  len = av_log2(max_diff) + 1;
1903  min_diff_minus1 = get_bits(gb, len);
1904  }
1905  if (max_diff > (min_diff_minus1 + 1))
1906  for (int k = 1; k < num_val_delta_dlt; k++) {
1907  len = av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1908  skip_bits(gb, len); // delta_val_diff_minus_min
1909  }
1910  }
1911 }
1912 
1913 static int pps_3d_extension(GetBitContext *gb, AVCodecContext *avctx,
1914  HEVCPPS *pps, const HEVCSPS *sps)
1915 {
1916  unsigned int pps_depth_layers_minus1;
1917 
1918  if (get_bits1(gb)) { // dlts_present_flag
1919  pps_depth_layers_minus1 = get_bits(gb, 6);
1920  pps->pps_bit_depth_for_depth_layers_minus8 = get_bits(gb, 4);
1921  for (int i = 0; i <= pps_depth_layers_minus1; i++) {
1922  if (get_bits1(gb)) { // dlt_flag[i]
1923  if (!get_bits1(gb)) { // dlt_pred_flag[i]
1924  if (get_bits1(gb)) { // dlt_val_flags_present_flag[i]
1925  for (int j = 0; j <= ((1 << (pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1926  skip_bits1(gb); // dlt_value_flag[i][j]
1927  } else
1928  delta_dlt(gb, pps);
1929  }
1930  }
1931  }
1932  }
1933 
1934  return 0;
1935 }
1936 
1937 static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
1938  HEVCPPS *pps, const HEVCSPS *sps)
1939 {
1940  if (pps->transform_skip_enabled_flag) {
1941  pps->log2_max_transform_skip_block_size = get_ue_golomb_31(gb) + 2;
1942  }
1943  pps->cross_component_prediction_enabled_flag = get_bits1(gb);
1944  pps->chroma_qp_offset_list_enabled_flag = get_bits1(gb);
1945  if (pps->chroma_qp_offset_list_enabled_flag) {
1946  pps->diff_cu_chroma_qp_offset_depth = get_ue_golomb_31(gb);
1947  pps->chroma_qp_offset_list_len_minus1 = get_ue_golomb_31(gb);
1948  if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1949  av_log(avctx, AV_LOG_ERROR,
1950  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1951  return AVERROR_INVALIDDATA;
1952  }
1953  for (int i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1954  pps->cb_qp_offset_list[i] = get_se_golomb(gb);
1955  if (pps->cb_qp_offset_list[i]) {
1956  av_log(avctx, AV_LOG_WARNING,
1957  "cb_qp_offset_list not tested yet.\n");
1958  }
1959  pps->cr_qp_offset_list[i] = get_se_golomb(gb);
1960  if (pps->cr_qp_offset_list[i]) {
1961  av_log(avctx, AV_LOG_WARNING,
1962  "cb_qp_offset_list not tested yet.\n");
1963  }
1964  }
1965  }
1966  pps->log2_sao_offset_scale_luma = get_ue_golomb_31(gb);
1967  pps->log2_sao_offset_scale_chroma = get_ue_golomb_31(gb);
1968 
1969  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1970  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1971  )
1972  return AVERROR_INVALIDDATA;
1973 
1974  return(0);
1975 }
1976 
1977 static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx,
1978  HEVCPPS *pps, const HEVCSPS *sps)
1979 {
1980  int num_comps, ret;
1981 
1982  pps->pps_curr_pic_ref_enabled_flag = get_bits1(gb);
1983  if (pps->residual_adaptive_colour_transform_enabled_flag = get_bits1(gb)) {
1984  pps->pps_slice_act_qp_offsets_present_flag = get_bits1(gb);
1985  pps->pps_act_y_qp_offset = get_se_golomb(gb) - 5;
1986  pps->pps_act_cb_qp_offset = get_se_golomb(gb) - 5;
1987  pps->pps_act_cr_qp_offset = get_se_golomb(gb) - 3;
1988 
1989 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1990  pps->pps_act_ ## name ## _qp_offset >= 12)
1991  ret = CHECK_QP_OFFSET(y) || CHECK_QP_OFFSET(cb) || CHECK_QP_OFFSET(cr);
1992 #undef CHECK_QP_OFFSET
1993  if (ret) {
1994  av_log(avctx, AV_LOG_ERROR,
1995  "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1996  return AVERROR_INVALIDDATA;
1997  }
1998  }
1999 
2000  if (pps->pps_palette_predictor_initializers_present_flag = get_bits1(gb)) {
2001  pps->pps_num_palette_predictor_initializers = get_ue_golomb(gb);
2002  if (pps->pps_num_palette_predictor_initializers > 0) {
2003  if (pps->pps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
2004  av_log(avctx, AV_LOG_ERROR,
2005  "pps_num_palette_predictor_initializers out of range: %u\n",
2006  pps->pps_num_palette_predictor_initializers);
2007  return AVERROR_INVALIDDATA;
2008  }
2009  pps->monochrome_palette_flag = get_bits1(gb);
2010  pps->luma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
2011  if (pps->luma_bit_depth_entry != sps->bit_depth)
2012  return AVERROR_INVALIDDATA;
2013  if (!pps->monochrome_palette_flag) {
2014  pps->chroma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
2015  if (pps->chroma_bit_depth_entry != sps->bit_depth_chroma)
2016  return AVERROR_INVALIDDATA;
2017  }
2018 
2019  num_comps = pps->monochrome_palette_flag ? 1 : 3;
2020  for (int comp = 0; comp < num_comps; comp++) {
2021  int bit_depth = !comp ? pps->luma_bit_depth_entry : pps->chroma_bit_depth_entry;
2022  for (int i = 0; i < pps->pps_num_palette_predictor_initializers; i++)
2023  pps->pps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
2024  }
2025  }
2026  }
2027 
2028  return 0;
2029 }
2030 
2031 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
2032  HEVCPPS *pps, const HEVCSPS *sps)
2033 {
2034  int log2_diff;
2035  int pic_area_in_ctbs;
2036  int i, j, x, y, ctb_addr_rs, tile_id;
2037 
2038  // Inferred parameters
2039  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
2040  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
2041  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
2042  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
2043  return AVERROR(ENOMEM);
2044 
2045  if (pps->uniform_spacing_flag) {
2046  if (!pps->column_width) {
2047  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
2048  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
2049  }
2050  if (!pps->column_width || !pps->row_height)
2051  return AVERROR(ENOMEM);
2052 
2053  for (i = 0; i < pps->num_tile_columns; i++) {
2054  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
2055  (i * sps->ctb_width) / pps->num_tile_columns;
2056  }
2057 
2058  for (i = 0; i < pps->num_tile_rows; i++) {
2059  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
2060  (i * sps->ctb_height) / pps->num_tile_rows;
2061  }
2062  }
2063 
2064  pps->col_bd[0] = 0;
2065  for (i = 0; i < pps->num_tile_columns; i++)
2066  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
2067 
2068  pps->row_bd[0] = 0;
2069  for (i = 0; i < pps->num_tile_rows; i++)
2070  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
2071 
2072  for (i = 0, j = 0; i < sps->ctb_width; i++) {
2073  if (i > pps->col_bd[j])
2074  j++;
2075  pps->col_idxX[i] = j;
2076  }
2077 
2078  /**
2079  * 6.5
2080  */
2081  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
2082 
2083  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
2084  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
2085  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
2086  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
2087  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
2088  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
2089  return AVERROR(ENOMEM);
2090  }
2091 
2092  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
2093  int tb_x = ctb_addr_rs % sps->ctb_width;
2094  int tb_y = ctb_addr_rs / sps->ctb_width;
2095  int tile_x = 0;
2096  int tile_y = 0;
2097  int val = 0;
2098 
2099  for (i = 0; i < pps->num_tile_columns; i++) {
2100  if (tb_x < pps->col_bd[i + 1]) {
2101  tile_x = i;
2102  break;
2103  }
2104  }
2105 
2106  for (i = 0; i < pps->num_tile_rows; i++) {
2107  if (tb_y < pps->row_bd[i + 1]) {
2108  tile_y = i;
2109  break;
2110  }
2111  }
2112 
2113  for (i = 0; i < tile_x; i++)
2114  val += pps->row_height[tile_y] * pps->column_width[i];
2115  for (i = 0; i < tile_y; i++)
2116  val += sps->ctb_width * pps->row_height[i];
2117 
2118  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
2119  tb_x - pps->col_bd[tile_x];
2120 
2121  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
2122  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
2123  }
2124 
2125  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
2126  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
2127  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
2128  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
2129  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
2130 
2131  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
2132  if (!pps->tile_pos_rs)
2133  return AVERROR(ENOMEM);
2134 
2135  for (j = 0; j < pps->num_tile_rows; j++)
2136  for (i = 0; i < pps->num_tile_columns; i++)
2137  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
2138  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
2139 
2140  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
2141  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
2142  for (y = 0; y < sps->tb_mask+2; y++) {
2143  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
2144  pps->min_tb_addr_zs_tab[y] = -1;
2145  }
2146  for (y = 0; y < sps->tb_mask+1; y++) {
2147  for (x = 0; x < sps->tb_mask+1; x++) {
2148  int tb_x = x >> log2_diff;
2149  int tb_y = y >> log2_diff;
2150  int rs = sps->ctb_width * tb_y + tb_x;
2151  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
2152  for (i = 0; i < log2_diff; i++) {
2153  int m = 1 << i;
2154  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
2155  }
2156  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
2157  }
2158  }
2159 
2160  return 0;
2161 }
2162 
2163 int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
2164  HEVCParamSets *ps)
2165 {
2166  const HEVCSPS *sps = NULL;
2167  const HEVCVPS *vps = NULL;
2168  int i, ret = 0;
2169  ptrdiff_t nal_size = get_bits_bytesize(gb, 1);
2170  unsigned int pps_id = get_ue_golomb_long(gb);
2171  unsigned log2_parallel_merge_level_minus2;
2172  HEVCPPS *pps;
2173 
2174  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
2175 
2176  if (pps_id >= HEVC_MAX_PPS_COUNT) {
2177  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
2178  return AVERROR_INVALIDDATA;
2179  }
2180 
2181  if (ps->pps_list[pps_id]) {
2182  const HEVCPPS *pps1 = ps->pps_list[pps_id];
2183  if (pps1->data_size == nal_size &&
2184  !memcmp(pps1->data, gb->buffer, pps1->data_size))
2185  return 0;
2186  }
2187 
2188  pps = av_refstruct_alloc_ext(sizeof(*pps), 0, NULL, hevc_pps_free);
2189  if (!pps)
2190  return AVERROR(ENOMEM);
2191 
2192  pps->data_size = nal_size;
2193  pps->data = av_memdup(gb->buffer, nal_size);
2194  if (!pps->data) {
2195  ret = AVERROR_INVALIDDATA;
2196  goto err;
2197  }
2198 
2199  // Default values
2200  pps->loop_filter_across_tiles_enabled_flag = 1;
2201  pps->num_tile_columns = 1;
2202  pps->num_tile_rows = 1;
2203  pps->uniform_spacing_flag = 1;
2204  pps->disable_dbf = 0;
2205  pps->beta_offset = 0;
2206  pps->tc_offset = 0;
2207  pps->log2_max_transform_skip_block_size = 2;
2208 
2209  // Coded parameters
2210  pps->pps_id = pps_id;
2211  pps->sps_id = get_ue_golomb_long(gb);
2212  if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
2213  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
2214  ret = AVERROR_INVALIDDATA;
2215  goto err;
2216  }
2217  if (!ps->sps_list[pps->sps_id]) {
2218  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
2219  ret = AVERROR_INVALIDDATA;
2220  goto err;
2221  }
2222  sps = ps->sps_list[pps->sps_id];
2223  vps = ps->vps_list[sps->vps_id];
2224 
2225  pps->sps = av_refstruct_ref_c(sps);
2226 
2227  pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
2228  pps->output_flag_present_flag = get_bits1(gb);
2229  pps->num_extra_slice_header_bits = get_bits(gb, 3);
2230 
2231  pps->sign_data_hiding_flag = get_bits1(gb);
2232 
2233  pps->cabac_init_present_flag = get_bits1(gb);
2234 
2235  pps->num_ref_idx_l0_default_active = get_ue_golomb_31(gb) + 1;
2236  pps->num_ref_idx_l1_default_active = get_ue_golomb_31(gb) + 1;
2237  if (pps->num_ref_idx_l0_default_active >= HEVC_MAX_REFS ||
2238  pps->num_ref_idx_l1_default_active >= HEVC_MAX_REFS) {
2239  av_log(avctx, AV_LOG_ERROR, "Too many default refs in PPS: %d/%d.\n",
2240  pps->num_ref_idx_l0_default_active, pps->num_ref_idx_l1_default_active);
2241  goto err;
2242  }
2243 
2244  pps->pic_init_qp_minus26 = get_se_golomb(gb);
2245 
2246  pps->constrained_intra_pred_flag = get_bits1(gb);
2247  pps->transform_skip_enabled_flag = get_bits1(gb);
2248 
2249  pps->cu_qp_delta_enabled_flag = get_bits1(gb);
2250  pps->diff_cu_qp_delta_depth = 0;
2251  if (pps->cu_qp_delta_enabled_flag)
2252  pps->diff_cu_qp_delta_depth = get_ue_golomb_long(gb);
2253 
2254  if (pps->diff_cu_qp_delta_depth < 0 ||
2255  pps->diff_cu_qp_delta_depth > sps->log2_diff_max_min_coding_block_size) {
2256  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
2257  pps->diff_cu_qp_delta_depth);
2258  ret = AVERROR_INVALIDDATA;
2259  goto err;
2260  }
2261 
2262  pps->cb_qp_offset = get_se_golomb(gb);
2263  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
2264  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
2265  pps->cb_qp_offset);
2266  ret = AVERROR_INVALIDDATA;
2267  goto err;
2268  }
2269  pps->cr_qp_offset = get_se_golomb(gb);
2270  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
2271  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
2272  pps->cr_qp_offset);
2273  ret = AVERROR_INVALIDDATA;
2274  goto err;
2275  }
2276  pps->pic_slice_level_chroma_qp_offsets_present_flag = get_bits1(gb);
2277 
2278  pps->weighted_pred_flag = get_bits1(gb);
2279  pps->weighted_bipred_flag = get_bits1(gb);
2280 
2281  pps->transquant_bypass_enable_flag = get_bits1(gb);
2282  pps->tiles_enabled_flag = get_bits1(gb);
2283  pps->entropy_coding_sync_enabled_flag = get_bits1(gb);
2284 
2285  if (pps->tiles_enabled_flag) {
2286  int num_tile_columns_minus1 = get_ue_golomb(gb);
2287  int num_tile_rows_minus1 = get_ue_golomb(gb);
2288 
2289  if (num_tile_columns_minus1 < 0 ||
2290  num_tile_columns_minus1 >= sps->ctb_width) {
2291  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
2292  num_tile_columns_minus1);
2293  ret = num_tile_columns_minus1 < 0 ? num_tile_columns_minus1 : AVERROR_INVALIDDATA;
2294  goto err;
2295  }
2296  if (num_tile_rows_minus1 < 0 ||
2297  num_tile_rows_minus1 >= sps->ctb_height) {
2298  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
2299  num_tile_rows_minus1);
2300  ret = num_tile_rows_minus1 < 0 ? num_tile_rows_minus1 : AVERROR_INVALIDDATA;
2301  goto err;
2302  }
2303  pps->num_tile_columns = num_tile_columns_minus1 + 1;
2304  pps->num_tile_rows = num_tile_rows_minus1 + 1;
2305 
2306  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
2307  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
2308  if (!pps->column_width || !pps->row_height) {
2309  ret = AVERROR(ENOMEM);
2310  goto err;
2311  }
2312 
2313  pps->uniform_spacing_flag = get_bits1(gb);
2314  if (!pps->uniform_spacing_flag) {
2315  uint64_t sum = 0;
2316  for (i = 0; i < pps->num_tile_columns - 1; i++) {
2317  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
2318  sum += pps->column_width[i];
2319  }
2320  if (sum >= sps->ctb_width) {
2321  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
2322  ret = AVERROR_INVALIDDATA;
2323  goto err;
2324  }
2325  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
2326 
2327  sum = 0;
2328  for (i = 0; i < pps->num_tile_rows - 1; i++) {
2329  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
2330  sum += pps->row_height[i];
2331  }
2332  if (sum >= sps->ctb_height) {
2333  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
2334  ret = AVERROR_INVALIDDATA;
2335  goto err;
2336  }
2337  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
2338  }
2339  pps->loop_filter_across_tiles_enabled_flag = get_bits1(gb);
2340  }
2341 
2342  pps->seq_loop_filter_across_slices_enabled_flag = get_bits1(gb);
2343 
2344  pps->deblocking_filter_control_present_flag = get_bits1(gb);
2345  if (pps->deblocking_filter_control_present_flag) {
2346  pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
2347  pps->disable_dbf = get_bits1(gb);
2348  if (!pps->disable_dbf) {
2349  int beta_offset_div2 = get_se_golomb(gb);
2350  int tc_offset_div2 = get_se_golomb(gb) ;
2351  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
2352  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
2353  beta_offset_div2);
2354  ret = AVERROR_INVALIDDATA;
2355  goto err;
2356  }
2357  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
2358  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
2359  tc_offset_div2);
2360  ret = AVERROR_INVALIDDATA;
2361  goto err;
2362  }
2363  pps->beta_offset = 2 * beta_offset_div2;
2364  pps->tc_offset = 2 * tc_offset_div2;
2365  }
2366  }
2367 
2368  pps->scaling_list_data_present_flag = get_bits1(gb);
2369  if (pps->scaling_list_data_present_flag) {
2370  set_default_scaling_list_data(&pps->scaling_list);
2371  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
2372  if (ret < 0)
2373  goto err;
2374  }
2375  pps->lists_modification_present_flag = get_bits1(gb);
2376  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
2377  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
2378  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
2379  log2_parallel_merge_level_minus2);
2380  ret = AVERROR_INVALIDDATA;
2381  goto err;
2382  }
2383  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
2384 
2385  pps->slice_header_extension_present_flag = get_bits1(gb);
2386 
2387  pps->pps_extension_present_flag = get_bits1(gb);
2388  if (pps->pps_extension_present_flag) {
2389  pps->pps_range_extensions_flag = get_bits1(gb);
2390  pps->pps_multilayer_extension_flag = get_bits1(gb);
2391  pps->pps_3d_extension_flag = get_bits1(gb);
2392  pps->pps_scc_extension_flag = get_bits1(gb);
2393  skip_bits(gb, 4); // pps_extension_4bits
2394 
2395  if (sps->ptl.general_ptl.profile_idc >= AV_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
2396  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
2397  goto err;
2398  }
2399 
2400  if (pps->pps_multilayer_extension_flag) {
2401  if ((ret = pps_multilayer_extension(gb, avctx, pps, sps, vps)) < 0)
2402  goto err;
2403  }
2404 
2405  if (pps->pps_3d_extension_flag) {
2406  if ((ret = pps_3d_extension(gb, avctx, pps, sps)) < 0)
2407  goto err;
2408  }
2409 
2410  if (pps->pps_scc_extension_flag) {
2411  if ((ret = pps_scc_extension(gb, avctx, pps, sps)) < 0)
2412  goto err;
2413  }
2414  }
2415 
2416  ret = setup_pps(avctx, gb, pps, sps);
2417  if (ret < 0)
2418  goto err;
2419 
2420  if (get_bits_left(gb) < 0) {
2421  av_log(avctx, AV_LOG_WARNING,
2422  "Overread PPS by %d bits\n", -get_bits_left(gb));
2423  }
2424 
2425  av_refstruct_unref(&ps->pps_list[pps_id]);
2426  ps->pps_list[pps_id] = pps;
2427 
2428  return 0;
2429 
2430 err:
2431  av_refstruct_unref(&pps);
2432  return ret;
2433 }
2434 
2435 void ff_hevc_ps_uninit(HEVCParamSets *ps)
2436 {
2437  int i;
2438 
2439  for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
2440  av_refstruct_unref(&ps->vps_list[i]);
2441  for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
2442  av_refstruct_unref(&ps->sps_list[i]);
2443  for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
2444  av_refstruct_unref(&ps->pps_list[i]);
2445 }
2446 
2447 int ff_hevc_compute_poc2(unsigned log2_max_poc_lsb, int pocTid0, int poc_lsb, int nal_unit_type)
2448 {
2449  int max_poc_lsb = 1 << log2_max_poc_lsb;
2450  int prev_poc_lsb = pocTid0 % max_poc_lsb;
2451  int prev_poc_msb = pocTid0 - prev_poc_lsb;
2452  int poc_msb;
2453 
2454  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2455  poc_msb = prev_poc_msb + max_poc_lsb;
2456  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2457  poc_msb = prev_poc_msb - max_poc_lsb;
2458  else
2459  poc_msb = prev_poc_msb;
2460 
2461  // For BLA picture types, POCmsb is set to 0.
2462  if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
2463  nal_unit_type == HEVC_NAL_BLA_W_RADL ||
2464  nal_unit_type == HEVC_NAL_BLA_N_LP)
2465  poc_msb = 0;
2466 
2467  return poc_msb + poc_lsb;
2468 }
HEVC_DEP_TYPE_BOTH
@ HEVC_DEP_TYPE_BOTH
Definition: ps.c:456
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:280
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
decode_vui
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: ps.c:922
HEVCSPS::data_size
int data_size
Definition: ps.h:369
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
HEVCPPS::data_size
int data_size
Definition: ps.h:506
HEVC_DEP_TYPE_MV
@ HEVC_DEP_TYPE_MV
Definition: ps.c:455
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
VUI::vui_time_scale
uint32_t vui_time_scale
Definition: ps.h:111
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
RepFormat::conf_win_bottom_offset
uint16_t conf_win_bottom_offset
Definition: ps.h:168
RepFormat::separate_colour_plane_flag
uint8_t separate_colour_plane_flag
Definition: ps.h:162
ff_ctz
#define ff_ctz
Definition: intmath.h:105
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:247
HEVCWindow::bottom_offset
unsigned int bottom_offset
Definition: ps.h:95
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:79
HEVCParamSets::pps_list
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
Definition: ps.h:514
ff_hevc_profiles
const AVProfile ff_hevc_profiles[]
Definition: profiles.c:97
ShortTermRPS::num_negative_pics
uint8_t num_negative_pics
Definition: ps.h:80
ShortTermRPS::rps_idx_num_delta_pocs
uint8_t rps_idx_num_delta_pocs
Definition: ps.h:82
av_popcount64
#define av_popcount64
Definition: common.h:157
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
AVProfile::name
const char * name
short name for the profile
Definition: codec.h:166
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
AVRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1406
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:424
ff_hevc_decode_short_term_rps
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: ps.c:89
H2645VUI::matrix_coeffs
enum AVColorSpace matrix_coeffs
Definition: h2645_vui.h:41
HEVCSublayerHdrParams::cbr_flag
uint32_t cbr_flag
Definition: ps.h:42
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
HEVC_NAL_BLA_N_LP
@ HEVC_NAL_BLA_N_LP
Definition: hevc.h:47
HEVCHdrParams::dpb_output_delay_du_length_minus1
uint8_t dpb_output_delay_du_length_minus1
Definition: ps.h:61
HEVCHdrFlagParams::low_delay_hrd_flag
uint8_t low_delay_hrd_flag
Definition: ps.h:49
VUI::tiles_fixed_structure_flag
int tiles_fixed_structure_flag
Definition: ps.h:117
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
VUI::vui_num_ticks_poc_diff_one_minus1
int vui_num_ticks_poc_diff_one_minus1
Definition: ps.h:113
ScalingList::sl
uint8_t sl[4][6][64]
Definition: ps.h:251
VUI::field_seq_flag
int field_seq_flag
Definition: ps.h:103
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:701
VUI::bitstream_restriction_flag
int bitstream_restriction_flag
Definition: ps.h:116
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_hevc_parse_sps
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, unsigned nuh_layer_id, int apply_defdispwin, const HEVCVPS *const *vps_list, AVCodecContext *avctx)
Parse the SPS from the bitstream into the provided HEVCSPS struct.
Definition: ps.c:1205
av_popcount
#define av_popcount
Definition: common.h:154
HEVCHdrParams::elemental_duration_in_tc_minus1
uint16_t elemental_duration_in_tc_minus1[HEVC_MAX_SUB_LAYERS]
Definition: ps.h:69
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:246
HEVC_MAX_LAYERS
@ HEVC_MAX_LAYERS
Definition: hevc.h:103
HEVCHdrParams
Definition: ps.h:52
H2645VUI::video_full_range_flag
int video_full_range_flag
Definition: h2645_vui.h:37
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:518
AV_CODEC_FLAG2_IGNORE_CROP
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:355
HEVCHdrParams::vcl_hrd_parameters_present_flag
uint8_t vcl_hrd_parameters_present_flag
Definition: ps.h:55
HEVCSublayerHdrParams::bit_rate_value_minus1
uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]
Definition: ps.h:38
H2645VUI::video_signal_type_present_flag
int video_signal_type_present_flag
Definition: h2645_vui.h:35
hevc_vps_free
static void hevc_vps_free(AVRefStructOpaque opaque, void *obj)
Definition: ps.c:445
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:383
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
HEVCWindow::left_offset
unsigned int left_offset
Definition: ps.h:92
ShortTermRPS::use_delta
unsigned use_delta
Definition: ps.h:88
GetBitContext
Definition: get_bits.h:109
RepFormat::pic_width_in_luma_samples
uint16_t pic_width_in_luma_samples
Definition: ps.h:159
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
H265RawProfileTierLevel::sub_layer_level_present_flag
uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:64
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:122
remove_sps
static void remove_sps(HEVCParamSets *s, int id)
Definition: ps.c:65
HEVCHdrParams::sub_pic_hrd_params_present_flag
uint8_t sub_pic_hrd_params_present_flag
Definition: ps.h:56
HEVCSublayerHdrParams::bit_rate_du_value_minus1
uint32_t bit_rate_du_value_minus1[HEVC_MAX_CPB_CNT]
Definition: ps.h:41
ff_hevc_diag_scan8x8_y
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: data.c:58
val
static double val(void *priv, double ch)
Definition: aeval.c:77
remove_vps
static void remove_vps(HEVCParamSets *s, int id)
Definition: ps.c:78
HEVCSublayerHdrParams::cpb_size_du_value_minus1
uint32_t cpb_size_du_value_minus1[HEVC_MAX_CPB_CNT]
Definition: ps.h:40
scaling_list_data
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, const HEVCSPS *sps)
Definition: ps.c:1079
HEVCParamSets::sps_list
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
Definition: ps.h:513
default_scaling_list_intra
static const uint8_t default_scaling_list_intra[]
Definition: ps.c:35
HEVC_SCALABILITY_MULTIVIEW
@ HEVC_SCALABILITY_MULTIVIEW
Definition: hevc.h:167
HEVCSPS::data
uint8_t * data
Definition: ps.h:368
refstruct.h
VUI::restricted_ref_pic_lists_flag
int restricted_ref_pic_lists_flag
Definition: ps.h:119
HEVC_AUX_ALPHA
@ HEVC_AUX_ALPHA
Definition: hevc.h:174
HEVCPPS::row_bd
unsigned int * row_bd
RowBd.
Definition: ps.h:495
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
hevc_sps_free
static void hevc_sps_free(AVRefStructOpaque opaque, void *obj)
Definition: ps.c:1686
H265RawProfileTierLevel::sub_layer_profile_present_flag
uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:63
HEVCHdrParams::nal_hrd_parameters_present_flag
uint8_t nal_hrd_parameters_present_flag
Definition: ps.h:54
HEVCPPS::col_bd
unsigned int * col_bd
ColBd.
Definition: ps.h:494
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
HEVCHdrParams::cpb_size_scale
uint8_t cpb_size_scale
Definition: ps.h:63
AV_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
PTLCommon
Definition: ps.h:127
s
#define s(width, name)
Definition: cbs_vp9.c:198
HEVCHdrParams::vcl_params
HEVCSublayerHdrParams vcl_params[HEVC_MAX_SUB_LAYERS]
Definition: ps.h:72
hevc_sub_height_c
static const uint8_t hevc_sub_height_c[]
Definition: ps.c:61
RepFormat
Definition: ps.h:158
compare_sps
static int compare_sps(const HEVCSPS *sps1, const HEVCSPS *sps2)
Definition: ps.c:1695
av_refstruct_alloc_ext
static void * av_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(AVRefStructOpaque opaque, void *obj))
A wrapper around av_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
VUI::motion_vectors_over_pic_boundaries_flag
int motion_vectors_over_pic_boundaries_flag
Definition: ps.h:118
map_pixel_format
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
Definition: ps.c:1156
HEVCWindow::top_offset
unsigned int top_offset
Definition: ps.h:94
HEVCPPS::data
uint8_t * data
Definition: ps.h:505
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
ScalingList
Definition: ps.h:248
HEVCHdrParams::tick_divisor_minus2
uint8_t tick_divisor_minus2
Definition: ps.h:59
ShortTermRPS::num_delta_pocs
uint8_t num_delta_pocs
Definition: ps.h:81
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
ff_hevc_decode_nal_vps
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:762
setup_pps
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:2031
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:519
if
if(ret)
Definition: filter_design.txt:179
ff_hevc_diag_scan4x4_y
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: data.c:32
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:110
set_default_scaling_list_data
static void set_default_scaling_list_data(ScalingList *sl)
Definition: ps.c:1049
colour_mapping_table
static int colour_mapping_table(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps)
Definition: ps.c:1810
NULL
#define NULL
Definition: coverity.c:32
H2645VUI::colour_description_present_flag
int colour_description_present_flag
Definition: h2645_vui.h:38
pps_3d_extension
static int pps_3d_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:1913
ScalingList::sl_dc
uint8_t sl_dc[2][6]
Definition: ps.h:252
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
VUI::frame_field_info_present_flag
int frame_field_info_present_flag
Definition: ps.h:104
HEVC_DEP_TYPE_SAMPLE
@ HEVC_DEP_TYPE_SAMPLE
Definition: ps.c:454
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
VUI::vui_timing_info_present_flag
int vui_timing_info_present_flag
Definition: ps.h:109
HEVCPPS::tile_id
int * tile_id
TileId.
Definition: ps.h:500
ff_hevc_decode_nal_pps
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:2163
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
HEVCSublayerHdrParams
Definition: ps.h:37
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
profiles.h
HEVCHdrFlagParams::fixed_pic_rate_general_flag
uint8_t fixed_pic_rate_general_flag
Definition: ps.h:47
DependencyType
DependencyType
Definition: ps.c:453
VUI::log2_max_mv_length_horizontal
int log2_max_mv_length_horizontal
Definition: ps.h:123
PTL
Definition: ps.h:150
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:125
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
data.h
decode_sublayer_hrd
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, HEVCSublayerHdrParams *par, int subpic_params_present)
Definition: ps.c:359
AVProfile::profile
int profile
Definition: codec.h:165
vps
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
Definition: cbs_h265_syntax_template.c:423
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
VUI::max_bytes_per_pic_denom
int max_bytes_per_pic_denom
Definition: ps.h:121
pps_range_extensions
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:1937
AV_PROFILE_HEVC_REXT
#define AV_PROFILE_HEVC_REXT
Definition: defs.h:162
hevc_sub_width_c
static const uint8_t hevc_sub_width_c[]
Definition: ps.c:57
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
HEVCSublayerHdrParams::cpb_size_value_minus1
uint32_t cpb_size_value_minus1[HEVC_MAX_CPB_CNT]
Definition: ps.h:39
HEVCWindow
Definition: ps.h:91
ShortTermRPS::used
uint32_t used
Definition: ps.h:77
HEVCHdrParams::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: ps.h:67
decode_vps_ext
static int decode_vps_ext(GetBitContext *gb, AVCodecContext *avctx, HEVCVPS *vps, uint64_t layer1_id_included)
Definition: ps.c:459
get_bits_bytesize
static int get_bits_bytesize(const GetBitContext *s, int round_up)
Get the size of the GetBitContext's buffer in bytes.
Definition: get_bits.h:268
HEVC_MAX_DPB_SIZE
@ HEVC_MAX_DPB_SIZE
Definition: hevc.h:120
HEVCPPS::pps_id
unsigned int pps_id
Definition: ps.h:375
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:503
RepFormat::conf_win_left_offset
uint16_t conf_win_left_offset
Definition: ps.h:165
RepFormat::pic_height_in_luma_samples
uint16_t pic_height_in_luma_samples
Definition: ps.h:160
CHECK_QP_OFFSET
#define CHECK_QP_OFFSET(name)
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
VUI::common
H2645VUI common
Definition: ps.h:99
VUI::def_disp_win
HEVCWindow def_disp_win
Definition: ps.h:107
VUI::vui_poc_proportional_to_timing_flag
int vui_poc_proportional_to_timing_flag
Definition: ps.h:112
VUI
Definition: ps.h:98
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
VUI::vui_num_units_in_tick
uint32_t vui_num_units_in_tick
Definition: ps.h:110
ps.h
VUI::max_bits_per_min_cu_denom
int max_bits_per_min_cu_denom
Definition: ps.h:122
VUI::log2_max_mv_length_vertical
int log2_max_mv_length_vertical
Definition: ps.h:124
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:416
av_zero_extend
#define av_zero_extend
Definition: common.h:151
HEVCHdrParams::bit_rate_scale
uint8_t bit_rate_scale
Definition: ps.h:62
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
av_refstruct_unref
void av_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: ps.c:2435
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:456
VUI::default_display_window_flag
int default_display_window_flag
Definition: ps.h:106
HEVCHdrParams::nal_params
HEVCSublayerHdrParams nal_params[HEVC_MAX_SUB_LAYERS]
Definition: ps.h:71
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:373
parse_ptl
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, int profile_present, PTL *ptl, int max_num_sub_layers)
Definition: ps.c:313
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
VUI::neutra_chroma_indication_flag
int neutra_chroma_indication_flag
Definition: ps.h:101
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_hevc_diag_scan4x4_x
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: data.c:25
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2297
ShortTermRPS::abs_delta_rps
uint16_t abs_delta_rps
Definition: ps.h:84
RepFormat::bit_depth_luma
uint8_t bit_depth_luma
bit_depth_vps_luma_minus8 + 8
Definition: ps.h:163
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
ff_hevc_compute_poc2
int ff_hevc_compute_poc2(unsigned log2_max_poc_lsb, int pocTid0, int poc_lsb, int nal_unit_type)
Compute POC of the current frame and return it.
Definition: ps.c:2447
pps_scc_extension
static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:1977
ret
ret
Definition: filter_design.txt:187
HEVCHdrFlagParams::fixed_pic_rate_within_cvs_flag
uint8_t fixed_pic_rate_within_cvs_flag
Definition: ps.h:48
HEVCVPS::data
uint8_t * data
Definition: ps.h:244
h2645_vui.h
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
ff_h2645_decode_common_vui_params
void ff_h2645_decode_common_vui_params(GetBitContext *gb, H2645VUI *vui, void *logctx)
Definition: h2645_vui.c:37
pos
unsigned int pos
Definition: spdifenc.c:414
ShortTermRPS::delta_idx
uint8_t delta_idx
Definition: ps.h:79
HEVCHdrParams::initial_cpb_removal_delay_length_minus1
uint8_t initial_cpb_removal_delay_length_minus1
Definition: ps.h:65
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:439
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
delta_dlt
static void delta_dlt(GetBitContext *gb, HEVCPPS *pps)
Definition: ps.c:1891
av_refstruct_ref_c
const void * av_refstruct_ref_c(const void *obj)
Analog of av_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
ff_hevc_decode_nal_sps
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, unsigned nuh_layer_id, int apply_defdispwin)
Definition: ps.c:1701
decode_profile_tier_level
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx, PTLCommon *ptl)
Definition: ps.c:238
decode_hrd
static int decode_hrd(GetBitContext *gb, int common_inf_present, HEVCHdrParams *hdr, int max_sublayers)
Definition: ps.c:377
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
HEVC_MAX_LOG2_CTB_SIZE
@ HEVC_MAX_LOG2_CTB_SIZE
Definition: hevc.h:131
HEVCWindow::right_offset
unsigned int right_offset
Definition: ps.h:93
ShortTermRPS
Definition: ps.h:75
VUI::vui_hrd_parameters_present_flag
int vui_hrd_parameters_present_flag
Definition: ps.h:114
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1382
colour_mapping_octants
static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth, int idx_y, int idx_cb, int idx_cr, int inp_length)
Definition: ps.c:1773
VUI::min_spatial_segmentation_idc
int min_spatial_segmentation_idc
Definition: ps.h:120
HEVC_SCALABILITY_AUXILIARY
@ HEVC_SCALABILITY_AUXILIARY
Definition: hevc.h:169
ff_hevc_diag_scan8x8_x
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: data.c:39
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:78
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:117
HEVCVPS
Definition: ps.h:171
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
HEVCSPS
Definition: ps.h:255
ShortTermRPS::rps_predict
unsigned rps_predict
Definition: ps.h:87
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
HEVCPPS
Definition: ps.h:374
HEVCPPS::sps_id
unsigned int sps_id
seq_parameter_set_id
Definition: ps.h:376
HEVCHdrParams::du_cpb_removal_delay_increment_length_minus1
uint8_t du_cpb_removal_delay_increment_length_minus1
Definition: ps.h:60
HEVCHdrParams::cpb_cnt_minus1
uint8_t cpb_cnt_minus1[HEVC_MAX_SUB_LAYERS]
Definition: ps.h:68
timing_info
static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)
Definition: cbs_av1_syntax_template.c:158
HEVCHdrParams::au_cpb_removal_delay_length_minus1
uint8_t au_cpb_removal_delay_length_minus1
Definition: ps.h:66
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:248
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
HEVCParamSets::vps_list
const HEVCVPS * vps_list[HEVC_MAX_VPS_COUNT]
RefStruct references.
Definition: ps.h:512
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:115
int32_t
int32_t
Definition: audioconvert.c:56
HEVCHdrParams::sub_pic_cpb_params_in_pic_timing_sei_flag
uint8_t sub_pic_cpb_params_in_pic_timing_sei_flag
Definition: ps.h:57
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
HEVCVPS::data_size
int data_size
Definition: ps.h:245
RepFormat::conf_win_top_offset
uint16_t conf_win_top_offset
Definition: ps.h:167
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
HEVC_MAX_PALETTE_PREDICTOR_SIZE
@ HEVC_MAX_PALETTE_PREDICTOR_SIZE
Definition: hevc.h:162
ShortTermRPS::delta_poc
int32_t delta_poc[32]
Definition: ps.h:76
pps_multilayer_extension
static int pps_multilayer_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps, const HEVCVPS *vps)
Definition: ps.c:1842
HEVCHdrParams::cpb_size_du_scale
uint8_t cpb_size_du_scale
Definition: ps.h:64
check_profile_idc
#define check_profile_idc(idc)
ShortTermRPS::delta_rps_sign
unsigned delta_rps_sign
Definition: ps.h:85
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:520
FF_DEBUG_BITSTREAM
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:1385
HEVCHdrParams::flags
HEVCHdrFlagParams flags
Definition: ps.h:53
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
HEVC_MAX_LONG_TERM_REF_PICS
@ HEVC_MAX_LONG_TERM_REF_PICS
Definition: hevc.h:127
HEVC_NAL_BLA_W_RADL
@ HEVC_NAL_BLA_W_RADL
Definition: hevc.h:46
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
default_scaling_list_inter
static const uint8_t default_scaling_list_inter[]
Definition: ps.c:46
HEVC_NAL_BLA_W_LP
@ HEVC_NAL_BLA_W_LP
Definition: hevc.h:45
RepFormat::chroma_format_idc
uint8_t chroma_format_idc
Definition: ps.h:161
hevc_pps_free
static void hevc_pps_free(AVRefStructOpaque unused, void *obj)
Definition: ps.c:1754
HEVCParamSets
Definition: ps.h:511
RepFormat::conf_win_right_offset
uint16_t conf_win_right_offset
Definition: ps.h:166
Generated on Sat Jan 17 2026 19:22:13 for FFmpeg by   doxygen 1.8.17