FFmpeg
hevc_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 "golomb.h"
28 #include "h2645_vui.h"
29 #include "hevc_data.h"
30 #include "hevc_ps.h"
31 #include "refstruct.h"
32 
33 static const uint8_t default_scaling_list_intra[] = {
34  16, 16, 16, 16, 17, 18, 21, 24,
35  16, 16, 16, 16, 17, 19, 22, 25,
36  16, 16, 17, 18, 20, 22, 25, 29,
37  16, 16, 18, 21, 24, 27, 31, 36,
38  17, 17, 20, 24, 30, 35, 41, 47,
39  18, 19, 22, 27, 35, 44, 54, 65,
40  21, 22, 25, 31, 41, 54, 70, 88,
41  24, 25, 29, 36, 47, 65, 88, 115
42 };
43 
44 static const uint8_t default_scaling_list_inter[] = {
45  16, 16, 16, 16, 17, 18, 20, 24,
46  16, 16, 16, 17, 18, 20, 24, 25,
47  16, 16, 17, 18, 20, 24, 25, 28,
48  16, 17, 18, 20, 24, 25, 28, 33,
49  17, 18, 20, 24, 25, 28, 33, 41,
50  18, 20, 24, 25, 28, 33, 41, 54,
51  20, 24, 25, 28, 33, 41, 54, 71,
52  24, 25, 28, 33, 41, 54, 71, 91
53 };
54 
55 static const uint8_t hevc_sub_width_c[] = {
56  1, 2, 2, 1
57 };
58 
59 static const uint8_t hevc_sub_height_c[] = {
60  1, 2, 1, 1
61 };
62 
63 static void remove_pps(HEVCParamSets *s, int id)
64 {
65  if (s->pps == s->pps_list[id])
66  s->pps = NULL;
67  ff_refstruct_unref(&s->pps_list[id]);
68 }
69 
70 static void remove_sps(HEVCParamSets *s, int id)
71 {
72  int i;
73  if (s->sps_list[id]) {
74  if (s->sps == s->sps_list[id])
75  s->sps = NULL;
76 
77  /* drop all PPS that depend on this SPS */
78  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
79  if (s->pps_list[i] && s->pps_list[i]->sps_id == id)
80  remove_pps(s, i);
81 
82  av_assert0(!(s->sps_list[id] && s->sps == s->sps_list[id]));
83  ff_refstruct_unref(&s->sps_list[id]);
84  }
85 }
86 
87 static void remove_vps(HEVCParamSets *s, int id)
88 {
89  int i;
90  if (s->vps_list[id]) {
91  if (s->vps == s->vps_list[id])
92  s->vps = NULL;
93 
94  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
95  if (s->sps_list[i] && s->sps_list[i]->vps_id == id)
96  remove_sps(s, i);
97  ff_refstruct_unref(&s->vps_list[id]);
98  }
99 }
100 
102  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
103 {
104  int delta_poc;
105  int k0 = 0;
106  int k = 0;
107  int i;
108 
109  rps->rps_predict = 0;
110 
111  if (rps != sps->st_rps && sps->nb_st_rps)
112  rps->rps_predict = get_bits1(gb);
113 
114  if (rps->rps_predict) {
115  const ShortTermRPS *rps_ridx;
116  int delta_rps;
117 
118  if (is_slice_header) {
119  rps->delta_idx = get_ue_golomb_long(gb) + 1;
120  if (rps->delta_idx > sps->nb_st_rps) {
121  av_log(avctx, AV_LOG_ERROR,
122  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
123  rps->delta_idx, sps->nb_st_rps);
124  return AVERROR_INVALIDDATA;
125  }
126  rps_ridx = &sps->st_rps[sps->nb_st_rps - rps->delta_idx];
127  rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
128  } else
129  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
130 
131  rps->delta_rps_sign = get_bits1(gb);
132  rps->abs_delta_rps = get_ue_golomb_long(gb) + 1;
133  if (rps->abs_delta_rps > 32768) {
134  av_log(avctx, AV_LOG_ERROR,
135  "Invalid value of abs_delta_rps: %d\n",
136  rps->abs_delta_rps);
137  return AVERROR_INVALIDDATA;
138  }
139  delta_rps = (1 - (rps->delta_rps_sign << 1)) * rps->abs_delta_rps;
140  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
141  int used = rps->used[k] = get_bits1(gb);
142 
143  rps->use_delta_flag = 0;
144  if (!used)
145  rps->use_delta_flag = get_bits1(gb);
146 
147  if (used || rps->use_delta_flag) {
148  if (i < rps_ridx->num_delta_pocs)
149  delta_poc = delta_rps + rps_ridx->delta_poc[i];
150  else
151  delta_poc = delta_rps;
152  rps->delta_poc[k] = delta_poc;
153  if (delta_poc < 0)
154  k0++;
155  k++;
156  }
157  }
158 
159  if (k >= FF_ARRAY_ELEMS(rps->used)) {
160  av_log(avctx, AV_LOG_ERROR,
161  "Invalid num_delta_pocs: %d\n", k);
162  return AVERROR_INVALIDDATA;
163  }
164 
165  rps->num_delta_pocs = k;
166  rps->num_negative_pics = k0;
167  // sort in increasing order (smallest first)
168  if (rps->num_delta_pocs != 0) {
169  int used, tmp;
170  for (i = 1; i < rps->num_delta_pocs; i++) {
171  delta_poc = rps->delta_poc[i];
172  used = rps->used[i];
173  for (k = i - 1; k >= 0; k--) {
174  tmp = rps->delta_poc[k];
175  if (delta_poc < tmp) {
176  rps->delta_poc[k + 1] = tmp;
177  rps->used[k + 1] = rps->used[k];
178  rps->delta_poc[k] = delta_poc;
179  rps->used[k] = used;
180  }
181  }
182  }
183  }
184  if ((rps->num_negative_pics >> 1) != 0) {
185  int used;
186  k = rps->num_negative_pics - 1;
187  // flip the negative values to largest first
188  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
189  delta_poc = rps->delta_poc[i];
190  used = rps->used[i];
191  rps->delta_poc[i] = rps->delta_poc[k];
192  rps->used[i] = rps->used[k];
193  rps->delta_poc[k] = delta_poc;
194  rps->used[k] = used;
195  k--;
196  }
197  }
198  } else {
199  unsigned int prev, nb_positive_pics;
201  nb_positive_pics = get_ue_golomb_long(gb);
202 
203  if (rps->num_negative_pics >= HEVC_MAX_REFS ||
204  nb_positive_pics >= HEVC_MAX_REFS) {
205  av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
206  return AVERROR_INVALIDDATA;
207  }
208 
209  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
210  if (rps->num_delta_pocs) {
211  prev = 0;
212  for (i = 0; i < rps->num_negative_pics; i++) {
213  delta_poc = rps->delta_poc_s0[i] = get_ue_golomb_long(gb) + 1;
214  if (delta_poc < 1 || delta_poc > 32768) {
215  av_log(avctx, AV_LOG_ERROR,
216  "Invalid value of delta_poc: %d\n",
217  delta_poc);
218  return AVERROR_INVALIDDATA;
219  }
220  prev -= delta_poc;
221  rps->delta_poc[i] = prev;
222  rps->used[i] = get_bits1(gb);
223  }
224  prev = 0;
225  for (i = 0; i < nb_positive_pics; i++) {
226  delta_poc = rps->delta_poc_s1[i] = get_ue_golomb_long(gb) + 1;
227  if (delta_poc < 1 || delta_poc > 32768) {
228  av_log(avctx, AV_LOG_ERROR,
229  "Invalid value of delta_poc: %d\n",
230  delta_poc);
231  return AVERROR_INVALIDDATA;
232  }
233  prev += delta_poc;
234  rps->delta_poc[rps->num_negative_pics + i] = prev;
235  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
236  }
237  }
238  }
239  return 0;
240 }
241 
242 
244  PTLCommon *ptl)
245 {
246  int i;
247 
248  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 43 + 1)
249  return -1;
250 
251  ptl->profile_space = get_bits(gb, 2);
252  ptl->tier_flag = get_bits1(gb);
253  ptl->profile_idc = get_bits(gb, 5);
254  if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN)
255  av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
256  else if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN_10)
257  av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
258  else if (ptl->profile_idc == AV_PROFILE_HEVC_MAIN_STILL_PICTURE)
259  av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
260  else if (ptl->profile_idc == AV_PROFILE_HEVC_REXT)
261  av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
262  else if (ptl->profile_idc == AV_PROFILE_HEVC_SCC)
263  av_log(avctx, AV_LOG_DEBUG, "Screen Content Coding Extension profile bitstream\n");
264  else
265  av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
266 
267  for (i = 0; i < 32; i++) {
268  ptl->profile_compatibility_flag[i] = get_bits1(gb);
269 
270  if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i])
271  ptl->profile_idc = i;
272  }
273  ptl->progressive_source_flag = get_bits1(gb);
274  ptl->interlaced_source_flag = get_bits1(gb);
275  ptl->non_packed_constraint_flag = get_bits1(gb);
276  ptl->frame_only_constraint_flag = get_bits1(gb);
277 
278 #define check_profile_idc(idc) \
279  ptl->profile_idc == idc || ptl->profile_compatibility_flag[idc]
280 
283  check_profile_idc(10)) {
284 
285  ptl->max_12bit_constraint_flag = get_bits1(gb);
286  ptl->max_10bit_constraint_flag = get_bits1(gb);
287  ptl->max_8bit_constraint_flag = get_bits1(gb);
288  ptl->max_422chroma_constraint_flag = get_bits1(gb);
289  ptl->max_420chroma_constraint_flag = get_bits1(gb);
290  ptl->max_monochrome_constraint_flag = get_bits1(gb);
291  ptl->intra_constraint_flag = get_bits1(gb);
292  ptl->one_picture_only_constraint_flag = get_bits1(gb);
293  ptl->lower_bit_rate_constraint_flag = get_bits1(gb);
294 
296  ptl->max_14bit_constraint_flag = get_bits1(gb);
297  skip_bits_long(gb, 33); // XXX_reserved_zero_33bits[0..32]
298  } else {
299  skip_bits_long(gb, 34); // XXX_reserved_zero_34bits[0..33]
300  }
301  } else if (check_profile_idc(2)) {
302  skip_bits(gb, 7);
303  ptl->one_picture_only_constraint_flag = get_bits1(gb);
304  skip_bits_long(gb, 35); // XXX_reserved_zero_35bits[0..34]
305  } else {
306  skip_bits_long(gb, 43); // XXX_reserved_zero_43bits[0..42]
307  }
308 
311  ptl->inbld_flag = get_bits1(gb);
312  else
313  skip_bits1(gb);
314 #undef check_profile_idc
315 
316  return 0;
317 }
318 
319 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
320  PTL *ptl, int max_num_sub_layers)
321 {
322  int i;
323  if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
324  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 uninit_vps(FFRefStructOpaque opaque, void *obj)
446 {
447  HEVCVPS *vps = obj;
448 
449  av_freep(&vps->hdr);
450 }
451 
453  HEVCParamSets *ps)
454 {
455  int i,j;
456  int vps_id = 0;
457  ptrdiff_t nal_size;
459 
460  if (!vps)
461  return AVERROR(ENOMEM);
462 
463  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
464 
465  nal_size = gb->buffer_end - gb->buffer;
466  if (nal_size > sizeof(vps->data)) {
467  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized VPS "
468  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
469  nal_size, sizeof(vps->data));
470  vps->data_size = sizeof(vps->data);
471  } else {
472  vps->data_size = nal_size;
473  }
474  memcpy(vps->data, gb->buffer, vps->data_size);
475 
476  vps_id = vps->vps_id = get_bits(gb, 4);
477 
478  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
479  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
480  goto err;
481  }
482 
483  vps->vps_max_layers = get_bits(gb, 6) + 1;
484  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
485  vps->vps_temporal_id_nesting_flag = get_bits1(gb);
486 
487  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
488  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
489  goto err;
490  }
491 
492  if (vps->vps_max_sub_layers > HEVC_MAX_SUB_LAYERS) {
493  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
494  vps->vps_max_sub_layers);
495  goto err;
496  }
497 
498  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
499  goto err;
500 
501  vps->vps_sub_layer_ordering_info_present_flag = get_bits1(gb);
502 
503  i = vps->vps_sub_layer_ordering_info_present_flag ? 0 : vps->vps_max_sub_layers - 1;
504  for (; i < vps->vps_max_sub_layers; i++) {
505  vps->vps_max_dec_pic_buffering[i] = get_ue_golomb_long(gb) + 1;
506  vps->vps_num_reorder_pics[i] = get_ue_golomb_long(gb);
507  vps->vps_max_latency_increase[i] = get_ue_golomb_long(gb) - 1;
508 
509  if (vps->vps_max_dec_pic_buffering[i] > HEVC_MAX_DPB_SIZE || !vps->vps_max_dec_pic_buffering[i]) {
510  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
511  vps->vps_max_dec_pic_buffering[i] - 1);
512  goto err;
513  }
514  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
515  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
516  vps->vps_num_reorder_pics[i]);
517  if (avctx->err_recognition & AV_EF_EXPLODE)
518  goto err;
519  }
520  }
521 
522  vps->vps_max_layer_id = get_bits(gb, 6);
523  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
524  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
525  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
526  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
527  goto err;
528  }
529 
530  for (i = 1; i < vps->vps_num_layer_sets; i++)
531  for (j = 0; j <= vps->vps_max_layer_id; j++)
532  skip_bits(gb, 1); // layer_id_included_flag[i][j]
533 
534  vps->vps_timing_info_present_flag = get_bits1(gb);
535  if (vps->vps_timing_info_present_flag) {
536  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
537  vps->vps_time_scale = get_bits_long(gb, 32);
538  vps->vps_poc_proportional_to_timing_flag = get_bits1(gb);
539  if (vps->vps_poc_proportional_to_timing_flag)
540  vps->vps_num_ticks_poc_diff_one = get_ue_golomb_long(gb) + 1;
541  vps->vps_num_hrd_parameters = get_ue_golomb_long(gb);
542  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
543  av_log(avctx, AV_LOG_ERROR,
544  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
545  goto err;
546  }
547 
548  vps->hdr = av_calloc(vps->vps_num_hrd_parameters, sizeof(*vps->hdr));
549  if (!vps->hdr)
550  goto err;
551 
552  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
553  int common_inf_present = 1;
554 
555  get_ue_golomb_long(gb); // hrd_layer_set_idx
556  if (i)
557  common_inf_present = get_bits1(gb);
558  decode_hrd(gb, common_inf_present, &vps->hdr[i],
559  vps->vps_max_sub_layers);
560  }
561  }
562  get_bits1(gb); /* vps_extension_flag */
563 
564  if (get_bits_left(gb) < 0) {
565  av_log(avctx, AV_LOG_ERROR,
566  "Overread VPS by %d bits\n", -get_bits_left(gb));
567  if (ps->vps_list[vps_id])
568  goto err;
569  }
570 
571  if (ps->vps_list[vps_id] &&
572  !memcmp(ps->vps_list[vps_id], vps, sizeof(*vps))) {
574  } else {
575  remove_vps(ps, vps_id);
576  ps->vps_list[vps_id] = vps;
577  }
578 
579  return 0;
580 
581 err:
583  return AVERROR_INVALIDDATA;
584 }
585 
586 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
587  int apply_defdispwin, HEVCSPS *sps)
588 {
589  VUI backup_vui, *vui = &sps->vui;
590  GetBitContext backup;
591  int alt = 0;
592 
593  ff_h2645_decode_common_vui_params(gb, &sps->vui.common, avctx);
594 
596  if (vui->common.video_full_range_flag && sps->pix_fmt == AV_PIX_FMT_YUV420P)
597  sps->pix_fmt = AV_PIX_FMT_YUVJ420P;
599  if (vui->common.matrix_coeffs == AVCOL_SPC_RGB) {
600  switch (sps->pix_fmt) {
601  case AV_PIX_FMT_YUV444P:
602  sps->pix_fmt = AV_PIX_FMT_GBRP;
603  break;
605  sps->pix_fmt = AV_PIX_FMT_GBRP10;
606  break;
608  sps->pix_fmt = AV_PIX_FMT_GBRP12;
609  break;
610  }
611  }
612  }
613  }
614 
616  vui->field_seq_flag = get_bits1(gb);
618 
619  // Backup context in case an alternate header is detected
620  memcpy(&backup, gb, sizeof(backup));
621  memcpy(&backup_vui, vui, sizeof(backup_vui));
622  if (get_bits_left(gb) >= 68 && show_bits(gb, 21) == 0x100000) {
624  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
625  } else
627 
628  if (vui->default_display_window_flag) {
629  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
630  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
631  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
632  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
633  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
634  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
635 
636  if (apply_defdispwin &&
638  av_log(avctx, AV_LOG_DEBUG,
639  "discarding vui default display window, "
640  "original values are l:%u r:%u t:%u b:%u\n",
645 
648  vui->def_disp_win.top_offset =
649  vui->def_disp_win.bottom_offset = 0;
650  }
651  }
652 
655 
656  if (vui->vui_timing_info_present_flag) {
657  if( get_bits_left(gb) < 66 && !alt) {
658  // The alternate syntax seem to have timing info located
659  // at where def_disp_win is normally located
660  av_log(avctx, AV_LOG_WARNING,
661  "Strange VUI timing information, retrying...\n");
662  memcpy(vui, &backup_vui, sizeof(backup_vui));
663  memcpy(gb, &backup, sizeof(backup));
664  alt = 1;
665  goto timing_info;
666  }
667  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
668  vui->vui_time_scale = get_bits_long(gb, 32);
669  if (alt) {
670  av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
672  }
678  decode_hrd(gb, 1, &sps->hdr, sps->max_sub_layers);
679  }
680 
682  if (vui->bitstream_restriction_flag) {
683  if (get_bits_left(gb) < 8 && !alt) {
684  av_log(avctx, AV_LOG_WARNING,
685  "Strange VUI bitstream restriction information, retrying"
686  " from timing information...\n");
687  memcpy(vui, &backup_vui, sizeof(backup_vui));
688  memcpy(gb, &backup, sizeof(backup));
689  alt = 1;
690  goto timing_info;
691  }
700  }
701 
702  if (get_bits_left(gb) < 1 && !alt) {
703  // XXX: Alternate syntax when sps_range_extension_flag != 0?
704  av_log(avctx, AV_LOG_WARNING,
705  "Overread in VUI, retrying from timing information...\n");
706  memcpy(vui, &backup_vui, sizeof(backup_vui));
707  memcpy(gb, &backup, sizeof(backup));
708  alt = 1;
709  goto timing_info;
710  }
711 }
712 
714 {
715  int matrixId;
716 
717  for (matrixId = 0; matrixId < 6; matrixId++) {
718  // 4x4 default is 16
719  memset(sl->sl[0][matrixId], 16, 16);
720  sl->sl_dc[0][matrixId] = 16; // default for 16x16
721  sl->sl_dc[1][matrixId] = 16; // default for 32x32
722  }
723  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
724  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
725  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
726  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
727  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
728  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
729  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
730  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
731  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
732  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
733  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
734  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
735  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
736  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
737  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
738  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
739  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
740  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
741 }
742 
744  ScalingList *sl, const HEVCSPS *sps)
745 {
746  uint8_t scaling_list_pred_mode_flag;
747  uint8_t scaling_list_dc_coef[2][6];
748  int size_id, matrix_id, pos;
749  int i;
750 
751  for (size_id = 0; size_id < 4; size_id++)
752  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
753  scaling_list_pred_mode_flag = get_bits1(gb);
754  if (!scaling_list_pred_mode_flag) {
755  unsigned int delta = get_ue_golomb_long(gb);
756  /* Only need to handle non-zero delta. Zero means default,
757  * which should already be in the arrays. */
758  if (delta) {
759  // Copy from previous array.
760  delta *= (size_id == 3) ? 3 : 1;
761  if (matrix_id < delta) {
762  av_log(avctx, AV_LOG_ERROR,
763  "Invalid delta in scaling list data: %d.\n", delta);
764  return AVERROR_INVALIDDATA;
765  }
766 
767  memcpy(sl->sl[size_id][matrix_id],
768  sl->sl[size_id][matrix_id - delta],
769  size_id > 0 ? 64 : 16);
770  if (size_id > 1)
771  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
772  }
773  } else {
774  int next_coef, coef_num;
775  int32_t scaling_list_delta_coef;
776 
777  next_coef = 8;
778  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
779  if (size_id > 1) {
780  int scaling_list_coeff_minus8 = get_se_golomb(gb);
781  if (scaling_list_coeff_minus8 < -7 ||
782  scaling_list_coeff_minus8 > 247)
783  return AVERROR_INVALIDDATA;
784  scaling_list_dc_coef[size_id - 2][matrix_id] = scaling_list_coeff_minus8 + 8;
785  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
786  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
787  }
788  for (i = 0; i < coef_num; i++) {
789  if (size_id == 0)
790  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
792  else
793  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
795 
796  scaling_list_delta_coef = get_se_golomb(gb);
797  next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
798  sl->sl[size_id][matrix_id][pos] = next_coef;
799  }
800  }
801  }
802 
803  if (sps->chroma_format_idc == 3) {
804  for (i = 0; i < 64; i++) {
805  sl->sl[3][1][i] = sl->sl[2][1][i];
806  sl->sl[3][2][i] = sl->sl[2][2][i];
807  sl->sl[3][4][i] = sl->sl[2][4][i];
808  sl->sl[3][5][i] = sl->sl[2][5][i];
809  }
810  sl->sl_dc[1][1] = sl->sl_dc[0][1];
811  sl->sl_dc[1][2] = sl->sl_dc[0][2];
812  sl->sl_dc[1][4] = sl->sl_dc[0][4];
813  sl->sl_dc[1][5] = sl->sl_dc[0][5];
814  }
815 
816 
817  return 0;
818 }
819 
821 {
822  const AVPixFmtDescriptor *desc;
823  switch (sps->bit_depth) {
824  case 8:
825  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
826  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
827  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
828  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
829  break;
830  case 9:
831  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
832  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
833  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
834  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
835  break;
836  case 10:
837  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
838  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
839  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
840  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
841  break;
842  case 12:
843  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
844  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
845  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
846  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
847  break;
848  default:
849  av_log(avctx, AV_LOG_ERROR,
850  "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
851  "chroma_format_idc is %d, depth is %d\n",
852  sps->chroma_format_idc, sps->bit_depth);
853  return AVERROR_INVALIDDATA;
854  }
855 
856  desc = av_pix_fmt_desc_get(sps->pix_fmt);
857  if (!desc)
858  return AVERROR(EINVAL);
859 
860  sps->hshift[0] = sps->vshift[0] = 0;
861  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
862  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
863 
864  sps->pixel_shift = sps->bit_depth > 8;
865 
866  return 0;
867 }
868 
869 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
870  int apply_defdispwin, const HEVCVPS * const *vps_list,
871  AVCodecContext *avctx)
872 {
873  HEVCWindow *ow;
874  int ret = 0;
875  int bit_depth_chroma, start, num_comps;
876  int i;
877 
878  // Coded parameters
879 
880  sps->vps_id = get_bits(gb, 4);
881 
882  if (vps_list && !vps_list[sps->vps_id]) {
883  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
884  sps->vps_id);
885  return AVERROR_INVALIDDATA;
886  }
887 
888  sps->max_sub_layers = get_bits(gb, 3) + 1;
889  if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
890  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
891  sps->max_sub_layers);
892  return AVERROR_INVALIDDATA;
893  }
894 
895  sps->temporal_id_nesting_flag = get_bits(gb, 1);
896 
897  if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
898  return ret;
899 
900  *sps_id = get_ue_golomb_long(gb);
901  if (*sps_id >= HEVC_MAX_SPS_COUNT) {
902  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
903  return AVERROR_INVALIDDATA;
904  }
905 
906  sps->chroma_format_idc = get_ue_golomb_long(gb);
907  if (sps->chroma_format_idc > 3U) {
908  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
909  return AVERROR_INVALIDDATA;
910  }
911 
912  if (sps->chroma_format_idc == 3)
913  sps->separate_colour_plane_flag = get_bits1(gb);
914 
915  if (sps->separate_colour_plane_flag)
916  sps->chroma_format_idc = 0;
917 
918  sps->width = get_ue_golomb_long(gb);
919  sps->height = get_ue_golomb_long(gb);
920  if ((ret = av_image_check_size(sps->width,
921  sps->height, 0, avctx)) < 0)
922  return ret;
923 
924  sps->conformance_window_flag = get_bits1(gb);
925  if (sps->conformance_window_flag) {
926  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
927  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
928  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
929  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
930  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
931  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
932 
933  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
934  av_log(avctx, AV_LOG_DEBUG,
935  "discarding sps conformance window, "
936  "original values are l:%u r:%u t:%u b:%u\n",
937  sps->pic_conf_win.left_offset,
938  sps->pic_conf_win.right_offset,
939  sps->pic_conf_win.top_offset,
940  sps->pic_conf_win.bottom_offset);
941 
942  sps->pic_conf_win.left_offset =
943  sps->pic_conf_win.right_offset =
944  sps->pic_conf_win.top_offset =
945  sps->pic_conf_win.bottom_offset = 0;
946  }
947  sps->output_window = sps->pic_conf_win;
948  }
949 
950  sps->bit_depth = get_ue_golomb_31(gb) + 8;
951  if (sps->bit_depth > 16) {
952  av_log(avctx, AV_LOG_ERROR, "Luma bit depth (%d) is out of range\n",
953  sps->bit_depth);
954  return AVERROR_INVALIDDATA;
955  }
956  bit_depth_chroma = get_ue_golomb_31(gb) + 8;
957  if (bit_depth_chroma > 16) {
958  av_log(avctx, AV_LOG_ERROR, "Chroma bit depth (%d) is out of range\n",
959  bit_depth_chroma);
960  return AVERROR_INVALIDDATA;
961  }
962  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
963  av_log(avctx, AV_LOG_ERROR,
964  "Luma bit depth (%d) is different from chroma bit depth (%d), "
965  "this is unsupported.\n",
966  sps->bit_depth, bit_depth_chroma);
967  return AVERROR_INVALIDDATA;
968  }
969  sps->bit_depth_chroma = bit_depth_chroma;
970 
971  ret = map_pixel_format(avctx, sps);
972  if (ret < 0)
973  return ret;
974 
975  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
976  if (sps->log2_max_poc_lsb > 16) {
977  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
978  sps->log2_max_poc_lsb - 4);
979  return AVERROR_INVALIDDATA;
980  }
981 
982  sps->sublayer_ordering_info_flag = get_bits1(gb);
983  start = sps->sublayer_ordering_info_flag ? 0 : sps->max_sub_layers - 1;
984  for (i = start; i < sps->max_sub_layers; i++) {
985  sps->temporal_layer[i].max_dec_pic_buffering = get_ue_golomb_long(gb) + 1;
986  sps->temporal_layer[i].num_reorder_pics = get_ue_golomb_long(gb);
987  sps->temporal_layer[i].max_latency_increase = get_ue_golomb_long(gb) - 1;
988  if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
989  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
990  sps->temporal_layer[i].max_dec_pic_buffering - 1U);
991  return AVERROR_INVALIDDATA;
992  }
993  if (sps->temporal_layer[i].num_reorder_pics > sps->temporal_layer[i].max_dec_pic_buffering - 1) {
994  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
995  sps->temporal_layer[i].num_reorder_pics);
996  if (avctx->err_recognition & AV_EF_EXPLODE ||
997  sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
998  return AVERROR_INVALIDDATA;
999  }
1000  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[i].num_reorder_pics + 1;
1001  }
1002  }
1003 
1004  if (!sps->sublayer_ordering_info_flag) {
1005  for (i = 0; i < start; i++) {
1006  sps->temporal_layer[i].max_dec_pic_buffering = sps->temporal_layer[start].max_dec_pic_buffering;
1007  sps->temporal_layer[i].num_reorder_pics = sps->temporal_layer[start].num_reorder_pics;
1008  sps->temporal_layer[i].max_latency_increase = sps->temporal_layer[start].max_latency_increase;
1009  }
1010  }
1011 
1012  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
1013  sps->log2_diff_max_min_coding_block_size = get_ue_golomb_long(gb);
1014  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
1015  sps->log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
1016  sps->log2_max_trafo_size = sps->log2_diff_max_min_transform_block_size +
1017  sps->log2_min_tb_size;
1018 
1019  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1020  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1021  return AVERROR_INVALIDDATA;
1022  }
1023 
1024  if (sps->log2_diff_max_min_coding_block_size > 30) {
1025  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);
1026  return AVERROR_INVALIDDATA;
1027  }
1028 
1029  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1030  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1031  return AVERROR_INVALIDDATA;
1032  }
1033 
1034  if (sps->log2_diff_max_min_transform_block_size > 30) {
1035  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size",
1036  sps->log2_diff_max_min_transform_block_size);
1037  return AVERROR_INVALIDDATA;
1038  }
1039 
1040  sps->max_transform_hierarchy_depth_inter = get_ue_golomb_long(gb);
1041  sps->max_transform_hierarchy_depth_intra = get_ue_golomb_long(gb);
1042 
1043  sps->scaling_list_enable_flag = get_bits1(gb);
1044  if (sps->scaling_list_enable_flag) {
1045  set_default_scaling_list_data(&sps->scaling_list);
1046 
1047  if (get_bits1(gb)) {
1048  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1049  if (ret < 0)
1050  return ret;
1051  }
1052  }
1053 
1054  sps->amp_enabled_flag = get_bits1(gb);
1055  sps->sao_enabled = get_bits1(gb);
1056 
1057  sps->pcm_enabled_flag = get_bits1(gb);
1058  if (sps->pcm_enabled_flag) {
1059  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1060  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1061  sps->pcm.log2_min_pcm_cb_size = get_ue_golomb_long(gb) + 3;
1062  sps->pcm.log2_max_pcm_cb_size = sps->pcm.log2_min_pcm_cb_size +
1063  get_ue_golomb_long(gb);
1064  if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1065  av_log(avctx, AV_LOG_ERROR,
1066  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1067  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1068  return AVERROR_INVALIDDATA;
1069  }
1070 
1071  sps->pcm.loop_filter_disable_flag = get_bits1(gb);
1072  }
1073 
1074  sps->nb_st_rps = get_ue_golomb_long(gb);
1075  if (sps->nb_st_rps > HEVC_MAX_SHORT_TERM_REF_PIC_SETS) {
1076  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1077  sps->nb_st_rps);
1078  return AVERROR_INVALIDDATA;
1079  }
1080  for (i = 0; i < sps->nb_st_rps; i++) {
1081  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1082  sps, 0)) < 0)
1083  return ret;
1084  }
1085 
1086  sps->long_term_ref_pics_present_flag = get_bits1(gb);
1087  if (sps->long_term_ref_pics_present_flag) {
1088  sps->num_long_term_ref_pics_sps = get_ue_golomb_long(gb);
1089  if (sps->num_long_term_ref_pics_sps > HEVC_MAX_LONG_TERM_REF_PICS) {
1090  av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1091  sps->num_long_term_ref_pics_sps);
1092  return AVERROR_INVALIDDATA;
1093  }
1094  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1095  sps->lt_ref_pic_poc_lsb_sps[i] = get_bits(gb, sps->log2_max_poc_lsb);
1096  sps->used_by_curr_pic_lt_sps_flag[i] = get_bits1(gb);
1097  }
1098  }
1099 
1100  sps->sps_temporal_mvp_enabled_flag = get_bits1(gb);
1101  sps->sps_strong_intra_smoothing_enable_flag = get_bits1(gb);
1102  sps->vui.common.sar = (AVRational){0, 1};
1103  sps->vui_present = get_bits1(gb);
1104  if (sps->vui_present)
1105  decode_vui(gb, avctx, apply_defdispwin, sps);
1106 
1107  sps->sps_extension_present_flag = get_bits1(gb);
1108  if (sps->sps_extension_present_flag) {
1109  sps->sps_range_extension_flag = get_bits1(gb);
1110  sps->sps_multilayer_extension_flag = get_bits1(gb);
1111  sps->sps_3d_extension_flag = get_bits1(gb);
1112  sps->sps_scc_extension_flag = get_bits1(gb);
1113  skip_bits(gb, 4); // sps_extension_4bits
1114 
1115  if (sps->sps_range_extension_flag) {
1116  sps->transform_skip_rotation_enabled_flag = get_bits1(gb);
1117  sps->transform_skip_context_enabled_flag = get_bits1(gb);
1118  sps->implicit_rdpcm_enabled_flag = get_bits1(gb);
1119 
1120  sps->explicit_rdpcm_enabled_flag = get_bits1(gb);
1121 
1122  sps->extended_precision_processing_flag = get_bits1(gb);
1123  if (sps->extended_precision_processing_flag)
1124  av_log(avctx, AV_LOG_WARNING,
1125  "extended_precision_processing_flag not yet implemented\n");
1126 
1127  sps->intra_smoothing_disabled_flag = get_bits1(gb);
1128  sps->high_precision_offsets_enabled_flag = get_bits1(gb);
1129  if (sps->high_precision_offsets_enabled_flag)
1130  av_log(avctx, AV_LOG_WARNING,
1131  "high_precision_offsets_enabled_flag not yet implemented\n");
1132 
1133  sps->persistent_rice_adaptation_enabled_flag = get_bits1(gb);
1134 
1135  sps->cabac_bypass_alignment_enabled_flag = get_bits1(gb);
1136  if (sps->cabac_bypass_alignment_enabled_flag)
1137  av_log(avctx, AV_LOG_WARNING,
1138  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1139  }
1140 
1141  if (sps->sps_multilayer_extension_flag) {
1142  skip_bits1(gb); // inter_view_mv_vert_constraint_flag
1143  av_log(avctx, AV_LOG_WARNING,
1144  "sps_multilayer_extension_flag not yet implemented\n");
1145  }
1146 
1147  if (sps->sps_3d_extension_flag) {
1148  for (i = 0; i <= 1; i++) {
1149  skip_bits1(gb); // iv_di_mc_enabled_flag
1150  skip_bits1(gb); // iv_mv_scal_enabled_flag
1151  if (i == 0) {
1152  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1153  skip_bits1(gb); // iv_res_pred_enabled_flag
1154  skip_bits1(gb); // depth_ref_enabled_flag
1155  skip_bits1(gb); // vsp_mc_enabled_flag
1156  skip_bits1(gb); // dbbp_enabled_flag
1157  } else {
1158  skip_bits1(gb); // tex_mc_enabled_flag
1159  get_ue_golomb_long(gb); // log2_ivmc_sub_pb_size_minus3
1160  skip_bits1(gb); // intra_contour_enabled_flag
1161  skip_bits1(gb); // intra_dc_only_wedge_enabled_flag
1162  skip_bits1(gb); // cqt_cu_part_pred_enabled_flag
1163  skip_bits1(gb); // inter_dc_only_enabled_flag
1164  skip_bits1(gb); // skip_intra_enabled_flag
1165  }
1166  }
1167  av_log(avctx, AV_LOG_WARNING,
1168  "sps_3d_extension_flag not yet implemented\n");
1169  }
1170 
1171  if (sps->sps_scc_extension_flag) {
1172  sps->sps_curr_pic_ref_enabled_flag = get_bits1(gb);
1173  sps->palette_mode_enabled_flag = get_bits1(gb);
1174  if (sps->palette_mode_enabled_flag) {
1175  sps->palette_max_size = get_ue_golomb(gb);
1176  sps->delta_palette_max_predictor_size = get_ue_golomb(gb);
1177  sps->sps_palette_predictor_initializers_present_flag = get_bits1(gb);
1178 
1179  if (sps->sps_palette_predictor_initializers_present_flag) {
1180  sps->sps_num_palette_predictor_initializers = get_ue_golomb(gb) + 1;
1181  if (sps->sps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1182  av_log(avctx, AV_LOG_ERROR,
1183  "sps_num_palette_predictor_initializers out of range: %u\n",
1184  sps->sps_num_palette_predictor_initializers);
1185  return AVERROR_INVALIDDATA;
1186  }
1187  num_comps = !sps->chroma_format_idc ? 1 : 3;
1188  for (int comp = 0; comp < num_comps; comp++) {
1189  int bit_depth = !comp ? sps->bit_depth : sps->bit_depth_chroma;
1190  for (i = 0; i < sps->sps_num_palette_predictor_initializers; i++)
1191  sps->sps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
1192  }
1193  }
1194  }
1195  sps->motion_vector_resolution_control_idc = get_bits(gb, 2);
1196  sps->intra_boundary_filtering_disabled_flag = get_bits1(gb);
1197  }
1198  }
1199  if (apply_defdispwin) {
1200  sps->output_window.left_offset += sps->vui.def_disp_win.left_offset;
1201  sps->output_window.right_offset += sps->vui.def_disp_win.right_offset;
1202  sps->output_window.top_offset += sps->vui.def_disp_win.top_offset;
1203  sps->output_window.bottom_offset += sps->vui.def_disp_win.bottom_offset;
1204  }
1205 
1206  ow = &sps->output_window;
1207  if (ow->left_offset >= INT_MAX - ow->right_offset ||
1208  ow->top_offset >= INT_MAX - ow->bottom_offset ||
1209  ow->left_offset + ow->right_offset >= sps->width ||
1210  ow->top_offset + ow->bottom_offset >= sps->height) {
1211  av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
1212  ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1213  if (avctx->err_recognition & AV_EF_EXPLODE) {
1214  return AVERROR_INVALIDDATA;
1215  }
1216  av_log(avctx, AV_LOG_WARNING,
1217  "Displaying the whole video surface.\n");
1218  memset(ow, 0, sizeof(*ow));
1219  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1220  }
1221 
1222  // Inferred parameters
1223  sps->log2_ctb_size = sps->log2_min_cb_size +
1224  sps->log2_diff_max_min_coding_block_size;
1225  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1226 
1227  if (sps->log2_ctb_size > HEVC_MAX_LOG2_CTB_SIZE) {
1228  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1229  return AVERROR_INVALIDDATA;
1230  }
1231  if (sps->log2_ctb_size < 4) {
1232  av_log(avctx,
1233  AV_LOG_ERROR,
1234  "log2_ctb_size %d differs from the bounds of any known profile\n",
1235  sps->log2_ctb_size);
1236  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1237  return AVERROR_INVALIDDATA;
1238  }
1239 
1240  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1241  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1242  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1243 
1244  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1245  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1246  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1247  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1248  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1249  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1250  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1251 
1252  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1253 
1254  if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
1255  av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1256  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1257  return AVERROR_INVALIDDATA;
1258  }
1259 
1260  if (sps->max_transform_hierarchy_depth_inter > sps->log2_ctb_size - sps->log2_min_tb_size) {
1261  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1262  sps->max_transform_hierarchy_depth_inter);
1263  return AVERROR_INVALIDDATA;
1264  }
1265  if (sps->max_transform_hierarchy_depth_intra > sps->log2_ctb_size - sps->log2_min_tb_size) {
1266  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1267  sps->max_transform_hierarchy_depth_intra);
1268  return AVERROR_INVALIDDATA;
1269  }
1270  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1271  av_log(avctx, AV_LOG_ERROR,
1272  "max transform block size out of range: %d\n",
1273  sps->log2_max_trafo_size);
1274  return AVERROR_INVALIDDATA;
1275  }
1276 
1277  if (get_bits_left(gb) < 0) {
1278  av_log(avctx, AV_LOG_ERROR,
1279  "Overread SPS by %d bits\n", -get_bits_left(gb));
1280  return AVERROR_INVALIDDATA;
1281  }
1282 
1283  return 0;
1284 }
1285 
1287  HEVCParamSets *ps, int apply_defdispwin)
1288 {
1289  HEVCSPS *sps = ff_refstruct_allocz(sizeof(*sps));
1290  unsigned int sps_id;
1291  int ret;
1292  ptrdiff_t nal_size;
1293 
1294  if (!sps)
1295  return AVERROR(ENOMEM);
1296 
1297  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1298 
1299  nal_size = gb->buffer_end - gb->buffer;
1300  if (nal_size > sizeof(sps->data)) {
1301  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized SPS "
1302  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1303  nal_size, sizeof(sps->data));
1304  sps->data_size = sizeof(sps->data);
1305  } else {
1306  sps->data_size = nal_size;
1307  }
1308  memcpy(sps->data, gb->buffer, sps->data_size);
1309 
1310  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1311  apply_defdispwin,
1312  ps->vps_list, avctx);
1313  if (ret < 0) {
1315  return ret;
1316  }
1317 
1318  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1319  av_log(avctx, AV_LOG_DEBUG,
1320  "Parsed SPS: id %d; coded wxh: %dx%d; "
1321  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1322  sps_id, sps->width, sps->height,
1323  sps->width - (sps->output_window.left_offset + sps->output_window.right_offset),
1324  sps->height - (sps->output_window.top_offset + sps->output_window.bottom_offset),
1325  av_get_pix_fmt_name(sps->pix_fmt));
1326  }
1327 
1328  /* check if this is a repeat of an already parsed SPS, then keep the
1329  * original one.
1330  * otherwise drop all PPSes that depend on it */
1331  if (ps->sps_list[sps_id] &&
1332  !memcmp(ps->sps_list[sps_id], sps, sizeof(*sps))) {
1334  } else {
1335  remove_sps(ps, sps_id);
1336  ps->sps_list[sps_id] = sps;
1337  }
1338 
1339  return 0;
1340 }
1341 
1342 static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
1343 {
1344  HEVCPPS *pps = obj;
1345 
1346  av_freep(&pps->column_width);
1347  av_freep(&pps->row_height);
1348  av_freep(&pps->col_bd);
1349  av_freep(&pps->row_bd);
1350  av_freep(&pps->col_idxX);
1351  av_freep(&pps->ctb_addr_rs_to_ts);
1352  av_freep(&pps->ctb_addr_ts_to_rs);
1353  av_freep(&pps->tile_pos_rs);
1354  av_freep(&pps->tile_id);
1355  av_freep(&pps->min_tb_addr_zs_tab);
1356 }
1357 
1358 static void colour_mapping_octants(GetBitContext *gb, HEVCPPS *pps, int inp_depth,
1359  int idx_y, int idx_cb, int idx_cr, int inp_length)
1360 {
1361  unsigned int split_octant_flag, part_num_y, coded_res_flag, res_coeff_q, res_coeff_r;
1362  int cm_res_bits;
1363 
1364  part_num_y = 1 << pps->cm_y_part_num_log2;
1365 
1366  split_octant_flag = inp_depth < pps->cm_octant_depth ? get_bits1(gb) : 0;
1367 
1368  if (split_octant_flag)
1369  for (int k = 0; k < 2; k++)
1370  for (int m = 0; m < 2; m++)
1371  for (int n = 0; n < 2; n++)
1372  colour_mapping_octants(gb, pps, inp_depth + 1,
1373  idx_y + part_num_y * k * inp_length / 2,
1374  idx_cb + m * inp_length / 2,
1375  idx_cr + n * inp_length / 2,
1376  inp_length / 2);
1377  else
1378  for (int i = 0; i < part_num_y; i++) {
1379  for (int j = 0; j < 4; j++) {
1380  coded_res_flag = get_bits1(gb);
1381  if (coded_res_flag)
1382  for (int c = 0; c < 3; c++) {
1383  res_coeff_q = get_ue_golomb_long(gb);
1384  cm_res_bits = FFMAX(0, 10 + pps->luma_bit_depth_cm_input -
1385  pps->luma_bit_depth_cm_output -
1386  pps->cm_res_quant_bits - pps->cm_delta_flc_bits);
1387  res_coeff_r = cm_res_bits ? get_bits(gb, cm_res_bits) : 0;
1388  if (res_coeff_q || res_coeff_r)
1389  skip_bits1(gb);
1390  }
1391  }
1392  }
1393 }
1394 
1396 {
1397  pps->num_cm_ref_layers = get_ue_golomb(gb) + 1;
1398  if (pps->num_cm_ref_layers > 62) {
1399  av_log(avctx, AV_LOG_ERROR,
1400  "num_cm_ref_layers_minus1 shall be in the range [0, 61].\n");
1401  return AVERROR_INVALIDDATA;
1402  }
1403  for (int i = 0; i < pps->num_cm_ref_layers; i++)
1404  pps->cm_ref_layer_id[i] = get_bits(gb, 6);
1405 
1406  pps->cm_octant_depth = get_bits(gb, 2);
1407  pps->cm_y_part_num_log2 = get_bits(gb, 2);
1408 
1409  pps->luma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1410  pps->chroma_bit_depth_cm_input = get_ue_golomb(gb) + 8;
1411  pps->luma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1412  pps->chroma_bit_depth_cm_output = get_ue_golomb(gb) + 8;
1413 
1414  pps->cm_res_quant_bits = get_bits(gb, 2);
1415  pps->cm_delta_flc_bits = get_bits(gb, 2) + 1;
1416 
1417  if (pps->cm_octant_depth == 1) {
1418  pps->cm_adapt_threshold_u_delta = get_se_golomb_long(gb);
1419  pps->cm_adapt_threshold_v_delta = get_se_golomb_long(gb);
1420  }
1421 
1422  colour_mapping_octants(gb, pps, 0, 0, 0, 0, 1 << pps->cm_octant_depth);
1423 
1424  return 0;
1425 }
1426 
1428  HEVCPPS *pps, const HEVCSPS *sps, const HEVCVPS *vps)
1429 {
1430  pps->poc_reset_info_present_flag = get_bits1(gb);
1431  pps->pps_infer_scaling_list_flag = get_bits1(gb);
1432  if (pps->pps_infer_scaling_list_flag)
1433  pps->pps_scaling_list_ref_layer_id = get_bits(gb, 6);
1434 
1435  pps->num_ref_loc_offsets = get_ue_golomb(gb);
1436  if (pps->num_ref_loc_offsets > vps->vps_max_layers - 1)
1437  return AVERROR_INVALIDDATA;
1438 
1439  for (int i = 0; i < pps->num_ref_loc_offsets; i++) {
1440  pps->ref_loc_offset_layer_id[i] = get_bits(gb, 6);
1441  pps->scaled_ref_layer_offset_present_flag[i] = get_bits1(gb);
1442  if (pps->scaled_ref_layer_offset_present_flag[i]) {
1443  pps->scaled_ref_layer_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1444  pps->scaled_ref_layer_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1445  pps->scaled_ref_layer_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1446  pps->scaled_ref_layer_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1447  }
1448 
1449  pps->ref_region_offset_present_flag[i] = get_bits1(gb);
1450  if (pps->ref_region_offset_present_flag[i]) {
1451  pps->ref_region_left_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1452  pps->ref_region_top_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1453  pps->ref_region_right_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1454  pps->ref_region_bottom_offset[pps->ref_loc_offset_layer_id[i]] = get_se_golomb_long(gb);
1455  }
1456 
1457  pps->resample_phase_set_present_flag[i] = get_bits1(gb);
1458  if (pps->resample_phase_set_present_flag[i]) {
1459  pps->phase_hor_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1460  pps->phase_ver_luma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb_31(gb);
1461  pps->phase_hor_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1462  pps->phase_ver_chroma[pps->ref_loc_offset_layer_id[i]] = get_ue_golomb(gb) - 8;
1463  }
1464  }
1465 
1466  pps->colour_mapping_enabled_flag = get_bits1(gb);
1467  if (pps->colour_mapping_enabled_flag) {
1468  int ret = colour_mapping_table(gb, avctx, pps);
1469  if (ret < 0)
1470  return ret;
1471  }
1472 
1473  return 0;
1474 }
1475 
1477 {
1478  unsigned int num_val_delta_dlt, max_diff = 0;
1479  int min_diff_minus1 = -1;
1480  unsigned int len;
1481 
1482  num_val_delta_dlt = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1483  if (num_val_delta_dlt) {
1484  if (num_val_delta_dlt > 1)
1485  max_diff = get_bits(gb, pps->pps_bit_depth_for_depth_layers_minus8 + 8);
1486  if (num_val_delta_dlt > 2 && max_diff) {
1487  len = av_log2(max_diff) + 1;
1488  min_diff_minus1 = get_bits(gb, len);
1489  }
1490  if (max_diff > (min_diff_minus1 + 1))
1491  for (int k = 1; k < num_val_delta_dlt; k++) {
1492  len = av_log2(max_diff - (min_diff_minus1 + 1)) + 1;
1493  skip_bits(gb, len); // delta_val_diff_minus_min
1494  }
1495  }
1496 }
1497 
1499  HEVCPPS *pps, const HEVCSPS *sps)
1500 {
1501  unsigned int pps_depth_layers_minus1;
1502 
1503  if (get_bits1(gb)) { // dlts_present_flag
1504  pps_depth_layers_minus1 = get_bits(gb, 6);
1505  pps->pps_bit_depth_for_depth_layers_minus8 = get_bits(gb, 4);
1506  for (int i = 0; i <= pps_depth_layers_minus1; i++) {
1507  if (get_bits1(gb)) { // dlt_flag[i]
1508  if (!get_bits1(gb)) { // dlt_pred_flag[i]
1509  if (get_bits1(gb)) { // dlt_val_flags_present_flag[i]
1510  for (int j = 0; j <= ((1 << (pps->pps_bit_depth_for_depth_layers_minus8 + 8)) - 1); j++)
1511  skip_bits1(gb); // dlt_value_flag[i][j]
1512  } else
1513  delta_dlt(gb, pps);
1514  }
1515  }
1516  }
1517  }
1518 
1519  return 0;
1520 }
1521 
1523  HEVCPPS *pps, const HEVCSPS *sps)
1524 {
1525  if (pps->transform_skip_enabled_flag) {
1526  pps->log2_max_transform_skip_block_size = get_ue_golomb_31(gb) + 2;
1527  }
1528  pps->cross_component_prediction_enabled_flag = get_bits1(gb);
1529  pps->chroma_qp_offset_list_enabled_flag = get_bits1(gb);
1530  if (pps->chroma_qp_offset_list_enabled_flag) {
1531  pps->diff_cu_chroma_qp_offset_depth = get_ue_golomb_31(gb);
1532  pps->chroma_qp_offset_list_len_minus1 = get_ue_golomb_31(gb);
1533  if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1534  av_log(avctx, AV_LOG_ERROR,
1535  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1536  return AVERROR_INVALIDDATA;
1537  }
1538  for (int i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1539  pps->cb_qp_offset_list[i] = get_se_golomb(gb);
1540  if (pps->cb_qp_offset_list[i]) {
1541  av_log(avctx, AV_LOG_WARNING,
1542  "cb_qp_offset_list not tested yet.\n");
1543  }
1544  pps->cr_qp_offset_list[i] = get_se_golomb(gb);
1545  if (pps->cr_qp_offset_list[i]) {
1546  av_log(avctx, AV_LOG_WARNING,
1547  "cb_qp_offset_list not tested yet.\n");
1548  }
1549  }
1550  }
1551  pps->log2_sao_offset_scale_luma = get_ue_golomb_31(gb);
1552  pps->log2_sao_offset_scale_chroma = get_ue_golomb_31(gb);
1553 
1554  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1555  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1556  )
1557  return AVERROR_INVALIDDATA;
1558 
1559  return(0);
1560 }
1561 
1563  HEVCPPS *pps, const HEVCSPS *sps)
1564 {
1565  int num_comps, ret;
1566 
1567  pps->pps_curr_pic_ref_enabled_flag = get_bits1(gb);
1568  if (pps->residual_adaptive_colour_transform_enabled_flag = get_bits1(gb)) {
1569  pps->pps_slice_act_qp_offsets_present_flag = get_bits1(gb);
1570  pps->pps_act_y_qp_offset = get_se_golomb(gb) - 5;
1571  pps->pps_act_cb_qp_offset = get_se_golomb(gb) - 5;
1572  pps->pps_act_cr_qp_offset = get_se_golomb(gb) - 3;
1573 
1574 #define CHECK_QP_OFFSET(name) (pps->pps_act_ ## name ## _qp_offset <= -12 || \
1575  pps->pps_act_ ## name ## _qp_offset >= 12)
1577 #undef CHECK_QP_OFFSET
1578  if (ret) {
1579  av_log(avctx, AV_LOG_ERROR,
1580  "PpsActQpOffsetY/Cb/Cr shall be in the range of [-12, 12].\n");
1581  return AVERROR_INVALIDDATA;
1582  }
1583  }
1584 
1585  if (pps->pps_palette_predictor_initializers_present_flag = get_bits1(gb)) {
1586  pps->pps_num_palette_predictor_initializers = get_ue_golomb(gb);
1587  if (pps->pps_num_palette_predictor_initializers > 0) {
1588  if (pps->pps_num_palette_predictor_initializers > HEVC_MAX_PALETTE_PREDICTOR_SIZE) {
1589  av_log(avctx, AV_LOG_ERROR,
1590  "pps_num_palette_predictor_initializers out of range: %u\n",
1591  pps->pps_num_palette_predictor_initializers);
1592  return AVERROR_INVALIDDATA;
1593  }
1594  pps->monochrome_palette_flag = get_bits1(gb);
1595  pps->luma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
1596  if (pps->luma_bit_depth_entry != sps->bit_depth)
1597  return AVERROR_INVALIDDATA;
1598  if (!pps->monochrome_palette_flag) {
1599  pps->chroma_bit_depth_entry = get_ue_golomb_31(gb) + 8;
1600  if (pps->chroma_bit_depth_entry != sps->bit_depth_chroma)
1601  return AVERROR_INVALIDDATA;
1602  }
1603 
1604  num_comps = pps->monochrome_palette_flag ? 1 : 3;
1605  for (int comp = 0; comp < num_comps; comp++) {
1606  int bit_depth = !comp ? pps->luma_bit_depth_entry : pps->chroma_bit_depth_entry;
1607  for (int i = 0; i < pps->pps_num_palette_predictor_initializers; i++)
1608  pps->pps_palette_predictor_initializer[comp][i] = get_bits(gb, bit_depth);
1609  }
1610  }
1611  }
1612 
1613  return 0;
1614 }
1615 
1616 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1617  HEVCPPS *pps, const HEVCSPS *sps)
1618 {
1619  int log2_diff;
1620  int pic_area_in_ctbs;
1621  int i, j, x, y, ctb_addr_rs, tile_id;
1622 
1623  // Inferred parameters
1624  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1625  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1626  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1627  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1628  return AVERROR(ENOMEM);
1629 
1630  if (pps->uniform_spacing_flag) {
1631  if (!pps->column_width) {
1632  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1633  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1634  }
1635  if (!pps->column_width || !pps->row_height)
1636  return AVERROR(ENOMEM);
1637 
1638  for (i = 0; i < pps->num_tile_columns; i++) {
1639  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1640  (i * sps->ctb_width) / pps->num_tile_columns;
1641  }
1642 
1643  for (i = 0; i < pps->num_tile_rows; i++) {
1644  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1645  (i * sps->ctb_height) / pps->num_tile_rows;
1646  }
1647  }
1648 
1649  pps->col_bd[0] = 0;
1650  for (i = 0; i < pps->num_tile_columns; i++)
1651  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1652 
1653  pps->row_bd[0] = 0;
1654  for (i = 0; i < pps->num_tile_rows; i++)
1655  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1656 
1657  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1658  if (i > pps->col_bd[j])
1659  j++;
1660  pps->col_idxX[i] = j;
1661  }
1662 
1663  /**
1664  * 6.5
1665  */
1666  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1667 
1668  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1669  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1670  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1671  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1672  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1673  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1674  return AVERROR(ENOMEM);
1675  }
1676 
1677  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1678  int tb_x = ctb_addr_rs % sps->ctb_width;
1679  int tb_y = ctb_addr_rs / sps->ctb_width;
1680  int tile_x = 0;
1681  int tile_y = 0;
1682  int val = 0;
1683 
1684  for (i = 0; i < pps->num_tile_columns; i++) {
1685  if (tb_x < pps->col_bd[i + 1]) {
1686  tile_x = i;
1687  break;
1688  }
1689  }
1690 
1691  for (i = 0; i < pps->num_tile_rows; i++) {
1692  if (tb_y < pps->row_bd[i + 1]) {
1693  tile_y = i;
1694  break;
1695  }
1696  }
1697 
1698  for (i = 0; i < tile_x; i++)
1699  val += pps->row_height[tile_y] * pps->column_width[i];
1700  for (i = 0; i < tile_y; i++)
1701  val += sps->ctb_width * pps->row_height[i];
1702 
1703  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1704  tb_x - pps->col_bd[tile_x];
1705 
1706  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1707  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1708  }
1709 
1710  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1711  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1712  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1713  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1714  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1715 
1716  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1717  if (!pps->tile_pos_rs)
1718  return AVERROR(ENOMEM);
1719 
1720  for (j = 0; j < pps->num_tile_rows; j++)
1721  for (i = 0; i < pps->num_tile_columns; i++)
1722  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1723  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1724 
1725  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1726  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1727  for (y = 0; y < sps->tb_mask+2; y++) {
1728  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1729  pps->min_tb_addr_zs_tab[y] = -1;
1730  }
1731  for (y = 0; y < sps->tb_mask+1; y++) {
1732  for (x = 0; x < sps->tb_mask+1; x++) {
1733  int tb_x = x >> log2_diff;
1734  int tb_y = y >> log2_diff;
1735  int rs = sps->ctb_width * tb_y + tb_x;
1736  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1737  for (i = 0; i < log2_diff; i++) {
1738  int m = 1 << i;
1739  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1740  }
1741  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1742  }
1743  }
1744 
1745  return 0;
1746 }
1747 
1749  HEVCParamSets *ps)
1750 {
1751  const HEVCSPS *sps = NULL;
1752  const HEVCVPS *vps = NULL;
1753  int i, ret = 0;
1754  unsigned int pps_id = 0;
1755  ptrdiff_t nal_size;
1756  unsigned log2_parallel_merge_level_minus2;
1757 
1759 
1760  if (!pps)
1761  return AVERROR(ENOMEM);
1762 
1763  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1764 
1765  nal_size = gb->buffer_end - gb->buffer;
1766  if (nal_size > sizeof(pps->data)) {
1767  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized PPS "
1768  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1769  nal_size, sizeof(pps->data));
1770  pps->data_size = sizeof(pps->data);
1771  } else {
1772  pps->data_size = nal_size;
1773  }
1774  memcpy(pps->data, gb->buffer, pps->data_size);
1775 
1776  // Default values
1777  pps->loop_filter_across_tiles_enabled_flag = 1;
1778  pps->num_tile_columns = 1;
1779  pps->num_tile_rows = 1;
1780  pps->uniform_spacing_flag = 1;
1781  pps->disable_dbf = 0;
1782  pps->beta_offset = 0;
1783  pps->tc_offset = 0;
1784  pps->log2_max_transform_skip_block_size = 2;
1785 
1786  // Coded parameters
1787  pps_id = pps->pps_id = get_ue_golomb_long(gb);
1788  if (pps_id >= HEVC_MAX_PPS_COUNT) {
1789  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1791  goto err;
1792  }
1793  pps->sps_id = get_ue_golomb_long(gb);
1794  if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
1795  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1797  goto err;
1798  }
1799  if (!ps->sps_list[pps->sps_id]) {
1800  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1802  goto err;
1803  }
1804  sps = ps->sps_list[pps->sps_id];
1805  vps = ps->vps_list[sps->vps_id];
1806 
1807  pps->dependent_slice_segments_enabled_flag = get_bits1(gb);
1808  pps->output_flag_present_flag = get_bits1(gb);
1809  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1810 
1811  pps->sign_data_hiding_flag = get_bits1(gb);
1812 
1813  pps->cabac_init_present_flag = get_bits1(gb);
1814 
1815  pps->num_ref_idx_l0_default_active = get_ue_golomb_31(gb) + 1;
1816  pps->num_ref_idx_l1_default_active = get_ue_golomb_31(gb) + 1;
1817  if (pps->num_ref_idx_l0_default_active >= HEVC_MAX_REFS ||
1818  pps->num_ref_idx_l1_default_active >= HEVC_MAX_REFS) {
1819  av_log(avctx, AV_LOG_ERROR, "Too many default refs in PPS: %d/%d.\n",
1820  pps->num_ref_idx_l0_default_active, pps->num_ref_idx_l1_default_active);
1821  goto err;
1822  }
1823 
1824  pps->pic_init_qp_minus26 = get_se_golomb(gb);
1825 
1826  pps->constrained_intra_pred_flag = get_bits1(gb);
1827  pps->transform_skip_enabled_flag = get_bits1(gb);
1828 
1829  pps->cu_qp_delta_enabled_flag = get_bits1(gb);
1830  pps->diff_cu_qp_delta_depth = 0;
1831  if (pps->cu_qp_delta_enabled_flag)
1832  pps->diff_cu_qp_delta_depth = get_ue_golomb_long(gb);
1833 
1834  if (pps->diff_cu_qp_delta_depth < 0 ||
1835  pps->diff_cu_qp_delta_depth > sps->log2_diff_max_min_coding_block_size) {
1836  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1837  pps->diff_cu_qp_delta_depth);
1839  goto err;
1840  }
1841 
1842  pps->cb_qp_offset = get_se_golomb(gb);
1843  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1844  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1845  pps->cb_qp_offset);
1847  goto err;
1848  }
1849  pps->cr_qp_offset = get_se_golomb(gb);
1850  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1851  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1852  pps->cr_qp_offset);
1854  goto err;
1855  }
1856  pps->pic_slice_level_chroma_qp_offsets_present_flag = get_bits1(gb);
1857 
1858  pps->weighted_pred_flag = get_bits1(gb);
1859  pps->weighted_bipred_flag = get_bits1(gb);
1860 
1861  pps->transquant_bypass_enable_flag = get_bits1(gb);
1862  pps->tiles_enabled_flag = get_bits1(gb);
1863  pps->entropy_coding_sync_enabled_flag = get_bits1(gb);
1864 
1865  if (pps->tiles_enabled_flag) {
1866  int num_tile_columns_minus1 = get_ue_golomb(gb);
1867  int num_tile_rows_minus1 = get_ue_golomb(gb);
1868 
1869  if (num_tile_columns_minus1 < 0 ||
1870  num_tile_columns_minus1 >= sps->ctb_width) {
1871  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1872  num_tile_columns_minus1);
1873  ret = num_tile_columns_minus1 < 0 ? num_tile_columns_minus1 : AVERROR_INVALIDDATA;
1874  goto err;
1875  }
1876  if (num_tile_rows_minus1 < 0 ||
1877  num_tile_rows_minus1 >= sps->ctb_height) {
1878  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1879  num_tile_rows_minus1);
1880  ret = num_tile_rows_minus1 < 0 ? num_tile_rows_minus1 : AVERROR_INVALIDDATA;
1881  goto err;
1882  }
1883  pps->num_tile_columns = num_tile_columns_minus1 + 1;
1884  pps->num_tile_rows = num_tile_rows_minus1 + 1;
1885 
1886  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1887  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1888  if (!pps->column_width || !pps->row_height) {
1889  ret = AVERROR(ENOMEM);
1890  goto err;
1891  }
1892 
1893  pps->uniform_spacing_flag = get_bits1(gb);
1894  if (!pps->uniform_spacing_flag) {
1895  uint64_t sum = 0;
1896  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1897  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1898  sum += pps->column_width[i];
1899  }
1900  if (sum >= sps->ctb_width) {
1901  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1903  goto err;
1904  }
1905  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1906 
1907  sum = 0;
1908  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1909  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1910  sum += pps->row_height[i];
1911  }
1912  if (sum >= sps->ctb_height) {
1913  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1915  goto err;
1916  }
1917  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1918  }
1919  pps->loop_filter_across_tiles_enabled_flag = get_bits1(gb);
1920  }
1921 
1922  pps->seq_loop_filter_across_slices_enabled_flag = get_bits1(gb);
1923 
1924  pps->deblocking_filter_control_present_flag = get_bits1(gb);
1925  if (pps->deblocking_filter_control_present_flag) {
1926  pps->deblocking_filter_override_enabled_flag = get_bits1(gb);
1927  pps->disable_dbf = get_bits1(gb);
1928  if (!pps->disable_dbf) {
1929  int beta_offset_div2 = get_se_golomb(gb);
1930  int tc_offset_div2 = get_se_golomb(gb) ;
1931  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1932  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1933  beta_offset_div2);
1935  goto err;
1936  }
1937  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1938  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1939  tc_offset_div2);
1941  goto err;
1942  }
1943  pps->beta_offset = 2 * beta_offset_div2;
1944  pps->tc_offset = 2 * tc_offset_div2;
1945  }
1946  }
1947 
1948  pps->scaling_list_data_present_flag = get_bits1(gb);
1949  if (pps->scaling_list_data_present_flag) {
1950  set_default_scaling_list_data(&pps->scaling_list);
1951  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1952  if (ret < 0)
1953  goto err;
1954  }
1955  pps->lists_modification_present_flag = get_bits1(gb);
1956  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
1957  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
1958  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1959  log2_parallel_merge_level_minus2);
1961  goto err;
1962  }
1963  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1964 
1965  pps->slice_header_extension_present_flag = get_bits1(gb);
1966 
1967  pps->pps_extension_present_flag = get_bits1(gb);
1968  if (pps->pps_extension_present_flag) {
1969  pps->pps_range_extensions_flag = get_bits1(gb);
1970  pps->pps_multilayer_extension_flag = get_bits1(gb);
1971  pps->pps_3d_extension_flag = get_bits1(gb);
1972  pps->pps_scc_extension_flag = get_bits1(gb);
1973  skip_bits(gb, 4); // pps_extension_4bits
1974 
1975  if (sps->ptl.general_ptl.profile_idc >= AV_PROFILE_HEVC_REXT && pps->pps_range_extensions_flag) {
1976  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1977  goto err;
1978  }
1979 
1980  if (pps->pps_multilayer_extension_flag) {
1981  if ((ret = pps_multilayer_extension(gb, avctx, pps, sps, vps)) < 0)
1982  goto err;
1983  }
1984 
1985  if (pps->pps_3d_extension_flag) {
1986  if ((ret = pps_3d_extension(gb, avctx, pps, sps)) < 0)
1987  goto err;
1988  }
1989 
1990  if (pps->pps_scc_extension_flag) {
1991  if ((ret = pps_scc_extension(gb, avctx, pps, sps)) < 0)
1992  goto err;
1993  }
1994  }
1995 
1996  ret = setup_pps(avctx, gb, pps, sps);
1997  if (ret < 0)
1998  goto err;
1999 
2000  if (get_bits_left(gb) < 0) {
2001  av_log(avctx, AV_LOG_WARNING,
2002  "Overread PPS by %d bits\n", -get_bits_left(gb));
2003  }
2004 
2005  remove_pps(ps, pps_id);
2006  ps->pps_list[pps_id] = pps;
2007 
2008  return 0;
2009 
2010 err:
2012  return ret;
2013 }
2014 
2016 {
2017  int i;
2018 
2019  for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
2020  ff_refstruct_unref(&ps->vps_list[i]);
2021  for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
2022  ff_refstruct_unref(&ps->sps_list[i]);
2023  for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
2024  ff_refstruct_unref(&ps->pps_list[i]);
2025 
2026  ps->sps = NULL;
2027  ps->pps = NULL;
2028  ps->vps = NULL;
2029 }
2030 
2031 int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
2032 {
2033  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
2034  int prev_poc_lsb = pocTid0 % max_poc_lsb;
2035  int prev_poc_msb = pocTid0 - prev_poc_lsb;
2036  int poc_msb;
2037 
2038  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
2039  poc_msb = prev_poc_msb + max_poc_lsb;
2040  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
2041  poc_msb = prev_poc_msb - max_poc_lsb;
2042  else
2043  poc_msb = prev_poc_msb;
2044 
2045  // For BLA picture types, POCmsb is set to 0.
2046  if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
2047  nal_unit_type == HEVC_NAL_BLA_W_RADL ||
2048  nal_unit_type == HEVC_NAL_BLA_N_LP)
2049  poc_msb = 0;
2050 
2051  return poc_msb + poc_lsb;
2052 }
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:186
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
colour_mapping_table
static int colour_mapping_table(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps)
Definition: hevc_ps.c:1395
ShortTermRPS::used
uint8_t used[32]
Definition: hevc_ps.h:84
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
VUI::vui_time_scale
uint32_t vui_time_scale
Definition: hevc_ps.h:107
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
CHECK_QP_OFFSET
#define CHECK_QP_OFFSET(name)
ShortTermRPS::delta_poc_s0
int32_t delta_poc_s0[32]
Definition: hevc_ps.h:81
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:241
HEVCWindow::bottom_offset
unsigned int bottom_offset
Definition: hevc_ps.h:91
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:80
HEVCParamSets::pps_list
const HEVCPPS * pps_list[HEVC_MAX_PPS_COUNT]
RefStruct references.
Definition: hevc_ps.h:442
remove_vps
static void remove_vps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:87
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
ff_hevc_diag_scan8x8_y
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
pps_scc_extension
static int pps_scc_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: hevc_ps.c:1562
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1420
remove_sps
static void remove_sps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:70
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
remove_pps
static void remove_pps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:63
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
decode_hrd
static int decode_hrd(GetBitContext *gb, int common_inf_present, HEVCHdrParams *hdr, int max_sublayers)
Definition: hevc_ps.c:377
H2645VUI::matrix_coeffs
enum AVColorSpace matrix_coeffs
Definition: h2645_vui.h:41
HEVCSublayerHdrParams::cbr_flag
uint32_t cbr_flag
Definition: hevc_ps.h:39
AV_PROFILE_HEVC_MAIN
#define AV_PROFILE_HEVC_MAIN
Definition: defs.h:158
av_mod_uintp2
#define av_mod_uintp2
Definition: common.h:125
map_pixel_format
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
Definition: hevc_ps.c:820
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
HEVC_MAX_SHORT_TERM_REF_PIC_SETS
@ HEVC_MAX_SHORT_TERM_REF_PIC_SETS
Definition: hevc.h:122
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
HEVCHdrParams::dpb_output_delay_du_length_minus1
uint8_t dpb_output_delay_du_length_minus1
Definition: hevc_ps.h:58
HEVCHdrFlagParams::low_delay_hrd_flag
uint8_t low_delay_hrd_flag
Definition: hevc_ps.h:46
VUI::tiles_fixed_structure_flag
int tiles_fixed_structure_flag
Definition: hevc_ps.h:113
ShortTermRPS::rps_predict
uint8_t rps_predict
Definition: hevc_ps.h:73
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:478
VUI::vui_num_ticks_poc_diff_one_minus1
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc_ps.h:109
ScalingList::sl
uint8_t sl[4][6][64]
Definition: hevc_ps.h:183
VUI::field_seq_flag
int field_seq_flag
Definition: hevc_ps.h:99
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:610
VUI::bitstream_restriction_flag
int bitstream_restriction_flag
Definition: hevc_ps.h:112
HEVC_NAL_BLA_W_RADL
@ HEVC_NAL_BLA_W_RADL
Definition: hevc.h:46
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
HEVCHdrParams::elemental_duration_in_tc_minus1
uint16_t elemental_duration_in_tc_minus1[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:66
HEVC_MAX_PPS_COUNT
@ HEVC_MAX_PPS_COUNT
Definition: hevc.h:114
bit_depth
static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)
Definition: af_astats.c:245
HEVCHdrParams
Definition: hevc_ps.h:49
H2645VUI::video_full_range_flag
int video_full_range_flag
Definition: h2645_vui.h:37
pps_multilayer_extension
static int pps_multilayer_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps, const HEVCVPS *vps)
Definition: hevc_ps.c:1427
AV_PIX_FMT_GRAY9
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:458
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: hevc_ps.h:52
HEVCSublayerHdrParams::bit_rate_value_minus1
uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]
Definition: hevc_ps.h:35
H2645VUI::video_signal_type_present_flag
int video_signal_type_present_flag
Definition: h2645_vui.h:35
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
pps_3d_extension
static int pps_3d_extension(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: hevc_ps.c:1498
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:494
HEVCWindow::left_offset
unsigned int left_offset
Definition: hevc_ps.h:88
GetBitContext
Definition: get_bits.h:108
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:476
H265RawProfileTierLevel::sub_layer_level_present_flag
uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:63
hevc_sub_width_c
static const uint8_t hevc_sub_width_c[]
Definition: hevc_ps.c:55
HEVCHdrParams::sub_pic_hrd_params_present_flag
uint8_t sub_pic_hrd_params_present_flag
Definition: hevc_ps.h:53
HEVCSublayerHdrParams::bit_rate_du_value_minus1
uint32_t bit_rate_du_value_minus1[HEVC_MAX_CPB_CNT]
Definition: hevc_ps.h:38
val
static double val(void *priv, double ch)
Definition: aeval.c:78
HEVCSublayerHdrParams::cpb_size_du_value_minus1
uint32_t cpb_size_du_value_minus1[HEVC_MAX_CPB_CNT]
Definition: hevc_ps.h:37
HEVCParamSets::sps_list
const HEVCSPS * sps_list[HEVC_MAX_SPS_COUNT]
RefStruct references.
Definition: hevc_ps.h:441
ShortTermRPS::num_delta_pocs
int num_delta_pocs
Definition: hevc_ps.h:79
refstruct.h
VUI::restricted_ref_pic_lists_flag
int restricted_ref_pic_lists_flag
Definition: hevc_ps.h:115
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:481
H265RawProfileTierLevel::sub_layer_profile_present_flag
uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: cbs_h265.h:62
HEVCHdrParams::nal_hrd_parameters_present_flag
uint8_t nal_hrd_parameters_present_flag
Definition: hevc_ps.h:51
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
HEVC_NAL_BLA_N_LP
@ HEVC_NAL_BLA_N_LP
Definition: hevc.h:47
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
HEVCHdrParams::cpb_size_scale
uint8_t cpb_size_scale
Definition: hevc_ps.h:60
ptl
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
PTLCommon
Definition: hevc_ps.h:123
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_hevc_diag_scan8x8_x
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
AV_PROFILE_HEVC_SCC
#define AV_PROFILE_HEVC_SCC
Definition: defs.h:162
HEVCHdrParams::vcl_params
HEVCSublayerHdrParams vcl_params[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:69
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
HEVC_MAX_REFS
@ HEVC_MAX_REFS
Definition: hevc.h:119
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:475
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
VUI::motion_vectors_over_pic_boundaries_flag
int motion_vectors_over_pic_boundaries_flag
Definition: hevc_ps.h:114
HEVCWindow::top_offset
unsigned int top_offset
Definition: hevc_ps.h:90
HEVC_MAX_LONG_TERM_REF_PICS
@ HEVC_MAX_LONG_TERM_REF_PICS
Definition: hevc.h:124
default_scaling_list_inter
static const uint8_t default_scaling_list_inter[]
Definition: hevc_ps.c:44
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: hevc_ps.h:180
ShortTermRPS::use_delta_flag
uint8_t use_delta_flag
Definition: hevc_ps.h:75
HEVCHdrParams::tick_divisor_minus2
uint8_t tick_divisor_minus2
Definition: hevc_ps.h:56
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
HEVC_MAX_SPS_COUNT
@ HEVC_MAX_SPS_COUNT
Definition: hevc.h:112
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:459
ff_hevc_diag_scan4x4_y
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
decode_vui
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: hevc_ps.c:586
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:140
NULL
#define NULL
Definition: coverity.c:32
H2645VUI::colour_description_present_flag
int colour_description_present_flag
Definition: h2645_vui.h:38
ScalingList::sl_dc
uint8_t sl_dc[2][6]
Definition: hevc_ps.h:184
VUI::frame_field_info_present_flag
int frame_field_info_present_flag
Definition: hevc_ps.h:100
ff_hevc_ps_uninit
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: hevc_ps.c:2015
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_hevc_parse_sps
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, int apply_defdispwin, const HEVCVPS *const *vps_list, AVCodecContext *avctx)
Parse the SPS from the bitstream into the provided HEVCSPS struct.
Definition: hevc_ps.c:869
VUI::vui_timing_info_present_flag
int vui_timing_info_present_flag
Definition: hevc_ps.h:105
ShortTermRPS::delta_idx
unsigned int delta_idx
Definition: hevc_ps.h:74
AV_PROFILE_HEVC_MAIN_STILL_PICTURE
#define AV_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: defs.h:160
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: hevc_ps.h:34
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
HEVCHdrFlagParams::fixed_pic_rate_general_flag
uint8_t fixed_pic_rate_general_flag
Definition: hevc_ps.h:44
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
VUI::log2_max_mv_length_horizontal
int log2_max_mv_length_horizontal
Definition: hevc_ps.h:119
HEVCParamSets::vps
const HEVCVPS * vps
Definition: hevc_ps.h:445
PTL
Definition: hevc_ps.h:146
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:479
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: hevc_ps.h:117
AV_PROFILE_HEVC_MAIN_10
#define AV_PROFILE_HEVC_MAIN_10
Definition: defs.h:159
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: hevc_ps.c:1358
AV_PROFILE_HEVC_REXT
#define AV_PROFILE_HEVC_REXT
Definition: defs.h:161
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: hevc_ps.h:36
HEVCWindow
Definition: hevc_ps.h:87
HEVCHdrParams::dpb_output_delay_length_minus1
uint8_t dpb_output_delay_length_minus1
Definition: hevc_ps.h:64
hevc_data.h
HEVC_MAX_LOG2_CTB_SIZE
@ HEVC_MAX_LOG2_CTB_SIZE
Definition: hevc.h:128
HEVC_MAX_DPB_SIZE
@ HEVC_MAX_DPB_SIZE
Definition: hevc.h:117
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:509
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
check_profile_idc
#define check_profile_idc(idc)
ff_hevc_decode_nal_sps
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1286
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:483
HEVC_NAL_BLA_W_LP
@ HEVC_NAL_BLA_W_LP
Definition: hevc.h:45
scaling_list_data
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, const HEVCSPS *sps)
Definition: hevc_ps.c:743
VUI::common
H2645VUI common
Definition: hevc_ps.h:95
VUI::def_disp_win
HEVCWindow def_disp_win
Definition: hevc_ps.h:103
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: hevc_ps.c:2031
VUI::vui_poc_proportional_to_timing_flag
int vui_poc_proportional_to_timing_flag
Definition: hevc_ps.h:108
VUI
Definition: hevc_ps.h:94
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:485
ff_hevc_decode_nal_vps
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:452
VUI::vui_num_units_in_tick
uint32_t vui_num_units_in_tick
Definition: hevc_ps.h:106
VUI::max_bits_per_min_cu_denom
int max_bits_per_min_cu_denom
Definition: hevc_ps.h:118
VUI::log2_max_mv_length_vertical
int log2_max_mv_length_vertical
Definition: hevc_ps.h:120
decode_profile_tier_level
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx, PTLCommon *ptl)
Definition: hevc_ps.c:243
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
HEVCHdrParams::bit_rate_scale
uint8_t bit_rate_scale
Definition: hevc_ps.h:59
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
ShortTermRPS::num_negative_pics
unsigned int num_negative_pics
Definition: hevc_ps.h:78
VUI::default_display_window_flag
int default_display_window_flag
Definition: hevc_ps.h:102
hevc_pps_free
static void hevc_pps_free(FFRefStructOpaque unused, void *obj)
Definition: hevc_ps.c:1342
hevc_ps.h
HEVCHdrParams::nal_params
HEVCSublayerHdrParams nal_params[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:68
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:371
HEVCParamSets::sps
const HEVCSPS * sps
Definition: hevc_ps.h:446
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:495
VUI::neutra_chroma_indication_flag
int neutra_chroma_indication_flag
Definition: hevc_ps.h:97
ShortTermRPS::rps_idx_num_delta_pocs
int rps_idx_num_delta_pocs
Definition: hevc_ps.h:80
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
len
int len
Definition: vorbis_enc_data.h:426
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:477
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:109
set_default_scaling_list_data
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:713
ret
ret
Definition: filter_design.txt:187
HEVCHdrFlagParams::fixed_pic_rate_within_cvs_flag
uint8_t fixed_pic_rate_within_cvs_flag
Definition: hevc_ps.h:45
h2645_vui.h
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
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:413
HEVCHdrParams::initial_cpb_removal_delay_length_minus1
uint8_t initial_cpb_removal_delay_length_minus1
Definition: hevc_ps.h:62
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:482
decode_sublayer_hrd
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, HEVCSublayerHdrParams *par, int subpic_params_present)
Definition: hevc_ps.c:359
U
#define U(x)
Definition: vpx_arith.h:37
HEVC_MAX_PALETTE_PREDICTOR_SIZE
@ HEVC_MAX_PALETTE_PREDICTOR_SIZE
Definition: hevc.h:159
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:141
ShortTermRPS::delta_rps_sign
uint8_t delta_rps_sign
Definition: hevc_ps.h:76
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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
parse_ptl
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:319
delta_dlt
static void delta_dlt(GetBitContext *gb, HEVCPPS *pps)
Definition: hevc_ps.c:1476
HEVCParamSets::pps
const HEVCPPS * pps
Definition: hevc_ps.h:447
HEVCWindow::right_offset
unsigned int right_offset
Definition: hevc_ps.h:89
ShortTermRPS
Definition: hevc_ps.h:72
ShortTermRPS::abs_delta_rps
unsigned int abs_delta_rps
Definition: hevc_ps.h:77
ff_hevc_diag_scan4x4_x
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
VUI::vui_hrd_parameters_present_flag
int vui_hrd_parameters_present_flag
Definition: hevc_ps.h:110
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
setup_pps
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, const HEVCSPS *sps)
Definition: hevc_ps.c:1616
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1396
VUI::min_spatial_segmentation_idc
int min_spatial_segmentation_idc
Definition: hevc_ps.h:116
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:75
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
HEVCVPS
Definition: hevc_ps.h:154
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: hevc_ps.h:187
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: hevc_ps.h:304
HEVCHdrParams::du_cpb_removal_delay_increment_length_minus1
uint8_t du_cpb_removal_delay_increment_length_minus1
Definition: hevc_ps.h:57
HEVCHdrParams::cpb_cnt_minus1
uint8_t cpb_cnt_minus1[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:65
hevc_sub_height_c
static const uint8_t hevc_sub_height_c[]
Definition: hevc_ps.c:59
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: hevc_ps.h:63
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:242
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: hevc_ps.h:440
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: hevc_ps.h:54
imgutils.h
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: hevc_ps.c:101
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
HEVC_MAX_SUB_LAYERS
@ HEVC_MAX_SUB_LAYERS
Definition: hevc.h:105
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_hevc_decode_nal_pps
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1748
ShortTermRPS::delta_poc
int32_t delta_poc[32]
Definition: hevc_ps.h:83
HEVCHdrParams::cpb_size_du_scale
uint8_t cpb_size_du_scale
Definition: hevc_ps.h:61
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:460
default_scaling_list_intra
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:33
FF_DEBUG_BITSTREAM
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:1399
HEVCHdrParams::flags
HEVCHdrFlagParams flags
Definition: hevc_ps.h:50
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
uninit_vps
static void uninit_vps(FFRefStructOpaque opaque, void *obj)
Definition: hevc_ps.c:445
pps_range_extensions
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, const HEVCSPS *sps)
Definition: hevc_ps.c:1522
ShortTermRPS::delta_poc_s1
int32_t delta_poc_s1[32]
Definition: hevc_ps.h:82
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:2882
HEVCParamSets
Definition: hevc_ps.h:439