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 "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  ff_refstruct_unref(&s->pps_list[i]);
73 
74  ff_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  ff_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  const char *profile_name = NULL;
242  int i;
243 
244  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 43 + 1)
245  return -1;
246 
247  ptl->profile_space = get_bits(gb, 2);
248  ptl->tier_flag = get_bits1(gb);
249  ptl->profile_idc = get_bits(gb, 5);
250 
251 #if !CONFIG_SMALL
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 #endif
258  av_log(avctx, profile_name ? AV_LOG_DEBUG : AV_LOG_WARNING,
259  "%s profile bitstream\n", profile_name ? profile_name : "Unknown");
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(FFRefStructOpaque opaque, void *obj)
446 {
447  HEVCVPS *vps = obj;
448 
449  av_freep(&vps->hdr);
450  av_freep(&vps->data);
451 }
452 
453 enum ScalabilityMask {
454  HEVC_SCALABILITY_DEPTH = 0,
455  HEVC_SCALABILITY_MULTIVIEW = 1,
456  HEVC_SCALABILITY_SPATIAL = 2,
457  HEVC_SCALABILITY_AUXILIARY = 3,
458  HEVC_SCALABILITY_MASK_MAX = 15,
459 };
460 
461 enum DependencyType {
462  HEVC_DEP_TYPE_SAMPLE = 0,
463  HEVC_DEP_TYPE_MV = 1,
464  HEVC_DEP_TYPE_BOTH = 2,
465 };
466 
467 static int decode_vps_ext(GetBitContext *gb, AVCodecContext *avctx, HEVCVPS *vps,
468  uint64_t layer1_id_included)
469 {
470  PTL ptl_dummy;
471  uint8_t max_sub_layers[HEVC_MAX_LAYERS];
472 
473  int splitting_flag, dimension_id_len, view_id_len, num_add_olss, num_scalability_types,
474  default_output_layer_idc, direct_dep_type_len, direct_dep_type,
475  sub_layers_max_present, sub_layer_flag_info_present_flag, nb_ptl;
476  unsigned non_vui_extension_length;
477 
478  if (vps->vps_max_layers == 1 || vps->vps_num_layer_sets == 1) {
479  av_log(avctx, AV_LOG_VERBOSE, "Ignoring VPS extensions with a single layer\n");
480  return 0;
481  }
482 
483  if (vps->vps_max_layers > 2) {
484  av_log(avctx, AV_LOG_ERROR,
485  "VPS has %d layers, only 2 layers are supported\n",
486  vps->vps_max_layers);
487  return AVERROR_PATCHWELCOME;
488  }
489  if (vps->vps_num_layer_sets > 2) {
490  av_log(avctx, AV_LOG_ERROR,
491  "VPS has %d layer sets, only 2 layer sets are supported\n",
492  vps->vps_num_layer_sets);
493  return AVERROR_PATCHWELCOME;
494  }
495 
496  align_get_bits(gb);
497 
498  /**
499  * For stereoscopic MV-HEVC, the following simplifying assumptions are made:
500  *
501  * - vps_max_layers = 2 (one base layer, one multiview layer)
502  * - vps_num_layer_sets = 2 (one output layer set for each view)
503  * - NumScalabilityTypes = 1 (only HEVC_SCALABILITY_MULTIVIEW)
504  * - direct_dependency_flag[1][0] = 1 (second layer depends on first)
505  * - num_add_olss = 0 (no extra output layer sets)
506  * - default_output_layer_idc = 0 (1:1 mapping between OLSs and layers)
507  * - layer_id_included_flag[1] = {1, 1} (consequence of layer dependencies)
508  * - vps_num_rep_formats_minus1 = 0 (all layers have the same size)
509  *
510  * Which results in the following derived variables:
511  * - ViewOrderIdx = {0, 1}
512  * - NumViews = 2
513  * - DependencyFlag[1][0] = 1
514  * - NumDirectRefLayers = {0, 1}
515  * - NumRefLayers = {0, 1}
516  * - NumPredictedLayers = {1, 0}
517  * - NumIndependentLayers = 1
518  * - NumLayersInTreePartition = {2}
519  * - NumLayerSets = 2
520  * - NumOutputLayerSets = 2
521  * - OlsIdxToLsIdx = {0, 1}
522  * - LayerIdxInVps = {0, 1}
523  * - NumLayersInIdList = {1, 2}
524  * - NumNecessaryLayers = {1, 2}
525  * - NecessaryLayerFlag = {{1, 0}, {1, 1}}
526  * - NumOutputLayersInOutputLayerSet = {1, 2}
527  * - OutputLayerFlag = {{1, 0}, {1, 1}}
528  */
529  vps->nb_layers = 2;
530 
531  if (parse_ptl(gb, avctx, 0, &ptl_dummy, vps->vps_max_sub_layers) < 0)
532  return AVERROR_INVALIDDATA;
533 
534  splitting_flag = get_bits1(gb);
535  num_scalability_types = 0;
536  for (int i = 0; i <= HEVC_SCALABILITY_MASK_MAX; i++) {
537  int scalability_mask_flag = get_bits1(gb);
538  if (scalability_mask_flag && (i != HEVC_SCALABILITY_MULTIVIEW)) {
539  av_log(avctx, AV_LOG_ERROR, "Scalability type %d not supported\n", i);
540  return AVERROR_PATCHWELCOME;
541  }
542  num_scalability_types += scalability_mask_flag;
543  }
544  if (num_scalability_types != 1)
545  return AVERROR_INVALIDDATA;
546 
547  if (!splitting_flag)
548  dimension_id_len = get_bits(gb, 3) + 1;
549 
550  if (get_bits1(gb)) { /* vps_nuh_layer_id_present_flag */
551  int layer_id_in_nuh = get_bits(gb, 6);
552  if (layer_id_in_nuh >= FF_ARRAY_ELEMS(vps->layer_idx)) {
553  av_log(avctx, AV_LOG_ERROR, "Invalid layer_id_in_nuh[1]: %d\n",
554  layer_id_in_nuh);
555  return AVERROR_INVALIDDATA;
556  }
557  vps->layer_idx[layer_id_in_nuh] = 1;
558  vps->layer_id_in_nuh[1] = layer_id_in_nuh;
559  } else {
560  vps->layer_idx[1] = 1;
561  vps->layer_id_in_nuh[1] = 1;
562  }
563 
564  if (!splitting_flag) {
565  int view_idx = get_bits(gb, dimension_id_len);
566  if (view_idx != 1) {
567  av_log(avctx, AV_LOG_ERROR, "Unexpected ViewOrderIdx: %d\n", view_idx);
568  return AVERROR_PATCHWELCOME;
569  }
570  }
571 
572  view_id_len = get_bits(gb, 4);
573  if (view_id_len)
574  for (int i = 0; i < 2 /* NumViews */; i++)
575  vps->view_id[i] = get_bits(gb, view_id_len);
576 
577  if (!get_bits1(gb) /* direct_dependency_flag */) {
578  av_log(avctx, AV_LOG_WARNING, "Independent output layers not supported\n");
579  return AVERROR_PATCHWELCOME;
580  }
581  vps->num_direct_ref_layers[1] = 1;
582 
583  sub_layers_max_present = get_bits1(gb); // vps_sub_layers_max_minus1_present_flag
584  for (int i = 0; i < vps->vps_max_layers; i++)
585  max_sub_layers[i] = sub_layers_max_present ? get_bits(gb, 3) + 1 :
586  vps->vps_max_sub_layers;
587 
588  if (get_bits1(gb) /* max_tid_ref_present_flag */)
589  skip_bits(gb, 3); // max_tid_il_ref_pics_plus1
590 
591  vps->default_ref_layers_active = get_bits1(gb);
592 
593  nb_ptl = get_ue_golomb(gb) + 1;
594  /* idx [0] is signalled in base VPS, idx [1] is signalled at the
595  * start of VPS extension, indices 2+ are signalled here;
596  * we ignore all but the first one anyway */
597  for (int i = 2; i < nb_ptl; i++) {
598  int profile_present = get_bits1(gb);
599  if (parse_ptl(gb, avctx, profile_present, &ptl_dummy, vps->vps_max_sub_layers) < 0)
600  return AVERROR_INVALIDDATA;
601  }
602 
603  num_add_olss = get_ue_golomb(gb);
604  if (num_add_olss != 0) {
605  /* Since we don't implement support for independent output layer sets
606  * and auxiliary layers, this should never nonzero */
607  av_log(avctx, AV_LOG_ERROR, "Unexpected num_add_olss: %d\n", num_add_olss);
608  return AVERROR_PATCHWELCOME;
609  }
610 
611  default_output_layer_idc = get_bits(gb, 2);
612  if (default_output_layer_idc != 0) {
613  av_log(avctx, AV_LOG_WARNING, "Unsupported default_output_layer_idc: %d\n",
614  default_output_layer_idc);
615  return AVERROR_PATCHWELCOME;
616  }
617 
618  /* Consequence of established layer dependencies */
619  if (layer1_id_included != ((1 << vps->layer_id_in_nuh[0]) |
620  (1 << vps->layer_id_in_nuh[1]))) {
621  av_log(avctx, AV_LOG_ERROR, "Dependent layer not included in layer ID?\n");
622  return AVERROR_PATCHWELCOME;
623  }
624 
625  vps->num_output_layer_sets = 2;
626  vps->ols[1] = 3;
627 
628  for (int j = 0; j < av_popcount64(vps->ols[1]); j++) {
629  int ptl_idx = get_bits(gb, av_ceil_log2(nb_ptl));
630  if (ptl_idx < 1 || ptl_idx >= nb_ptl) {
631  av_log(avctx, AV_LOG_ERROR, "Invalid PTL index: %d\n", ptl_idx);
632  return AVERROR_INVALIDDATA;
633  }
634  }
635 
636  if (get_ue_golomb_31(gb) != 0 /* vps_num_rep_formats_minus1 */) {
637  av_log(avctx, AV_LOG_ERROR, "Unexpected extra rep formats\n");
638  return AVERROR_INVALIDDATA;
639  }
640 
641  vps->rep_format.pic_width_in_luma_samples = get_bits(gb, 16);
642  vps->rep_format.pic_height_in_luma_samples = get_bits(gb, 16);
643 
644  if (!get_bits1(gb) /* chroma_and_bit_depth_vps_present_flag */) {
645  av_log(avctx, AV_LOG_ERROR,
646  "chroma_and_bit_depth_vps_present_flag=0 in first rep_format\n");
647  return AVERROR_INVALIDDATA;
648  }
649  vps->rep_format.chroma_format_idc = get_bits(gb, 2);
650  if (vps->rep_format.chroma_format_idc == 3)
651  vps->rep_format.separate_colour_plane_flag = get_bits1(gb);
652  vps->rep_format.bit_depth_luma = get_bits(gb, 4) + 8;
653  vps->rep_format.bit_depth_chroma = get_bits(gb, 4) + 8;
654  if (vps->rep_format.bit_depth_luma > 16 ||
655  vps->rep_format.bit_depth_chroma > 16 ||
656  vps->rep_format.bit_depth_luma != vps->rep_format.bit_depth_chroma) {
657  av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %"PRIu8" %"PRIu8"\n",
658  vps->rep_format.bit_depth_luma, vps->rep_format.bit_depth_chroma);
659  return AVERROR_PATCHWELCOME;
660  }
661 
662  if (get_bits1(gb) /* conformance_window_vps_flag */) {
663  int vert_mult = hevc_sub_height_c[vps->rep_format.chroma_format_idc];
664  int horiz_mult = hevc_sub_width_c[vps->rep_format.chroma_format_idc];
665  vps->rep_format.conf_win_left_offset = get_ue_golomb(gb) * horiz_mult;
666  vps->rep_format.conf_win_right_offset = get_ue_golomb(gb) * horiz_mult;
667  vps->rep_format.conf_win_top_offset = get_ue_golomb(gb) * vert_mult;
668  vps->rep_format.conf_win_bottom_offset = get_ue_golomb(gb) * vert_mult;
669  }
670 
671  vps->max_one_active_ref_layer = get_bits1(gb);
672  vps->poc_lsb_aligned = get_bits1(gb);
673 
674  sub_layer_flag_info_present_flag = get_bits1(gb);
675  for (int j = 0; j < FFMAX(max_sub_layers[0], max_sub_layers[1]); j++) {
676  int sub_layer_dpb_info_present_flag = 1;
677  if (j > 0 && sub_layer_flag_info_present_flag)
678  sub_layer_dpb_info_present_flag = get_bits1(gb);
679  if (sub_layer_dpb_info_present_flag) {
680  for (int k = 0; k < av_popcount64(vps->ols[1]); k++)
681  vps->dpb_size.max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
682  vps->dpb_size.max_num_reorder_pics = get_ue_golomb_long(gb);
683  vps->dpb_size.max_latency_increase = get_ue_golomb_long(gb) - 1;
684  }
685  }
686 
687  direct_dep_type_len = get_ue_golomb_31(gb) + 2;
688  if (direct_dep_type_len > 32) {
689  av_log(avctx, AV_LOG_ERROR, "Invalid direct_dep_type_len: %d\n",
690  direct_dep_type_len);
691  return AVERROR_INVALIDDATA;
692  }
693 
694  skip_bits1(gb); /* direct_depenency_all_layers_flag */
695  direct_dep_type = get_bits_long(gb, direct_dep_type_len);
696  if (direct_dep_type > HEVC_DEP_TYPE_BOTH) {
697  av_log(avctx, AV_LOG_WARNING, "Unsupported direct_dep_type: %d\n",
698  direct_dep_type);
699  return AVERROR_PATCHWELCOME;
700  }
701 
702  non_vui_extension_length = get_ue_golomb(gb);
703  if (non_vui_extension_length > 4096) {
704  av_log(avctx, AV_LOG_ERROR, "vps_non_vui_extension_length too large: %u\n",
705  non_vui_extension_length);
706  return AVERROR_INVALIDDATA;
707  }
708  skip_bits_long(gb, non_vui_extension_length * 8);
709 
710  if (get_bits1(gb)) // vps_vui_present_flag
711  av_log(avctx, AV_LOG_WARNING, "VPS VUI not supported\n");
712 
713  return 0;
714 }
715 
716 int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx,
717  HEVCParamSets *ps)
718 {
719  int i;
720  int vps_id = get_bits(gb, 4);
721  ptrdiff_t nal_size = gb->buffer_end - gb->buffer;
722  int ret = AVERROR_INVALIDDATA;
723  uint64_t layer1_id_included = 0;
724  HEVCVPS *vps;
725 
726  if (ps->vps_list[vps_id]) {
727  const HEVCVPS *vps1 = ps->vps_list[vps_id];
728  if (vps1->data_size == nal_size &&
729  !memcmp(vps1->data, gb->buffer, vps1->data_size))
730  return 0;
731  }
732 
733  vps = ff_refstruct_alloc_ext(sizeof(*vps), 0, NULL, hevc_vps_free);
734  if (!vps)
735  return AVERROR(ENOMEM);
736 
737  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
738 
739  vps->data_size = nal_size;
740  vps->data = av_memdup(gb->buffer, nal_size);
741  if (!vps->data) {
742  ret = AVERROR(ENOMEM);
743  goto err;
744  }
745  vps->vps_id = vps_id;
746 
747  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
748  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
749  goto err;
750  }
751 
752  vps->vps_max_layers = get_bits(gb, 6) + 1;
753  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
754  vps->vps_temporal_id_nesting_flag = get_bits1(gb);
755 
756  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
757  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
758  goto err;
759  }
760 
761  if (vps->vps_max_sub_layers > HEVC_MAX_SUB_LAYERS) {
762  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
763  vps->vps_max_sub_layers);
764  goto err;
765  }
766 
767  if (parse_ptl(gb, avctx, 1, &vps->ptl, vps->vps_max_sub_layers) < 0)
768  goto err;
769 
770  vps->vps_sub_layer_ordering_info_present_flag = get_bits1(gb);
771 
772  i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1;
773  for (; i < vps->vps_max_sub_layers; i++) {
774  vps->vps_max_dec_pic_buffering[i] = get_ue_golomb_long(gb) + 1;
775  vps->vps_num_reorder_pics[i] = get_ue_golomb_long(gb);
776  vps->vps_max_latency_increase[i] = get_ue_golomb_long(gb) - 1;
777 
778  if (vps->vps_max_dec_pic_buffering[i] > HEVC_MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
779  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
780  vps->vps_max_dec_pic_buffering[i] - 1);
781  goto err;
782  }
783  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
784  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
785  vps->vps_num_reorder_pics[i]);
786  if (avctx->err_recognition & AV_EF_EXPLODE)
787  goto err;
788  }
789  }
790 
791  vps->vps_max_layer_id = get_bits(gb, 6);
792  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
793  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
794  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
795  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
796  goto err;
797  }
798 
799  vps->num_output_layer_sets = 1;
800  vps->ols[0] = 1;
801 
802  // we support at most 2 layers, so ignore the others
803  if (vps->vps_num_layer_sets > 1)
804  layer1_id_included = get_bits64(gb, vps->vps_max_layer_id + 1); // layer_id_included_flag
805  if (vps->vps_num_layer_sets > 2)
806  skip_bits_long(gb, (vps->vps_num_layer_sets - 2) * (vps->vps_max_layer_id + 1));
807 
808  vps->vps_timing_info_present_flag = get_bits1(gb);
809  if (vps->vps_timing_info_present_flag) {
810  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
811  vps->vps_time_scale = get_bits_long(gb, 32);
812  vps->vps_poc_proportional_to_timing_flag = get_bits1(gb);
813  if (vps->vps_poc_proportional_to_timing_flag)
814  vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1;
815  vps->vps_num_hrd_parameters = get_ue_golomb_long(gb);
816  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
817  av_log(avctx, AV_LOG_ERROR,
818  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
819  goto err;
820  }
821 
822  if (vps->vps_num_hrd_parameters) {
823  vps->hdr = av_calloc(vps->vps_num_hrd_parameters, sizeof(*vps->hdr));
824  if (!vps->hdr)
825  goto err;
826  }
827 
828  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
829  int common_inf_present = 1;
830 
831  get_ue_golomb_long(gb); // hrd_layer_set_idx
832  if (i)
833  common_inf_present = get_bits1(gb);
834  decode_hrd(gb, common_inf_present, &vps->hdr[i],
835  vps->vps_max_sub_layers);
836  }
837  }
838 
839  vps->nb_layers = 1;
840  vps->layer_idx[0] = 0;
841  for (int i = 1; i < FF_ARRAY_ELEMS(vps->layer_idx); i++)
842  vps->layer_idx[i] = -1;
843 
844  if (vps->vps_max_layers > 1 && get_bits1(gb)) { /* vps_extension_flag */
845  int ret = decode_vps_ext(gb, avctx, vps, layer1_id_included);
846  if (ret == AVERROR_PATCHWELCOME) {
847  vps->nb_layers = 1;
848  av_log(avctx, AV_LOG_WARNING, "Ignoring unsupported VPS extension\n");
849  ret = 0;
850  } else if (ret < 0)
851  goto err;
852  }
853 
854  if (get_bits_left(gb) < 0) {
855  av_log(avctx, AV_LOG_ERROR,
856  "Overread VPS by %d bits\n", -get_bits_left(gb));
857  if (ps->vps_list[vps_id])
858  goto err;
859  }
860 
861  remove_vps(ps, vps_id);
862  ps->vps_list[vps_id] = vps;
863 
864  return 0;
865 
866 err:
867  ff_refstruct_unref(&vps);
868  return ret;
869 }
870 
871 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
872  int apply_defdispwin, HEVCSPS *sps)
873 {
874  VUI backup_vui, *vui = &sps->vui;
875  GetBitContext backup;
876  int alt = 0;
877 
878  ff_h2645_decode_common_vui_params(gb, &sps->vui.common, avctx);
879 
880  if (vui->common.video_signal_type_present_flag) {
881  if (vui->common.video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
882  sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
883  if (vui->common.colour_description_present_flag) {
884  if (vui->common.matrix_coeffs == AVCOL_SPC_RGB) {
885  switch (sps->pix_fmt) {
886  case AV_PIX_FMT_YUV444P:
887  sps->pix_fmt = AV_PIX_FMT_GBRP;
888  break;
889  case AV_PIX_FMT_YUV444P10:
890  sps->pix_fmt = AV_PIX_FMT_GBRP10;
891  break;
892  case AV_PIX_FMT_YUV444P12:
893  sps->pix_fmt = AV_PIX_FMT_GBRP12;
894  break;
895  }
896  }
897  }
898  }
899 
900  vui->neutra_chroma_indication_flag = get_bits1(gb);
901  vui->field_seq_flag = get_bits1(gb);
902  vui->frame_field_info_present_flag = get_bits1(gb);
903 
904  // Backup context in case an alternate header is detected
905  memcpy(&backup, gb, sizeof(backup));
906  memcpy(&backup_vui, vui, sizeof(backup_vui));
907  if (get_bits_left(gb) >= 68 && show_bits(gb, 21) == 0x100000) {
908  vui->default_display_window_flag = 0;
909  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
910  } else
911  vui->default_display_window_flag = get_bits1(gb);
912 
913  if (vui->default_display_window_flag) {
914  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
915  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
916  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
917  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
918  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
919  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
920 
921  if (apply_defdispwin &&
922  avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
923  av_log(avctx, AV_LOG_DEBUG,
924  "discarding vui default display window, "
925  "original values are l:%u r:%u t:%u b:%u\n",
926  vui->def_disp_win.left_offset,
927  vui->def_disp_win.right_offset,
928  vui->def_disp_win.top_offset,
929  vui->def_disp_win.bottom_offset);
930 
931  vui->def_disp_win.left_offset =
932  vui->def_disp_win.right_offset =
933  vui->def_disp_win.top_offset =
934  vui->def_disp_win.bottom_offset = 0;
935  }
936  }
937 
938 timing_info:
939  vui->vui_timing_info_present_flag = get_bits1(gb);
940 
941  if (vui->vui_timing_info_present_flag) {
942  if( get_bits_left(gb) < 66 && !alt) {
943  // The alternate syntax seem to have timing info located
944  // at where def_disp_win is normally located
945  av_log(avctx, AV_LOG_WARNING,
946  "Strange VUI timing information, retrying...\n");
947  memcpy(vui, &backup_vui, sizeof(backup_vui));
948  memcpy(gb, &backup, sizeof(backup));
949  alt = 1;
950  goto timing_info;
951  }
952  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
953  vui->vui_time_scale = get_bits_long(gb, 32);
954  if (alt) {
955  av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
956  vui->vui_time_scale, vui->vui_num_units_in_tick);
957  }
958  vui->vui_poc_proportional_to_timing_flag = get_bits1(gb);
959  if (vui->vui_poc_proportional_to_timing_flag)
960  vui->vui_num_ticks_poc_diff_one_minus1 = get_ue_golomb_long(gb);
961  vui->vui_hrd_parameters_present_flag = get_bits1(gb);
962  if (vui->vui_hrd_parameters_present_flag)
963  decode_hrd(gb, 1, &sps->hdr, sps->max_sub_layers);
964  }
965 
966  vui->bitstream_restriction_flag = get_bits1(gb);
967  if (vui->bitstream_restriction_flag) {
968  if (get_bits_left(gb) < 8 && !alt) {
969  av_log(avctx, AV_LOG_WARNING,
970  "Strange VUI bitstream restriction information, retrying"
971  " from timing information...\n");
972  memcpy(vui, &backup_vui, sizeof(backup_vui));
973  memcpy(gb, &backup, sizeof(backup));
974  alt = 1;
975  goto timing_info;
976  }
977  vui->tiles_fixed_structure_flag = get_bits1(gb);
978  vui->motion_vectors_over_pic_boundaries_flag = get_bits1(gb);
979  vui->restricted_ref_pic_lists_flag = get_bits1(gb);
980  vui->min_spatial_segmentation_idc = get_ue_golomb_long(gb);
981  vui->max_bytes_per_pic_denom = get_ue_golomb_long(gb);
982  vui->max_bits_per_min_cu_denom = get_ue_golomb_long(gb);
983  vui->log2_max_mv_length_horizontal = get_ue_golomb_long(gb);
984  vui->log2_max_mv_length_vertical = get_ue_golomb_long(gb);
985  }
986 
987  if (get_bits_left(gb) < 1 && !alt) {
988  // XXX: Alternate syntax when sps_range_extension_flag != 0?
989  av_log(avctx, AV_LOG_WARNING,
990  "Overread in VUI, retrying from timing information...\n");
991  memcpy(vui, &backup_vui, sizeof(backup_vui));
992  memcpy(gb, &backup, sizeof(backup));
993  alt = 1;
994  goto timing_info;
995  }
996 }
997 
998 static void set_default_scaling_list_data(ScalingList *sl)
999 {
1000  int matrixId;
1001 
1002  for (matrixId = 0; matrixId < 6; matrixId++) {
1003  // 4x4 default is 16
1004  memset(sl->sl[0][matrixId], 16, 16);
1005  sl->sl_dc[0][matrixId] = 16; // default for 16x16
1006  sl->sl_dc[1][matrixId] = 16; // default for 32x32
1007  }
1008  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
1009  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
1010  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
1011  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
1012  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
1013  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
1014  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
1015  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
1016  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
1017  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
1018  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
1019  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
1020  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
1021  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
1022  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
1023  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
1024  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
1025  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
1026 }
1027 
1028 static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx,
1029  ScalingList *sl, const HEVCSPS *sps)
1030 {
1031  uint8_t scaling_list_pred_mode_flag;
1032  uint8_t scaling_list_dc_coef[2][6];
1033  int size_id, matrix_id, pos;
1034  int i;
1035 
1036  for (size_id = 0; size_id < 4; size_id++)
1037  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
1038  scaling_list_pred_mode_flag = get_bits1(gb);
1039  if (!scaling_list_pred_mode_flag) {
1040  unsigned int delta = get_ue_golomb_long(gb);
1041  /* Only need to handle non-zero delta. Zero means default,
1042  * which should already be in the arrays. */
1043  if (delta) {
1044  // Copy from previous array.
1045  delta *= (size_id == 3) ? 3 : 1;
1046  if (matrix_id < delta) {
1047  av_log(avctx, AV_LOG_ERROR,
1048  "Invalid delta in scaling list data: %d.\n", delta);
1049  return AVERROR_INVALIDDATA;
1050  }
1051 
1052  memcpy(sl->sl[size_id][matrix_id],
1053  sl->sl[size_id][matrix_id - delta],
1054  size_id > 0 ? 64 : 16);
1055  if (size_id > 1)
1056  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
1057  }
1058  } else {
1059  int next_coef, coef_num;
1060  int32_t scaling_list_delta_coef;
1061 
1062  next_coef = 8;
1063  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
1064  if (size_id > 1) {
1065  int scaling_list_coeff_minus8 = get_se_golomb(gb);
1066  if (scaling_list_coeff_minus8 < -7 ||
1067  scaling_list_coeff_minus8 > 247)
1068  return AVERROR_INVALIDDATA;
1069  scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
1070  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
1071  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
1072  }
1073  for (i = 0; i < coef_num; i++) {
1074  if (size_id == 0)
1075  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
1076  ff_hevc_diag_scan4x4_x[i];
1077  else
1078  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
1079  ff_hevc_diag_scan8x8_x[i];
1080 
1081  scaling_list_delta_coef = get_se_golomb(gb);
1082  next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
1083  sl->sl[size_id][matrix_id][pos] = next_coef;
1084  }
1085  }
1086  }
1087 
1088  if (sps->chroma_format_idc == 3) {
1089  for (i = 0; i < 64; i++) {
1090  sl->sl[3][1][i] = sl->sl[2][1][i];
1091  sl->sl[3][2][i] = sl->sl[2][2][i];
1092  sl->sl[3][4][i] = sl->sl[2][4][i];
1093  sl->sl[3][5][i] = sl->sl[2][5][i];
1094  }
1095  sl->sl_dc[1][1] = sl->sl_dc[0][1];
1096  sl->sl_dc[1][2] = sl->sl_dc[0][2];
1097  sl->sl_dc[1][4] = sl->sl_dc[0][4];
1098  sl->sl_dc[1][5] = sl->sl_dc[0][5];
1099  }
1100 
1101 
1102  return 0;
1103 }
1104 
1105 static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
1106 {
1107  const AVPixFmtDescriptor *desc;
1108  switch (sps->bit_depth) {
1109  case 8:
1110  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
1111  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
1112  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
1113  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
1114  break;
1115  case 9:
1116  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
1117  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
1118  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
1119  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
1120  break;
1121  case 10:
1122  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
1123  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
1124  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
1125  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
1126  break;
1127  case 12:
1128  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
1129  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
1130  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
1131  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
1132  break;
1133  default:
1134  av_log(avctx, AV_LOG_ERROR,
1135  "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
1136  "chroma_format_idc is %d, depth is %d\n",
1137  sps->chroma_format_idc, sps->bit_depth);
1138  return AVERROR_INVALIDDATA;
1139  }
1140 
1141  desc = av_pix_fmt_desc_get(sps->pix_fmt);
1142  if (!desc)
1143  return AVERROR(EINVAL);
1144 
1145  sps->hshift[0] = sps->vshift[0] = 0;
1146  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
1147  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
1148 
1149  sps->pixel_shift = sps->bit_depth > 8;
1150 
1151  return 0;
1152 }
1153 
1154 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
1155  unsigned nuh_layer_id, int apply_defdispwin,
1156  const HEVCVPS * const *vps_list, AVCodecContext *avctx)
1157 {
1158  HEVCWindow *ow;
1159  int ret = 0;
1160  int bit_depth_chroma, num_comps, multi_layer_ext;
1161  int vps_max_sub_layers;
1162  int i;
1163 
1164  // Coded parameters
1165 
1166  sps->vps_id = get_bits(gb, 4);
1167 
1168  if (vps_list) {
1169  if (!vps_list[sps->vps_id]) {
1170  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
1171  sps->vps_id);
1172  return AVERROR_INVALIDDATA;
1173  }
1174  sps->vps = ff_refstruct_ref_c(vps_list[sps->vps_id]);
1175  }
1176 
1177  sps->max_sub_layers = get_bits(gb, 3) + 1;
1178  multi_layer_ext = nuh_layer_id > 0 &&
1179  sps->max_sub_layers == HEVC_MAX_SUB_LAYERS + 1;
1180  if (multi_layer_ext) {
1181  if (!sps->vps)
1182  return AVERROR(EINVAL);
1183 
1184  sps->max_sub_layers = sps->vps->vps_max_sub_layers;
1185  }
1186  vps_max_sub_layers = sps->vps ? sps->vps->vps_max_sub_layers
1187  : FFMIN(sps->max_sub_layers, HEVC_MAX_SUB_LAYERS);
1188 
1189  if (sps->max_sub_layers > vps_max_sub_layers) {
1190  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
1191  sps->max_sub_layers);
1192  return AVERROR_INVALIDDATA;
1193  }
1194 
1195  if (!multi_layer_ext) {
1196  sps->temporal_id_nesting = get_bits(gb, 1);
1197 
1198  if ((ret = parse_ptl(gb, avctx, 1, &sps->ptl, sps->max_sub_layers)) < 0)
1199  return ret;
1200  } else {
1201  sps->temporal_id_nesting = sps->max_sub_layers > 1 ?
1202  sps->vps->vps_max_sub_layers : 1;
1203  }
1204 
1205  *sps_id = get_ue_golomb_long(gb);
1206  if (*sps_id >= HEVC_MAX_SPS_COUNT) {
1207  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
1208  return AVERROR_INVALIDDATA;
1209  }
1210 
1211  if (multi_layer_ext) {
1212  const RepFormat *rf = &sps->vps->rep_format;
1213 
1214  if (sps->vps->nb_layers == 1) {
1215  av_log(avctx, AV_LOG_WARNING, "SPS %d references an unsupported VPS extension. Ignoring\n",
1216  *sps_id);
1217  return AVERROR(ENOSYS);
1218  }
1219 
1220  if (get_bits1(gb) && // update_rep_format_flag
1221  get_bits(gb, 8)) { // sps_rep_format_idx
1222  av_log(avctx, AV_LOG_ERROR, "sps_rep_format_idx!=0\n");
1223  return AVERROR_PATCHWELCOME;
1224  }
1225 
1226  sps->separate_colour_plane = rf->separate_colour_plane_flag;
1227  sps->chroma_format_idc = sps->separate_colour_plane ? 0 :
1228  rf->chroma_format_idc;
1229  sps->bit_depth = rf->bit_depth_luma;
1230  sps->width = rf->pic_width_in_luma_samples;
1231  sps->height = rf->pic_height_in_luma_samples;
1232 
1233  sps->pic_conf_win.left_offset = rf->conf_win_left_offset;
1234  sps->pic_conf_win.right_offset = rf->conf_win_right_offset;
1235  sps->pic_conf_win.top_offset = rf->conf_win_top_offset;
1236  sps->pic_conf_win.bottom_offset = rf->conf_win_bottom_offset;
1237 
1238  } else {
1239  sps->chroma_format_idc = get_ue_golomb_long(gb);
1240  if (sps->chroma_format_idc > 3U) {
1241  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
1242  return AVERROR_INVALIDDATA;
1243  }
1244 
1245  if (sps->chroma_format_idc == 3)
1246  sps->separate_colour_plane = get_bits1(gb);
1247 
1248  if (sps->separate_colour_plane)
1249  sps->chroma_format_idc = 0;
1250 
1251  sps->width = get_ue_golomb_long(gb);
1252  sps->height = get_ue_golomb_long(gb);
1253  if ((ret = av_image_check_size(sps->width,
1254  sps->height, 0, avctx)) < 0)
1255  return ret;
1256 
1257  sps->conformance_window = get_bits1(gb);
1258  if (sps->conformance_window) {
1259  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
1260  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
1261  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
1262  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
1263  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
1264  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
1265 
1266  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
1267  av_log(avctx, AV_LOG_DEBUG,
1268  "discarding sps conformance window, "
1269  "original values are l:%u r:%u t:%u b:%u\n",
1270  sps->pic_conf_win.left_offset,
1271  sps->pic_conf_win.right_offset,
1272  sps->pic_conf_win.top_offset,
1273  sps->pic_conf_win.bottom_offset);
1274 
1275  sps->pic_conf_win.left_offset =
1276  sps->pic_conf_win.right_offset =
1277  sps->pic_conf_win.top_offset =
1278  sps->pic_conf_win.bottom_offset = 0;
1279  }
1280  }
1281 
1282  sps->bit_depth = get_ue_golomb_31(gb) + 8;
1283  if (sps->bit_depth > 16) {
1284  av_log(avctx, AV_LOG_ERROR, "Luma bit depth (%d) is out of range\n",
1285  sps->bit_depth);
1286  return AVERROR_INVALIDDATA;
1287  }
1288  bit_depth_chroma = get_ue_golomb_31(gb) + 8;
1289  if (bit_depth_chroma > 16) {
1290  av_log(avctx, AV_LOG_ERROR, "Chroma bit depth (%d) is out of range\n",
1291  bit_depth_chroma);
1292  return AVERROR_INVALIDDATA;
1293  }
1294  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
1295  av_log(avctx, AV_LOG_ERROR,
1296  "Luma bit depth (%d) is different from chroma bit depth (%d), "
1297  "this is unsupported.\n",
1298  sps->bit_depth, bit_depth_chroma);
1299  return AVERROR_INVALIDDATA;
1300  }
1301  sps->bit_depth_chroma = bit_depth_chroma;
1302  }
1303 
1304  sps->output_window = sps->pic_conf_win;
1305 
1306  ret = map_pixel_format(avctx, sps);
1307  if (ret < 0)
1308  return ret;
1309 
1310  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
1311  if (sps->log2_max_poc_lsb > 16) {
1312  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
1313  sps->log2_max_poc_lsb - 4);
1314  return AVERROR_INVALIDDATA;
1315  }
1316 
1317  if (!multi_layer_ext) {
1318  int start;
1319 
1320  sps->sublayer_ordering_info = get_bits1(gb);
1321  start = sps->sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
1322  for (i = start; i < sps->max_sub_layers; i++) {
1323  sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
1324  sps->temporal_layer[i].num_reorder_pics = get_ue_golomb_long(gb);
1325  sps->temporal_layer[i].max_latency_increase = get_ue_golomb_long(gb) - 1;
1326  if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
1327  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
1328  sps->temporal_layer[i].max_dec_pic_buffering - 1U);
1329  return AVERROR_INVALIDDATA;
1330  }
1331  if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
1332  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
1333  sps->temporal_layer[i].num_reorder_pics);
1334  if (avctx->err_recognition & AV_EF_EXPLODE ||
1335  sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
1336  return AVERROR_INVALIDDATA;
1337  }
1338  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
1339  }
1340  }
1341 
1342  if (!sps->sublayer_ordering_info) {
1343  for (i = 0; i < start; i++) {
1344  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
1345  sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics;
1346  sps->temporal_layer[i].max_latency_increase = sps->temporal_layer[start].max_latency_increase;
1347  }
1348  }
1349  } else {
1350  for (int i = 0; i < sps->max_sub_layers; i++) {
1351  sps->temporal_layer[i].max_dec_pic_buffering = sps->vps->dpb_size.max_dec_pic_buffering;
1352  sps->temporal_layer[i].num_reorder_pics = sps->vps->dpb_size.max_num_reorder_pics;
1353  sps->temporal_layer[i].max_latency_increase = sps->vps->dpb_size.max_latency_increase;
1354  }
1355  }
1356 
1357  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
1358  sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);
1359  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
1360  sps->log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
1361  sps->log2_max_trafo_size = sps->log2_diff_max_min_transform_block_size +
1362  sps->log2_min_tb_size;
1363 
1364  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1365  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1366  return AVERROR_INVALIDDATA;
1367  }
1368 
1369  if (sps->log2_diff_max_min_coding_block_size > 30) {
1370  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);
1371  return AVERROR_INVALIDDATA;
1372  }
1373 
1374  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1375  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1376  return AVERROR_INVALIDDATA;
1377  }
1378 
1379  if (sps->log2_diff_max_min_transform_block_size > 30) {
1380  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size",
1381  sps->log2_diff_max_min_transform_block_size);
1382  return AVERROR_INVALIDDATA;
1383  }
1384 
1385  sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
1386  sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
1387 
1388  sps->scaling_list_enabled = get_bits1(gb);
1389  if (sps->scaling_list_enabled) {
1390  set_default_scaling_list_data(&sps->scaling_list);
1391 
1392  if (multi_layer_ext && get_bits1(gb)) { // sps_infer_scaling_list_flag
1393  av_log(avctx, AV_LOG_ERROR, "sps_infer_scaling_list_flag=1 not supported\n");
1394  return AVERROR_PATCHWELCOME;
1395  }
1396 
1397  if (get_bits1(gb)) {
1398  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1399  if (ret < 0)
1400  return ret;
1401  }
1402  }
1403 
1404  sps->amp_enabled = get_bits1(gb);
1405  sps->sao_enabled = get_bits1(gb);
1406 
1407  sps->pcm_enabled = get_bits1(gb);
1408  if (sps->pcm_enabled) {
1409  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1410  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1411  sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
1412  sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
1413  get_ue_golomb_long(gb);
1414  if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1415  av_log(avctx, AV_LOG_ERROR,
1416  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1417  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1418  return AVERROR_INVALIDDATA;
1419  }
1420 
1421  sps->pcm_loop_filter_disabled = get_bits1(gb);
1422  }
1423 
1424  sps->nb_st_rps = get_ue_golomb_long(gb);
1425  if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {
1426  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1427  sps->nb_st_rps);
1428  return AVERROR_INVALIDDATA;
1429  }
1430  for (i = 0; i < sps->nb_st_rps; i++) {
1431  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1432  sps, 0)) < 0)
1433  return ret;
1434  }
1435 
1436  sps->long_term_ref_pics_present = get_bits1(gb);
1437  if (sps->long_term_ref_pics_present) {
1438  sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
1439  if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) {
1440  av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1441  sps->num_long_term_ref_pics_sps);
1442  return AVERROR_INVALIDDATA;
1443  }
1444 
1445  sps->used_by_curr_pic_lt = 0;
1446  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1447  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1448  sps->used_by_curr_pic_lt |= get_bits1(gb) << i;
1449  }
1450  }
1451 
1452  sps->temporal_mvp_enabled = get_bits1(gb);
1453  sps->strong_intra_smoothing_enabled = get_bits1(gb);
1454  sps->vui.common.sar = (AVRational){0, 1};
1455  sps->vui_present = get_bits1(gb);
1456  if (sps->vui_present)
1457  decode_vui(gb, avctx, apply_defdispwin, sps);
1458 
1459  sps->extension_present = get_bits1(gb);
1460  if (sps->extension_present) {
1461  sps->range_extension = get_bits1(gb);
1462  sps->multilayer_extension = get_bits1(gb);
1463  sps->sps_3d_extension = get_bits1(gb);
1464  sps->scc_extension = get_bits1(gb);
1465  skip_bits(gb, 4); // sps_extension_4bits
1466 
1467  if (sps->range_extension) {
1468  sps->transform_skip_rotation_enabled = get_bits1(gb);
1469  sps->transform_skip_context_enabled = get_bits1(gb);
1470  sps->implicit_rdpcm_enabled = get_bits1(gb);
1471  sps->explicit_rdpcm_enabled = get_bits1(gb);
1472 
1473  sps->extended_precision_processing = get_bits1(gb);
1474  if (sps->extended_precision_processing)
1475  av_log(avctx, AV_LOG_WARNING,
1476  "extended_precision_processing_flag not yet implemented\n");
1477 
1478  sps->intra_smoothing_disabled = get_bits1(gb);
1479  sps->high_precision_offsets_enabled = get_bits1(gb);
1480  if (sps->high_precision_offsets_enabled)
1481  av_log(avctx, AV_LOG_WARNING,
1482  "high_precision_offsets_enabled_flag not yet implemented\n");
1483 
1484  sps->persistent_rice_adaptation_enabled = get_bits1(gb);
1485 
1486  sps->cabac_bypass_alignment_enabled = get_bits1(gb);
1487  if (sps->cabac_bypass_alignment_enabled)
1488  av_log(avctx, AV_LOG_WARNING,
1489  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1490  }
1491 
1492  if (sps->multilayer_extension) {
1493  skip_bits1(gb); // inter_view_mv_vert_constraint_flag
1494  }
1495 
1496  if (sps->sps_3d_extension) {
1497  for (i = 0; i <= 1; i++) {
1498  skip_bits1(gb); // iv_di_mc_enabled_flag
1499  skip_bits1(gb); // iv_mv_scal_enabled_flag
1500  if (i == 0) {
1501  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1502  skip_bits1(gb); // iv_res_pred_enabled_flag
1503  skip_bits1(gb); // depth_ref_enabled_flag
1504  skip_bits1(gb); // vsp_mc_enabled_flag
1505  skip_bits1(gb); // dbbp_enabled_flag
1506  } else {
1507  skip_bits1(gb); // tex_mc_enabled_flag
1508  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1509  skip_bits1(gb); // intra_contour_enabled_flag
1510  skip_bits1(gb); // intra_dc_only_wedge_enabled_flag
1511  skip_bits1(gb); // cqt_cu_part_pred_enabled_flag
1512  skip_bits1(gb); // inter_dc_only_enabled_flag
1513  skip_bits1(gb); // skip_intra_enabled_flag
1514  }
1515  }
1516  av_log(avctx, AV_LOG_WARNING,
1517  "sps_3d_extension_flag not yet implemented\n");
1518  }
1519 
1520  if (sps->scc_extension) {
1521  sps->curr_pic_ref_enabled = get_bits1(gb);
1522  sps->palette_mode_enabled = get_bits1(gb);
1523  if (sps->palette_mode_enabled) {
1524  sps->palette_max_size = get_ue_golomb(gb);
1525  sps->delta_palette_max_predictor_size = get_ue_golomb(gb);
1526  sps->palette_predictor_initializers_present = get_bits1(gb);
1527 
1528  if (sps->palette_predictor_initializers_present) {
1529  sps->sps_num_palette_predictor_initializers = get_ue_golomb(gb) + 1;
1530  if (sps->sps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1531  av_log(avctx, AV_LOG_ERROR,
1532  "sps_num_palette_predictor_initializers out of range: %u\n",
1533  sps->sps_num_palette_predictor_initializers);
1534  return AVERROR_INVALIDDATA;
1535  }
1536  num_comps = !sps->chroma_format_idc ? 1 : 3;
1537  for (int comp = 0; comp < num_comps; comp++) {
1538  int bit_depth = !comp ? sps->bit_depth : sps->bit_depth_chroma;
1539  for (i = 0; i < sps->sps_num_palette_predictor_initializers; i++)
1540  sps->sps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
1541  }
1542  }
1543  }
1544  sps->motion_vector_resolution_control_idc = get_bits(gb, 2);
1545  sps->intra_boundary_filtering_disabled = get_bits1(gb);
1546  }
1547  }
1548  if (apply_defdispwin) {
1549  sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
1550  sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;
1551  sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;
1552  sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
1553  }
1554 
1555  ow = &sps->output_window;
1556  if (ow->left_offset >= INT_MAX - ow->right_offset ||
1557  ow->top_offset >= INT_MAX - ow->bottom_offset ||
1558  ow->left_offset + ow->right_offset >= sps->width ||
1559  ow->top_offset + ow->bottom_offset >= sps->height) {
1560  av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
1561  ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1562  if (avctx->err_recognition & AV_EF_EXPLODE) {
1563  return AVERROR_INVALIDDATA;
1564  }
1565  av_log(avctx, AV_LOG_WARNING,
1566  "Displaying the whole video surface.\n");
1567  memset(ow, 0, sizeof(*ow));
1568  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1569  }
1570 
1571  // Inferred parameters
1572  sps->log2_ctb_size = sps->log2_min_cb_size +
1573  sps->log2_diff_max_min_coding_block_size;
1574  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1575 
1576  if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {
1577  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1578  return AVERROR_INVALIDDATA;
1579  }
1580  if (sps->log2_ctb_size < 4) {
1581  av_log(avctx,
1582  AV_LOG_ERROR,
1583  "log2_ctb_size %d differs from the bounds of any known profile\n",
1584  sps->log2_ctb_size);
1585  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1586  return AVERROR_INVALIDDATA;
1587  }
1588 
1589  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1590  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1591  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1592 
1593  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1594  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1595  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1596  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1597  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1598  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1599  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1600 
1601  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1602 
1603  if (av_zero_extend(sps->width, sps->log2_min_cb_size) ||
1604  av_zero_extend(sps->height, sps->log2_min_cb_size)) {
1605  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1606  return AVERROR_INVALIDDATA;
1607  }
1608 
1609  if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) {
1610  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1611  sps->max_transform_hierarchy_depth_inter);
1612  return AVERROR_INVALIDDATA;
1613  }
1614  if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) {
1615  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1616  sps->max_transform_hierarchy_depth_intra);
1617  return AVERROR_INVALIDDATA;
1618  }
1619  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1620  av_log(avctx, AV_LOG_ERROR,
1621  "max transform block size out of range: %d\n",
1622  sps->log2_max_trafo_size);
1623  return AVERROR_INVALIDDATA;
1624  }
1625 
1626  if (get_bits_left(gb) < 0) {
1627  av_log(avctx, AV_LOG_ERROR,
1628  "Overread SPS by %d bits\n", -get_bits_left(gb));
1629  return AVERROR_INVALIDDATA;
1630  }
1631 
1632  return 0;
1633 }
1634 
1635 static void hevc_sps_free(FFRefStructOpaque opaque, void *obj)
1636 {
1637  HEVCSPS *sps = obj;
1638 
1639  ff_refstruct_unref(&sps->vps);
1640 
1641  av_freep(&sps->data);
1642 }
1643 
1644 static int compare_sps(const HEVCSPS *sps1, const HEVCSPS *sps2)
1645 {
1646  return sps1->data_size == sps2->data_size &&
1647  !memcmp(sps1->data, sps2->data, sps1->data_size);
1648 }
1649 
1650 int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx,
1651  HEVCParamSets *ps, unsigned nuh_layer_id,
1652  int apply_defdispwin)
1653 {
1654  HEVCSPS *sps = ff_refstruct_alloc_ext(sizeof(*sps), 0, NULL, hevc_sps_free);
1655  unsigned int sps_id;
1656  int ret;
1657 
1658  if (!sps)
1659  return AVERROR(ENOMEM);
1660 
1661  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1662 
1663  sps->data_size = gb->buffer_end - gb->buffer;
1664  sps->data = av_memdup(gb->buffer, sps->data_size);
1665  if (!sps->data) {
1666  ret = AVERROR(ENOMEM);
1667  goto err;
1668  }
1669 
1670  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1671  nuh_layer_id, apply_defdispwin,
1672  ps->vps_list, avctx);
1673  if (ret < 0)
1674  goto err;
1675 
1676  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1677  av_log(avctx, AV_LOG_DEBUG,
1678  "Parsed SPS: id %d; coded wxh: %dx%d; "
1679  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1680  sps_id, sps->width, sps->height,
1681  sps->width - (sps->output_window.left_offset + sps->output_window.right_offset),
1682  sps->height - (sps->output_window.top_offset + sps->output_window.bottom_offset),
1683  av_get_pix_fmt_name(sps->pix_fmt));
1684  }
1685 
1686  /* check if this is a repeat of an already parsed SPS, then keep the
1687  * original one.
1688  * otherwise drop all PPSes that depend on it */
1689  if (ps->sps_list[sps_id] &&
1690  compare_sps(ps->sps_list[sps_id], sps)) {
1691  ff_refstruct_unref(&sps);
1692  } else {
1693  remove_sps(ps, sps_id);
1694  ps->sps_list[sps_id] = sps;
1695  }
1696 
1697  return 0;
1698 err:
1699  ff_refstruct_unref(&sps);
1700  return ret;
1701 }
1702 
1703 static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
1704 {
1705  HEVCPPS *pps = obj;
1706 
1707  ff_refstruct_unref(&pps->sps);
1708 
1709  av_freep(&pps->column_width);
1710  av_freep(&pps->row_height);
1711  av_freep(&pps->col_bd);
1712  av_freep(&pps->row_bd);
1713  av_freep(&pps->col_idxX);
1714  av_freep(&pps->ctb_addr_rs_to_ts);
1715  av_freep(&pps->ctb_addr_ts_to_rs);
1716  av_freep(&pps->tile_pos_rs);
1717  av_freep(&pps->tile_id);
1718  av_freep(&pps->min_tb_addr_zs_tab);
1719  av_freep(&pps->data);
1720 }
1721 
1722 static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
1723  int idx_y, int idx_cb, int idx_cr, int inp_length)
1724 {
1725  unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1726  int cm_res_bits;
1727 
1728  part_num_y = 1 << pps->cm_y_part_num_log2;
1729 
1730  split_octant_flag = inp_depth < pps->cm_octant_depth ? get_bits1(gb) : 0;
1731 
1732  if (split_octant_flag)
1733  for (int k = 0; k < 2; k++)
1734  for (int m = 0; m < 2; m++)
1735  for (int n = 0; n < 2; n++)
1736  colour_mapping_octants(gb, pps, inp_depth + 1,
1737  idx_y + part_num_y * k * inp_length / 2,
1738  idx_cb + m * inp_length / 2,
1739  idx_cr + n * inp_length / 2,
1740  inp_length / 2);
1741  else
1742  for (int i = 0; i < part_num_y; i++) {
1743  for (int j = 0; j < 4; j++) {
1744  coded_res_flag = get_bits1(gb);
1745  if (coded_res_flag)
1746  for (int c = 0; c < 3; c++) {
1747  res_coeff_q = get_ue_golomb_long(gb);
1748  cm_res_bits = FFMAX(0, 10 + pps->luma_bit_depth_cm_input -
1749  pps->luma_bit_depth_cm_output -
1750  pps->cm_res_quant_bits - pps->cm_delta_flc_bits);
1751  res_coeff_r = cm_res_bits ? get_bits(gb, cm_res_bits) : 0;
1752  if (res_coeff_q || res_coeff_r)
1753  skip_bits1(gb);
1754  }
1755  }
1756  }
1757 }
1758 
1759 static int colour_mapping_table(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps)
1760 {
1761  pps->num_cm_ref_layers = get_ue_golomb(gb) + 1;
1762  if (pps->num_cm_ref_layers > 62) {
1763  av_log(avctx, AV_LOG_ERROR,
1764  "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1765  return AVERROR_INVALIDDATA;
1766  }
1767  for (int i = 0; i < pps->num_cm_ref_layers; i++)
1768  pps->cm_ref_layer_id[i] = get_bits(gb, 6);
1769 
1770  pps->cm_octant_depth = get_bits(gb, 2);
1771  pps->cm_y_part_num_log2 = get_bits(gb, 2);
1772 
1773  pps->luma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1774  pps->chroma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1775  pps->luma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1776  pps->chroma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1777 
1778  pps->cm_res_quant_bits = get_bits(gb, 2);
1779  pps->cm_delta_flc_bits = get_bits(gb, 2) + 1;
1780 
1781  if (pps->cm_octant_depth == 1) {
1782  pps->cm_adapt_threshold_u_delta = get_se_golomb_long(gb);
1783  pps->cm_adapt_threshold_v_delta = get_se_golomb_long(gb);
1784  }
1785 
1786  colour_mapping_octants(gb, pps, 0, 0, 0, 0, 1 << pps->cm_octant_depth);
1787 
1788  return 0;
1789 }
1790 
1791 static int pps_multilayer_extension(GetBitContext *gb, AVCodecContext *avctx,
1792  HEVCPPS *pps, const HEVCSPS *sps, const HEVCVPS *vps)
1793 {
1794  pps->poc_reset_info_present_flag = get_bits1(gb);
1795  pps->pps_infer_scaling_list_flag = get_bits1(gb);
1796  if (pps->pps_infer_scaling_list_flag)
1797  pps->pps_scaling_list_ref_layer_id = get_bits(gb, 6);
1798 
1799  pps->num_ref_loc_offsets = get_ue_golomb(gb);
1800  if (pps->num_ref_loc_offsets > vps->vps_max_layers - 1)
1801  return AVERROR_INVALIDDATA;
1802 
1803  for (int i = 0; i < pps->num_ref_loc_offsets; i++) {
1804  pps->ref_loc_offset_layer_id[i] = get_bits(gb, 6);
1805  pps->scaled_ref_layer_offset_present_flag[i] = get_bits1(gb);
1806  if (pps->scaled_ref_layer_offset_present_flag[i]) {
1807  pps->scaled_ref_layer_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1808  pps->scaled_ref_layer_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1809  pps->scaled_ref_layer_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1810  pps->scaled_ref_layer_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1811  }
1812 
1813  pps->ref_region_offset_present_flag[i] = get_bits1(gb);
1814  if (pps->ref_region_offset_present_flag[i]) {
1815  pps->ref_region_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1816  pps->ref_region_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1817  pps->ref_region_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1818  pps->ref_region_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1819  }
1820 
1821  pps->resample_phase_set_present_flag[i] = get_bits1(gb);
1822  if (pps->resample_phase_set_present_flag[i]) {
1823  pps->phase_hor_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1824  pps->phase_ver_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1825  pps->phase_hor_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1826  pps->phase_ver_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1827  }
1828  }
1829 
1830  pps->colour_mapping_enabled_flag = get_bits1(gb);
1831  if (pps->colour_mapping_enabled_flag) {
1832  int ret = colour_mapping_table(gb, avctx, pps);
1833  if (ret < 0)
1834  return ret;
1835  }
1836 
1837  return 0;
1838 }
1839 
1840 static void delta_dlt(GetBitContext *gb, HEVCPPS *pps)
1841 {
1842  unsigned int num_val_delta_dlt, max_diff = 0;
1843  int min_diff_minus1 = -1;
1844  unsigned int len;
1845 
1846  num_val_delta_dlt = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1847  if (num_val_delta_dlt) {
1848  if (num_val_delta_dlt > 1)
1849  max_diff = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1850  if (num_val_delta_dlt > 2 && max_diff) {
1851  len = av_log2(max_diff) + 1;
1852  min_diff_minus1 = get_bits(gb, len);
1853  }
1854  if (max_diff > (min_diff_minus1 + 1))
1855  for (int k = 1; k < num_val_delta_dlt; k++) {
1856  len = av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1857  skip_bits(gb, len); // delta_val_diff_minus_min
1858  }
1859  }
1860 }
1861 
1862 static int pps_3d_extension(GetBitContext *gb, AVCodecContext *avctx,
1863  HEVCPPS *pps, const HEVCSPS *sps)
1864 {
1865  unsigned int pps_depth_layers_minus1;
1866 
1867  if (get_bits1(gb)) { // dlts_present_flag
1868  pps_depth_layers_minus1 = get_bits(gb, 6);
1869  pps->pps_bit_depth_for_depth_layers_minus8 = get_bits(gb, 4);
1870  for (int i = 0; i <= pps_depth_layers_minus1; i++) {
1871  if (get_bits1(gb)) { // dlt_flag[i]
1872  if (!get_bits1(gb)) { // dlt_pred_flag[i]
1873  if (get_bits1(gb)) { // dlt_val_flags_present_flag[i]
1874  for (int j = 0; j <= ((1 << (pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1875  skip_bits1(gb); // dlt_value_flag[i][j]
1876  } else
1877  delta_dlt(gb, pps);
1878  }
1879  }
1880  }
1881  }
1882 
1883  return 0;
1884 }
1885 
1886 static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx,
1887  HEVCPPS *pps, const HEVCSPS *sps)
1888 {
1889  if (pps->transform_skip_enabled_flag) {
1890  pps->log2_max_transform_skip_block_size = get_ue_golomb_31(gb) + 2;
1891  }
1892  pps->cross_component_prediction_enabled_flag = get_bits1(gb);
1893  pps->chroma_qp_offset_list_enabled_flag = get_bits1(gb);
1894  if (pps->chroma_qp_offset_list_enabled_flag) {
1895  pps->diff_cu_chroma_qp_offset_depth = get_ue_golomb_31(gb);
1896  pps->chroma_qp_offset_list_len_minus1 = get_ue_golomb_31(gb);
1897  if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1898  av_log(avctx, AV_LOG_ERROR,
1899  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1900  return AVERROR_INVALIDDATA;
1901  }
1902  for (int i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1903  pps->cb_qp_offset_list[i] = get_se_golomb(gb);
1904  if (pps->cb_qp_offset_list[i]) {
1905  av_log(avctx, AV_LOG_WARNING,
1906  "cb_qp_offset_list not tested yet.\n");
1907  }
1908  pps->cr_qp_offset_list[i] = get_se_golomb(gb);
1909  if (pps->cr_qp_offset_list[i]) {
1910  av_log(avctx, AV_LOG_WARNING,
1911  "cb_qp_offset_list not tested yet.\n");
1912  }
1913  }
1914  }
1915  pps->log2_sao_offset_scale_luma = get_ue_golomb_31(gb);
1916  pps->log2_sao_offset_scale_chroma = get_ue_golomb_31(gb);
1917 
1918  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1919  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1920  )
1921  return AVERROR_INVALIDDATA;
1922 
1923  return(0);
1924 }
1925 
1926 static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx,
1927  HEVCPPS *pps, const HEVCSPS *sps)
1928 {
1929  int num_comps, ret;
1930 
1931  pps->pps_curr_pic_ref_enabled_flag = get_bits1(gb);
1932  if (pps->residual_adaptive_colour_transform_enabled_flag = get_bits1(gb)) {
1933  pps->pps_slice_act_qp_offsets_present_flag = get_bits1(gb);
1934  pps->pps_act_y_qp_offset = get_se_golomb(gb) - 5;
1935  pps->pps_act_cb_qp_offset = get_se_golomb(gb) - 5;
1936  pps->pps_act_cr_qp_offset = get_se_golomb(gb) - 3;
1937 
1938 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1939  pps->pps_act_ ## name ## _qp_offset >= 12)
1940  ret = CHECK_QP_OFFSET(y) || CHECK_QP_OFFSET(cb) || CHECK_QP_OFFSET(cr);
1941 #undef CHECK_QP_OFFSET
1942  if (ret) {
1943  av_log(avctx, AV_LOG_ERROR,
1944  "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1945  return AVERROR_INVALIDDATA;
1946  }
1947  }
1948 
1949  if (pps->pps_palette_predictor_initializers_present_flag = get_bits1(gb)) {
1950  pps->pps_num_palette_predictor_initializers = get_ue_golomb(gb);
1951  if (pps->pps_num_palette_predictor_initializers > 0) {
1952  if (pps->pps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1953  av_log(avctx, AV_LOG_ERROR,
1954  "pps_num_palette_predictor_initializers out of range: %u\n",
1955  pps->pps_num_palette_predictor_initializers);
1956  return AVERROR_INVALIDDATA;
1957  }
1958  pps->monochrome_palette_flag = get_bits1(gb);
1959  pps->luma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
1960  if (pps->luma_bit_depth_entry != sps->bit_depth)
1961  return AVERROR_INVALIDDATA;
1962  if (!pps->monochrome_palette_flag) {
1963  pps->chroma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
1964  if (pps->chroma_bit_depth_entry != sps->bit_depth_chroma)
1965  return AVERROR_INVALIDDATA;
1966  }
1967 
1968  num_comps = pps->monochrome_palette_flag ? 1 : 3;
1969  for (int comp = 0; comp < num_comps; comp++) {
1970  int bit_depth = !comp ? pps->luma_bit_depth_entry : pps->chroma_bit_depth_entry;
1971  for (int i = 0; i < pps->pps_num_palette_predictor_initializers; i++)
1972  pps->pps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
1973  }
1974  }
1975  }
1976 
1977  return 0;
1978 }
1979 
1980 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1981  HEVCPPS *pps, const HEVCSPS *sps)
1982 {
1983  int log2_diff;
1984  int pic_area_in_ctbs;
1985  int i, j, x, y, ctb_addr_rs, tile_id;
1986 
1987  // Inferred parameters
1988  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1989  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1990  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1991  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1992  return AVERROR(ENOMEM);
1993 
1994  if (pps->uniform_spacing_flag) {
1995  if (!pps->column_width) {
1996  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1997  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1998  }
1999  if (!pps->column_width || !pps->row_height)
2000  return AVERROR(ENOMEM);
2001 
2002  for (i = 0; i < pps->num_tile_columns; i++) {
2003  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
2004  (i * sps->ctb_width) / pps->num_tile_columns;
2005  }
2006 
2007  for (i = 0; i < pps->num_tile_rows; i++) {
2008  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
2009  (i * sps->ctb_height) / pps->num_tile_rows;
2010  }
2011  }
2012 
2013  pps->col_bd[0] = 0;
2014  for (i = 0; i < pps->num_tile_columns; i++)
2015  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
2016 
2017  pps->row_bd[0] = 0;
2018  for (i = 0; i < pps->num_tile_rows; i++)
2019  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
2020 
2021  for (i = 0, j = 0; i < sps->ctb_width; i++) {
2022  if (i > pps->col_bd[j])
2023  j++;
2024  pps->col_idxX[i] = j;
2025  }
2026 
2027  /**
2028  * 6.5
2029  */
2030  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
2031 
2032  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
2033  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
2034  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
2035  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
2036  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
2037  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
2038  return AVERROR(ENOMEM);
2039  }
2040 
2041  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
2042  int tb_x = ctb_addr_rs % sps->ctb_width;
2043  int tb_y = ctb_addr_rs / sps->ctb_width;
2044  int tile_x = 0;
2045  int tile_y = 0;
2046  int val = 0;
2047 
2048  for (i = 0; i < pps->num_tile_columns; i++) {
2049  if (tb_x < pps->col_bd[i + 1]) {
2050  tile_x = i;
2051  break;
2052  }
2053  }
2054 
2055  for (i = 0; i < pps->num_tile_rows; i++) {
2056  if (tb_y < pps->row_bd[i + 1]) {
2057  tile_y = i;
2058  break;
2059  }
2060  }
2061 
2062  for (i = 0; i < tile_x; i++)
2063  val += pps->row_height[tile_y] * pps->column_width[i];
2064  for (i = 0; i < tile_y; i++)
2065  val += sps->ctb_width * pps->row_height[i];
2066 
2067  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
2068  tb_x - pps->col_bd[tile_x];
2069 
2070  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
2071  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
2072  }
2073 
2074  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
2075  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
2076  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
2077  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
2078  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
2079 
2080  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
2081  if (!pps->tile_pos_rs)
2082  return AVERROR(ENOMEM);
2083 
2084  for (j = 0; j < pps->num_tile_rows; j++)
2085  for (i = 0; i < pps->num_tile_columns; i++)
2086  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
2087  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
2088 
2089  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
2090  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
2091  for (y = 0; y < sps->tb_mask+2; y++) {
2092  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
2093  pps->min_tb_addr_zs_tab[y] = -1;
2094  }
2095  for (y = 0; y < sps->tb_mask+1; y++) {
2096  for (x = 0; x < sps->tb_mask+1; x++) {
2097  int tb_x = x >> log2_diff;
2098  int tb_y = y >> log2_diff;
2099  int rs = sps->ctb_width * tb_y + tb_x;
2100  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
2101  for (i = 0; i < log2_diff; i++) {
2102  int m = 1 << i;
2103  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
2104  }
2105  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
2106  }
2107  }
2108 
2109  return 0;
2110 }
2111 
2112 int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx,
2113  HEVCParamSets *ps)
2114 {
2115  const HEVCSPS *sps = NULL;
2116  const HEVCVPS *vps = NULL;
2117  int i, ret = 0;
2118  ptrdiff_t nal_size = gb->buffer_end - gb->buffer;
2119  unsigned int pps_id = get_ue_golomb_long(gb);
2120  unsigned log2_parallel_merge_level_minus2;
2121  HEVCPPS *pps;
2122 
2123  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
2124 
2125  if (pps_id >= HEVC_MAX_PPS_COUNT) {
2126  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
2127  return AVERROR_INVALIDDATA;
2128  }
2129 
2130  if (ps->pps_list[pps_id]) {
2131  const HEVCPPS *pps1 = ps->pps_list[pps_id];
2132  if (pps1->data_size == nal_size &&
2133  !memcmp(pps1->data, gb->buffer, pps1->data_size))
2134  return 0;
2135  }
2136 
2137  pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, hevc_pps_free);
2138  if (!pps)
2139  return AVERROR(ENOMEM);
2140 
2141  pps->data_size = nal_size;
2142  pps->data = av_memdup(gb->buffer, nal_size);
2143  if (!pps->data) {
2144  ret = AVERROR_INVALIDDATA;
2145  goto err;
2146  }
2147 
2148  // Default values
2149  pps->loop_filter_across_tiles_enabled_flag = 1;
2150  pps->num_tile_columns = 1;
2151  pps->num_tile_rows = 1;
2152  pps->uniform_spacing_flag = 1;
2153  pps->disable_dbf = 0;
2154  pps->beta_offset = 0;
2155  pps->tc_offset = 0;
2156  pps->log2_max_transform_skip_block_size = 2;
2157 
2158  // Coded parameters
2159  pps->pps_id = pps_id;
2160  pps->sps_id = get_ue_golomb_long(gb);
2161  if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
2162  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
2163  ret = AVERROR_INVALIDDATA;
2164  goto err;
2165  }
2166  if (!ps->sps_list[pps->sps_id]) {
2167  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
2168  ret = AVERROR_INVALIDDATA;
2169  goto err;
2170  }
2171  sps = ps->sps_list[pps->sps_id];
2172  vps = ps->vps_list[sps->vps_id];
2173 
2174  pps->sps = ff_refstruct_ref_c(sps);
2175 
2176  pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
2177  pps->output_flag_present_flag = get_bits1(gb);
2178  pps->num_extra_slice_header_bits = get_bits(gb, 3);
2179 
2180  pps->sign_data_hiding_flag = get_bits1(gb);
2181 
2182  pps->cabac_init_present_flag = get_bits1(gb);
2183 
2184  pps->num_ref_idx_l0_default_active = get_ue_golomb_31(gb) + 1;
2185  pps->num_ref_idx_l1_default_active = get_ue_golomb_31(gb) + 1;
2186  if (pps->num_ref_idx_l0_default_active >= HEVC_MAX_REFS ||
2187  pps->num_ref_idx_l1_default_active >= HEVC_MAX_REFS) {
2188  av_log(avctx, AV_LOG_ERROR, "Too many default refs in PPS: %d/%d.\n",
2189  pps->num_ref_idx_l0_default_active, pps->num_ref_idx_l1_default_active);
2190  goto err;
2191  }
2192 
2193  pps->pic_init_qp_minus26 = get_se_golomb(gb);
2194 
2195  pps->constrained_intra_pred_flag = get_bits1(gb);
2196  pps->transform_skip_enabled_flag = get_bits1(gb);
2197 
2198  pps->cu_qp_delta_enabled_flag = get_bits1(gb);
2199  pps->diff_cu_qp_delta_depth = 0;
2200  if (pps->cu_qp_delta_enabled_flag)
2201  pps->diff_cu_qp_delta_depth = get_ue_golomb_long(gb);
2202 
2203  if (pps->diff_cu_qp_delta_depth < 0 ||
2204  pps->diff_cu_qp_delta_depth > sps->log2_diff_max_min_coding_block_size) {
2205  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
2206  pps->diff_cu_qp_delta_depth);
2207  ret = AVERROR_INVALIDDATA;
2208  goto err;
2209  }
2210 
2211  pps->cb_qp_offset = get_se_golomb(gb);
2212  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
2213  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
2214  pps->cb_qp_offset);
2215  ret = AVERROR_INVALIDDATA;
2216  goto err;
2217  }
2218  pps->cr_qp_offset = get_se_golomb(gb);
2219  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
2220  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
2221  pps->cr_qp_offset);
2222  ret = AVERROR_INVALIDDATA;
2223  goto err;
2224  }
2225  pps->pic_slice_level_chroma_qp_offsets_present_flag = get_bits1(gb);
2226 
2227  pps->weighted_pred_flag = get_bits1(gb);
2228  pps->weighted_bipred_flag = get_bits1(gb);
2229 
2230  pps->transquant_bypass_enable_flag = get_bits1(gb);
2231  pps->tiles_enabled_flag = get_bits1(gb);
2232  pps->entropy_coding_sync_enabled_flag = get_bits1(gb);
2233 
2234  if (pps->tiles_enabled_flag) {
2235  int num_tile_columns_minus1 = get_ue_golomb(gb);
2236  int num_tile_rows_minus1 = get_ue_golomb(gb);
2237 
2238  if (num_tile_columns_minus1 < 0 ||
2239  num_tile_columns_minus1 >= sps->ctb_width) {
2240  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
2241  num_tile_columns_minus1);
2242  ret = num_tile_columns_minus1 < 0 ? num_tile_columns_minus1 : AVERROR_INVALIDDATA;
2243  goto err;
2244  }
2245  if (num_tile_rows_minus1 < 0 ||
2246  num_tile_rows_minus1 >= sps->ctb_height) {
2247  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
2248  num_tile_rows_minus1);
2249  ret = num_tile_rows_minus1 < 0 ? num_tile_rows_minus1 : AVERROR_INVALIDDATA;
2250  goto err;
2251  }
2252  pps->num_tile_columns = num_tile_columns_minus1 + 1;
2253  pps->num_tile_rows = num_tile_rows_minus1 + 1;
2254 
2255  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
2256  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
2257  if (!pps->column_width || !pps->row_height) {
2258  ret = AVERROR(ENOMEM);
2259  goto err;
2260  }
2261 
2262  pps->uniform_spacing_flag = get_bits1(gb);
2263  if (!pps->uniform_spacing_flag) {
2264  uint64_t sum = 0;
2265  for (i = 0; i < pps->num_tile_columns - 1; i++) {
2266  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
2267  sum += pps->column_width[i];
2268  }
2269  if (sum >= sps->ctb_width) {
2270  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
2271  ret = AVERROR_INVALIDDATA;
2272  goto err;
2273  }
2274  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
2275 
2276  sum = 0;
2277  for (i = 0; i < pps->num_tile_rows - 1; i++) {
2278  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
2279  sum += pps->row_height[i];
2280  }
2281  if (sum >= sps->ctb_height) {
2282  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
2283  ret = AVERROR_INVALIDDATA;
2284  goto err;
2285  }
2286  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
2287  }
2288  pps->loop_filter_across_tiles_enabled_flag = get_bits1(gb);
2289  }
2290 
2291  pps->seq_loop_filter_across_slices_enabled_flag = get_bits1(gb);
2292 
2293  pps->deblocking_filter_control_present_flag = get_bits1(gb);
2294  if (pps->deblocking_filter_control_present_flag) {
2295  pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
2296  pps->disable_dbf = get_bits1(gb);
2297  if (!pps->disable_dbf) {
2298  int beta_offset_div2 = get_se_golomb(gb);
2299  int tc_offset_div2 = get_se_golomb(gb) ;
2300  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
2301  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
2302  beta_offset_div2);
2303  ret = AVERROR_INVALIDDATA;
2304  goto err;
2305  }
2306  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
2307  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
2308  tc_offset_div2);
2309  ret = AVERROR_INVALIDDATA;
2310  goto err;
2311  }
2312  pps->beta_offset = 2 * beta_offset_div2;
2313  pps->tc_offset = 2 * tc_offset_div2;
2314  }
2315  }
2316 
2317  pps->scaling_list_data_present_flag = get_bits1(gb);
2318  if (pps->scaling_list_data_present_flag) {
2319  set_default_scaling_list_data(&pps->scaling_list);
2320  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
2321  if (ret < 0)
2322  goto err;
2323  }
2324  pps->lists_modification_present_flag = get_bits1(gb);
2325  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
2326  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
2327  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
2328  log2_parallel_merge_level_minus2);
2329  ret = AVERROR_INVALIDDATA;
2330  goto err;
2331  }
2332  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
2333 
2334  pps->slice_header_extension_present_flag = get_bits1(gb);
2335 
2336  pps->pps_extension_present_flag = get_bits1(gb);
2337  if (pps->pps_extension_present_flag) {
2338  pps->pps_range_extensions_flag = get_bits1(gb);
2339  pps->pps_multilayer_extension_flag = get_bits1(gb);
2340  pps->pps_3d_extension_flag = get_bits1(gb);
2341  pps->pps_scc_extension_flag = get_bits1(gb);
2342  skip_bits(gb, 4); // pps_extension_4bits
2343 
2344  if (sps->ptl.general_ptl.profile_idc >= AV_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
2345  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
2346  goto err;
2347  }
2348 
2349  if (pps->pps_multilayer_extension_flag) {
2350  if ((ret = pps_multilayer_extension(gb, avctx, pps, sps, vps)) < 0)
2351  goto err;
2352  }
2353 
2354  if (pps->pps_3d_extension_flag) {
2355  if ((ret = pps_3d_extension(gb, avctx, pps, sps)) < 0)
2356  goto err;
2357  }
2358 
2359  if (pps->pps_scc_extension_flag) {
2360  if ((ret = pps_scc_extension(gb, avctx, pps, sps)) < 0)
2361  goto err;
2362  }
2363  }
2364 
2365  ret = setup_pps(avctx, gb, pps, sps);
2366  if (ret < 0)
2367  goto err;
2368 
2369  if (get_bits_left(gb) < 0) {
2370  av_log(avctx, AV_LOG_WARNING,
2371  "Overread PPS by %d bits\n", -get_bits_left(gb));
2372  }
2373 
2374  ff_refstruct_unref(&ps->pps_list[pps_id]);
2375  ps->pps_list[pps_id] = pps;
2376 
2377  return 0;
2378 
2379 err:
2380  ff_refstruct_unref(&pps);
2381  return ret;
2382 }
2383 
2384 void ff_hevc_ps_uninit(HEVCParamSets *ps)
2385 {
2386  int i;
2387 
2388  for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
2389  ff_refstruct_unref(&ps->vps_list[i]);
2390  for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
2391  ff_refstruct_unref(&ps->sps_list[i]);
2392  for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
2393  ff_refstruct_unref(&ps->pps_list[i]);
2394 }
2395 
2396 int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
2397 {
2398  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
2399  int prev_poc_lsb = pocTid0 % max_poc_lsb;
2400  int prev_poc_msb = pocTid0 - prev_poc_lsb;
2401  int poc_msb;
2402 
2403  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2404  poc_msb = prev_poc_msb + max_poc_lsb;
2405  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2406  poc_msb = prev_poc_msb - max_poc_lsb;
2407  else
2408  poc_msb = prev_poc_msb;
2409 
2410  // For BLA picture types, POCmsb is set to 0.
2411  if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
2412  nal_unit_type == HEVC_NAL_BLA_W_RADL ||
2413  nal_unit_type == HEVC_NAL_BLA_N_LP)
2414  poc_msb = 0;
2415 
2416  return poc_msb + poc_lsb;
2417 }
HEVC_DEP_TYPE_BOTH
@ HEVC_DEP_TYPE_BOTH
Definition: ps.c:464
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
decode_vui
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: ps.c:871
HEVCSPS::data_size
int data_size
Definition: ps.h:366
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:503
HEVC_DEP_TYPE_MV
@ HEVC_DEP_TYPE_MV
Definition: ps.c:463
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
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:81
HEVCParamSets::pps_list
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
Definition: ps.h:511
ff_hevc_profiles
const AVProfile ff_hevc_profiles[]
Definition: profiles.c:97
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
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:181
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1430
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
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
HEVC_SCALABILITY_SPATIAL
@ HEVC_SCALABILITY_SPATIAL
Definition: ps.c:456
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
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:502
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:248
VUI::field_seq_flag
int field_seq_flag
Definition: ps.h:103
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
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:641
VUI::bitstream_restriction_flag
int bitstream_restriction_flag
Definition: ps.h:116
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
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:1154
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
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:482
AV_CODEC_FLAG2_IGNORE_CROP
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:375
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
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:381
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:335
ff_hevc_compute_poc
int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
Compute POC of the current frame and return it.
Definition: ps.c:2396
av_ceil_log2
#define av_ceil_log2
Definition: common.h:97
hevc_pps_free
static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
Definition: ps.c:1703
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:518
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:108
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:500
H265RawProfileTierLevel::sub_layer_level_present_flag
uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:64
HEVC_MAX_DPB_SIZE
@ HEVC_MAX_DPB_SIZE
Definition: hevc.h:120
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
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:122
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:1028
HEVCParamSets::sps_list
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
Definition: ps.h:510
default_scaling_list_intra
static const uint8_t default_scaling_list_intra[]
Definition: ps.c:35
HEVCSPS::data
uint8_t * data
Definition: ps.h:365
refstruct.h
VUI::restricted_ref_pic_lists_flag
int restricted_ref_pic_lists_flag
Definition: ps.h:119
HEVCPPS::row_bd
unsigned int * row_bd
RowBd.
Definition: ps.h:492
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
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:491
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
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
ff_refstruct_ref_c
const void * ff_refstruct_ref_c(const void *obj)
Analog of ff_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
hevc_sps_free
static void hevc_sps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:1635
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
hevc_vps_free
static void hevc_vps_free(FFRefStructOpaque opaque, void *obj)
Definition: ps.c:445
ScalabilityMask
ScalabilityMask
Definition: ps.c:453
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:1644
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:499
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
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:1105
HEVCWindow::top_offset
unsigned int top_offset
Definition: ps.h:94
HEVCPPS::data
uint8_t * data
Definition: ps.h:502
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:245
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
ff_hevc_decode_nal_vps
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:716
setup_pps
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:1980
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:483
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
HEVC_MAX_LONG_TERM_REF_PICS
@ HEVC_MAX_LONG_TERM_REF_PICS
Definition: hevc.h:127
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
set_default_scaling_list_data
static void set_default_scaling_list_data(ScalingList *sl)
Definition: ps.c:998
colour_mapping_table
static int colour_mapping_table(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps)
Definition: ps.c:1759
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:1862
ScalingList::sl_dc
uint8_t sl_dc[2][6]
Definition: ps.h:249
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:125
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:462
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:497
ff_hevc_decode_nal_pps
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: ps.c:2112
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
HEVC_SCALABILITY_AUXILIARY
@ HEVC_SCALABILITY_AUXILIARY
Definition: ps.c:457
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
profiles.h
HEVCHdrFlagParams::fixed_pic_rate_general_flag
uint8_t fixed_pic_rate_general_flag
Definition: ps.h:47
DependencyType
DependencyType
Definition: ps.c:461
VUI::log2_max_mv_length_horizontal
int log2_max_mv_length_horizontal
Definition: ps.h:123
PTL
Definition: ps.h:150
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:503
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:180
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:1886
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
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:467
HEVC_MAX_LOG2_CTB_SIZE
@ HEVC_MAX_LOG2_CTB_SIZE
Definition: hevc.h:131
HEVCPPS::pps_id
unsigned int pps_id
Definition: ps.h:372
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:515
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:425
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:507
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
HEVC_SCALABILITY_DEPTH
@ HEVC_SCALABILITY_DEPTH
Definition: ps.c:454
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:509
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:413
av_zero_extend
#define av_zero_extend
Definition: common.h:151
HEVC_SCALABILITY_MASK_MAX
@ HEVC_SCALABILITY_MASK_MAX
Definition: ps.c:458
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:220
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: ps.c:2384
get_bits64
static uint64_t get_bits64(GetBitContext *s, int n)
Read 0-64 bits.
Definition: get_bits.h:453
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:371
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:31
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:519
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
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:117
len
int len
Definition: vorbis_enc_data.h:426
profile
int profile
Definition: mxfenc.c:2228
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:501
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:109
pps_scc_extension
static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: ps.c:1926
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:241
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:561
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:506
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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:1840
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:1650
decode_profile_tier_level
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx, PTLCommon *ptl)
Definition: ps.c:238
HEVC_MAX_LAYERS
@ HEVC_MAX_LAYERS
Definition: hevc.h:103
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:35
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:1406
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:1722
VUI::min_spatial_segmentation_idc
int min_spatial_segmentation_idc
Definition: ps.h:120
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:79
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
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:36
HEVCSPS
Definition: ps.h:252
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:371
HEVCPPS::sps_id
unsigned int sps_id
seq_parameter_set_id
Definition: ps.h:373
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
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:115
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:34
HEVCParamSets::vps_list
const HEVCVPS * vps_list[HEVC_MAX_VPS_COUNT]
RefStruct references.
Definition: ps.h:509
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:242
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
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:1791
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:484
FF_DEBUG_BITSTREAM
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:1409
HEVCHdrParams::flags
HEVCHdrFlagParams flags
Definition: ps.h:53
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
HEVC_SCALABILITY_MULTIVIEW
@ HEVC_SCALABILITY_MULTIVIEW
Definition: ps.c:455
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
HEVC_NAL_BLA_W_RADL
@ HEVC_NAL_BLA_W_RADL
Definition: hevc.h:46
HEVC_MAX_PALETTE_PREDICTOR_SIZE
@ HEVC_MAX_PALETTE_PREDICTOR_SIZE
Definition: hevc.h:162
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:3090
default_scaling_list_inter
static const uint8_t default_scaling_list_inter[]
Definition: ps.c:46
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
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
HEVCParamSets
Definition: ps.h:508
RepFormat::conf_win_right_offset
uint16_t conf_win_right_offset
Definition: ps.h:166
Generated on Tue Nov 5 2024 19:21:38 for FFmpeg by   doxygen 1.8.17