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