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