FFmpeg
hevc_ps.c
Go to the documentation of this file.
1 /*
2  * HEVC Parameter Set decoding
3  *
4  * Copyright (C) 2012 - 2103 Guillaume Martres
5  * Copyright (C) 2012 - 2103 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2013 Vittorio Giovara
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/imgutils.h"
27 #include "golomb.h"
28 #include "hevc_data.h"
29 #include "hevc_ps.h"
30 
32  16, 16, 16, 16, 17, 18, 21, 24,
33  16, 16, 16, 16, 17, 19, 22, 25,
34  16, 16, 17, 18, 20, 22, 25, 29,
35  16, 16, 18, 21, 24, 27, 31, 36,
36  17, 17, 20, 24, 30, 35, 41, 47,
37  18, 19, 22, 27, 35, 44, 54, 65,
38  21, 22, 25, 31, 41, 54, 70, 88,
39  24, 25, 29, 36, 47, 65, 88, 115
40 };
41 
43  16, 16, 16, 16, 17, 18, 20, 24,
44  16, 16, 16, 17, 18, 20, 24, 25,
45  16, 16, 17, 18, 20, 24, 25, 28,
46  16, 17, 18, 20, 24, 25, 28, 33,
47  17, 18, 20, 24, 25, 28, 33, 41,
48  18, 20, 24, 25, 28, 33, 41, 54,
49  20, 24, 25, 28, 33, 41, 54, 71,
50  24, 25, 28, 33, 41, 54, 71, 91
51 };
52 
53 static const AVRational vui_sar[] = {
54  { 0, 1 },
55  { 1, 1 },
56  { 12, 11 },
57  { 10, 11 },
58  { 16, 11 },
59  { 40, 33 },
60  { 24, 11 },
61  { 20, 11 },
62  { 32, 11 },
63  { 80, 33 },
64  { 18, 11 },
65  { 15, 11 },
66  { 64, 33 },
67  { 160, 99 },
68  { 4, 3 },
69  { 3, 2 },
70  { 2, 1 },
71 };
72 
73 static const uint8_t hevc_sub_width_c[] = {
74  1, 2, 2, 1
75 };
76 
77 static const uint8_t hevc_sub_height_c[] = {
78  1, 2, 1, 1
79 };
80 
81 static void remove_pps(HEVCParamSets *s, int id)
82 {
83  if (s->pps_list[id] && s->pps == (const HEVCPPS*)s->pps_list[id]->data)
84  s->pps = NULL;
85  av_buffer_unref(&s->pps_list[id]);
86 }
87 
88 static void remove_sps(HEVCParamSets *s, int id)
89 {
90  int i;
91  if (s->sps_list[id]) {
92  if (s->sps == (const HEVCSPS*)s->sps_list[id]->data)
93  s->sps = NULL;
94 
95  /* drop all PPS that depend on this SPS */
96  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
97  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == id)
98  remove_pps(s, i);
99 
100  av_assert0(!(s->sps_list[id] && s->sps == (HEVCSPS*)s->sps_list[id]->data));
101  }
102  av_buffer_unref(&s->sps_list[id]);
103 }
104 
105 static void remove_vps(HEVCParamSets *s, int id)
106 {
107  int i;
108  if (s->vps_list[id]) {
109  if (s->vps == (const HEVCVPS*)s->vps_list[id]->data)
110  s->vps = NULL;
111 
112  for (i = 0; i < FF_ARRAY_ELEMS(s->sps_list); i++)
113  if (s->sps_list[i] && ((HEVCSPS*)s->sps_list[i]->data)->vps_id == id)
114  remove_sps(s, i);
115  }
116  av_buffer_unref(&s->vps_list[id]);
117 }
118 
120  ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
121 {
122  uint8_t rps_predict = 0;
123  int delta_poc;
124  int k0 = 0;
125  int k1 = 0;
126  int k = 0;
127  int i;
128 
129  if (rps != sps->st_rps && sps->nb_st_rps)
130  rps_predict = get_bits1(gb);
131 
132  if (rps_predict) {
133  const ShortTermRPS *rps_ridx;
134  int delta_rps;
135  unsigned abs_delta_rps;
136  uint8_t use_delta_flag = 0;
137  uint8_t delta_rps_sign;
138 
139  if (is_slice_header) {
140  unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
141  if (delta_idx > sps->nb_st_rps) {
142  av_log(avctx, AV_LOG_ERROR,
143  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
144  delta_idx, sps->nb_st_rps);
145  return AVERROR_INVALIDDATA;
146  }
147  rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
148  rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
149  } else
150  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
151 
152  delta_rps_sign = get_bits1(gb);
153  abs_delta_rps = get_ue_golomb_long(gb) + 1;
154  if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
155  av_log(avctx, AV_LOG_ERROR,
156  "Invalid value of abs_delta_rps: %d\n",
157  abs_delta_rps);
158  return AVERROR_INVALIDDATA;
159  }
160  delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
161  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
162  int used = rps->used[k] = get_bits1(gb);
163 
164  if (!used)
165  use_delta_flag = get_bits1(gb);
166 
167  if (used || use_delta_flag) {
168  if (i < rps_ridx->num_delta_pocs)
169  delta_poc = delta_rps + rps_ridx->delta_poc[i];
170  else
171  delta_poc = delta_rps;
172  rps->delta_poc[k] = delta_poc;
173  if (delta_poc < 0)
174  k0++;
175  else
176  k1++;
177  k++;
178  }
179  }
180 
181  if (k >= FF_ARRAY_ELEMS(rps->used)) {
182  av_log(avctx, AV_LOG_ERROR,
183  "Invalid num_delta_pocs: %d\n", k);
184  return AVERROR_INVALIDDATA;
185  }
186 
187  rps->num_delta_pocs = k;
188  rps->num_negative_pics = k0;
189  // sort in increasing order (smallest first)
190  if (rps->num_delta_pocs != 0) {
191  int used, tmp;
192  for (i = 1; i < rps->num_delta_pocs; i++) {
193  delta_poc = rps->delta_poc[i];
194  used = rps->used[i];
195  for (k = i - 1; k >= 0; k--) {
196  tmp = rps->delta_poc[k];
197  if (delta_poc < tmp) {
198  rps->delta_poc[k + 1] = tmp;
199  rps->used[k + 1] = rps->used[k];
200  rps->delta_poc[k] = delta_poc;
201  rps->used[k] = used;
202  }
203  }
204  }
205  }
206  if ((rps->num_negative_pics >> 1) != 0) {
207  int used;
208  k = rps->num_negative_pics - 1;
209  // flip the negative values to largest first
210  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
211  delta_poc = rps->delta_poc[i];
212  used = rps->used[i];
213  rps->delta_poc[i] = rps->delta_poc[k];
214  rps->used[i] = rps->used[k];
215  rps->delta_poc[k] = delta_poc;
216  rps->used[k] = used;
217  k--;
218  }
219  }
220  } else {
221  unsigned int prev, nb_positive_pics;
223  nb_positive_pics = get_ue_golomb_long(gb);
224 
225  if (rps->num_negative_pics >= HEVC_MAX_REFS ||
226  nb_positive_pics >= HEVC_MAX_REFS) {
227  av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
228  return AVERROR_INVALIDDATA;
229  }
230 
231  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
232  if (rps->num_delta_pocs) {
233  prev = 0;
234  for (i = 0; i < rps->num_negative_pics; i++) {
235  delta_poc = get_ue_golomb_long(gb) + 1;
236  if (delta_poc < 1 || delta_poc > 32768) {
237  av_log(avctx, AV_LOG_ERROR,
238  "Invalid value of delta_poc: %d\n",
239  delta_poc);
240  return AVERROR_INVALIDDATA;
241  }
242  prev -= delta_poc;
243  rps->delta_poc[i] = prev;
244  rps->used[i] = get_bits1(gb);
245  }
246  prev = 0;
247  for (i = 0; i < nb_positive_pics; i++) {
248  delta_poc = get_ue_golomb_long(gb) + 1;
249  if (delta_poc < 1 || delta_poc > 32768) {
250  av_log(avctx, AV_LOG_ERROR,
251  "Invalid value of delta_poc: %d\n",
252  delta_poc);
253  return AVERROR_INVALIDDATA;
254  }
255  prev += delta_poc;
256  rps->delta_poc[rps->num_negative_pics + i] = prev;
257  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
258  }
259  }
260  }
261  return 0;
262 }
263 
264 
266  PTLCommon *ptl)
267 {
268  int i;
269 
270  if (get_bits_left(gb) < 2+1+5 + 32 + 4 + 16 + 16 + 12)
271  return -1;
272 
273  ptl->profile_space = get_bits(gb, 2);
274  ptl->tier_flag = get_bits1(gb);
275  ptl->profile_idc = get_bits(gb, 5);
276  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
277  av_log(avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
278  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
279  av_log(avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
281  av_log(avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
282  else if (ptl->profile_idc == FF_PROFILE_HEVC_REXT)
283  av_log(avctx, AV_LOG_DEBUG, "Range Extension profile bitstream\n");
284  else
285  av_log(avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
286 
287  for (i = 0; i < 32; i++) {
289 
290  if (ptl->profile_idc == 0 && i > 0 && ptl->profile_compatibility_flag[i])
291  ptl->profile_idc = i;
292  }
297 
298  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
299  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
300  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
301 
302  return 0;
303 }
304 
305 static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx,
306  PTL *ptl, int max_num_sub_layers)
307 {
308  int i;
309  if (decode_profile_tier_level(gb, avctx, &ptl->general_ptl) < 0 ||
310  get_bits_left(gb) < 8 + (8*2 * (max_num_sub_layers - 1 > 0))) {
311  av_log(avctx, AV_LOG_ERROR, "PTL information too short\n");
312  return -1;
313  }
314 
315  ptl->general_ptl.level_idc = get_bits(gb, 8);
316 
317  for (i = 0; i < max_num_sub_layers - 1; i++) {
320  }
321 
322  if (max_num_sub_layers - 1> 0)
323  for (i = max_num_sub_layers - 1; i < 8; i++)
324  skip_bits(gb, 2); // reserved_zero_2bits[i]
325  for (i = 0; i < max_num_sub_layers - 1; i++) {
326  if (ptl->sub_layer_profile_present_flag[i] &&
327  decode_profile_tier_level(gb, avctx, &ptl->sub_layer_ptl[i]) < 0) {
328  av_log(avctx, AV_LOG_ERROR,
329  "PTL information for sublayer %i too short\n", i);
330  return -1;
331  }
332  if (ptl->sub_layer_level_present_flag[i]) {
333  if (get_bits_left(gb) < 8) {
334  av_log(avctx, AV_LOG_ERROR,
335  "Not enough data for sublayer %i level_idc\n", i);
336  return -1;
337  } else
338  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
339  }
340  }
341 
342  return 0;
343 }
344 
345 static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb,
346  int subpic_params_present)
347 {
348  int i;
349 
350  for (i = 0; i < nb_cpb; i++) {
351  get_ue_golomb_long(gb); // bit_rate_value_minus1
352  get_ue_golomb_long(gb); // cpb_size_value_minus1
353 
354  if (subpic_params_present) {
355  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
356  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
357  }
358  skip_bits1(gb); // cbr_flag
359  }
360 }
361 
362 static int decode_hrd(GetBitContext *gb, int common_inf_present,
363  int max_sublayers)
364 {
365  int nal_params_present = 0, vcl_params_present = 0;
366  int subpic_params_present = 0;
367  int i;
368 
369  if (common_inf_present) {
370  nal_params_present = get_bits1(gb);
371  vcl_params_present = get_bits1(gb);
372 
373  if (nal_params_present || vcl_params_present) {
374  subpic_params_present = get_bits1(gb);
375 
376  if (subpic_params_present) {
377  skip_bits(gb, 8); // tick_divisor_minus2
378  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
379  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
380  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
381  }
382 
383  skip_bits(gb, 4); // bit_rate_scale
384  skip_bits(gb, 4); // cpb_size_scale
385 
386  if (subpic_params_present)
387  skip_bits(gb, 4); // cpb_size_du_scale
388 
389  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
390  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
391  skip_bits(gb, 5); // dpb_output_delay_length_minus1
392  }
393  }
394 
395  for (i = 0; i < max_sublayers; i++) {
396  int low_delay = 0;
397  unsigned int nb_cpb = 1;
398  int fixed_rate = get_bits1(gb);
399 
400  if (!fixed_rate)
401  fixed_rate = get_bits1(gb);
402 
403  if (fixed_rate)
404  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
405  else
406  low_delay = get_bits1(gb);
407 
408  if (!low_delay) {
409  nb_cpb = get_ue_golomb_long(gb) + 1;
410  if (nb_cpb < 1 || nb_cpb > 32) {
411  av_log(NULL, AV_LOG_ERROR, "nb_cpb %d invalid\n", nb_cpb);
412  return AVERROR_INVALIDDATA;
413  }
414  }
415 
416  if (nal_params_present)
417  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
418  if (vcl_params_present)
419  decode_sublayer_hrd(gb, nb_cpb, subpic_params_present);
420  }
421  return 0;
422 }
423 
425  HEVCParamSets *ps)
426 {
427  int i,j;
428  int vps_id = 0;
429  ptrdiff_t nal_size;
430  HEVCVPS *vps;
431  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
432 
433  if (!vps_buf)
434  return AVERROR(ENOMEM);
435  vps = (HEVCVPS*)vps_buf->data;
436 
437  av_log(avctx, AV_LOG_DEBUG, "Decoding VPS\n");
438 
439  nal_size = gb->buffer_end - gb->buffer;
440  if (nal_size > sizeof(vps->data)) {
441  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized VPS "
442  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
443  nal_size, sizeof(vps->data));
444  vps->data_size = sizeof(vps->data);
445  } else {
446  vps->data_size = nal_size;
447  }
448  memcpy(vps->data, gb->buffer, vps->data_size);
449 
450  vps_id = get_bits(gb, 4);
451 
452  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
453  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
454  goto err;
455  }
456 
457  vps->vps_max_layers = get_bits(gb, 6) + 1;
458  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
460 
461  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
462  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
463  goto err;
464  }
465 
467  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
468  vps->vps_max_sub_layers);
469  goto err;
470  }
471 
472  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
473  goto err;
474 
476 
478  for (; i < vps->vps_max_sub_layers; i++) {
482 
484  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
485  vps->vps_max_dec_pic_buffering[i] - 1);
486  goto err;
487  }
488  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
489  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
490  vps->vps_num_reorder_pics[i]);
491  if (avctx->err_recognition & AV_EF_EXPLODE)
492  goto err;
493  }
494  }
495 
496  vps->vps_max_layer_id = get_bits(gb, 6);
497  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
498  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
499  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
500  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
501  goto err;
502  }
503 
504  for (i = 1; i < vps->vps_num_layer_sets; i++)
505  for (j = 0; j <= vps->vps_max_layer_id; j++)
506  skip_bits(gb, 1); // layer_id_included_flag[i][j]
507 
509  if (vps->vps_timing_info_present_flag) {
510  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
511  vps->vps_time_scale = get_bits_long(gb, 32);
516  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
517  av_log(avctx, AV_LOG_ERROR,
518  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
519  goto err;
520  }
521  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
522  int common_inf_present = 1;
523 
524  get_ue_golomb_long(gb); // hrd_layer_set_idx
525  if (i)
526  common_inf_present = get_bits1(gb);
527  decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
528  }
529  }
530  get_bits1(gb); /* vps_extension_flag */
531 
532  if (get_bits_left(gb) < 0) {
533  av_log(avctx, AV_LOG_ERROR,
534  "Overread VPS by %d bits\n", -get_bits_left(gb));
535  if (ps->vps_list[vps_id])
536  goto err;
537  }
538 
539  if (ps->vps_list[vps_id] &&
540  !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
541  av_buffer_unref(&vps_buf);
542  } else {
543  remove_vps(ps, vps_id);
544  ps->vps_list[vps_id] = vps_buf;
545  }
546 
547  return 0;
548 
549 err:
550  av_buffer_unref(&vps_buf);
551  return AVERROR_INVALIDDATA;
552 }
553 
554 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
555  int apply_defdispwin, HEVCSPS *sps)
556 {
557  VUI backup_vui, *vui = &sps->vui;
558  GetBitContext backup;
559  int sar_present, alt = 0;
560 
561  av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
562 
563  sar_present = get_bits1(gb);
564  if (sar_present) {
565  uint8_t sar_idx = get_bits(gb, 8);
566  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
567  vui->sar = vui_sar[sar_idx];
568  else if (sar_idx == 255) {
569  vui->sar.num = get_bits(gb, 16);
570  vui->sar.den = get_bits(gb, 16);
571  } else
572  av_log(avctx, AV_LOG_WARNING,
573  "Unknown SAR index: %u.\n", sar_idx);
574  }
575 
579 
582  vui->video_format = get_bits(gb, 3);
583  vui->video_full_range_flag = get_bits1(gb);
588  vui->colour_primaries = get_bits(gb, 8);
589  vui->transfer_characteristic = get_bits(gb, 8);
590  vui->matrix_coeffs = get_bits(gb, 8);
591 
592  // Set invalid values to "unspecified"
599  if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
600  switch (sps->pix_fmt) {
601  case AV_PIX_FMT_YUV444P:
602  sps->pix_fmt = AV_PIX_FMT_GBRP;
603  break;
605  sps->pix_fmt = AV_PIX_FMT_GBRP10;
606  break;
608  sps->pix_fmt = AV_PIX_FMT_GBRP12;
609  break;
610  }
611  }
612  }
613  }
614 
616  if (vui->chroma_loc_info_present_flag) {
619  }
620 
622  vui->field_seq_flag = get_bits1(gb);
624 
625  // Backup context in case an alternate header is detected
626  memcpy(&backup, gb, sizeof(backup));
627  memcpy(&backup_vui, vui, sizeof(backup_vui));
628  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
630  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
631  } else
633 
634  if (vui->default_display_window_flag) {
635  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
636  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
637  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
638  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
639  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
640  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
641 
642  if (apply_defdispwin &&
644  av_log(avctx, AV_LOG_DEBUG,
645  "discarding vui default display window, "
646  "original values are l:%u r:%u t:%u b:%u\n",
651 
654  vui->def_disp_win.top_offset =
655  vui->def_disp_win.bottom_offset = 0;
656  }
657  }
658 
661 
662  if (vui->vui_timing_info_present_flag) {
663  if( get_bits_left(gb) < 66 && !alt) {
664  // The alternate syntax seem to have timing info located
665  // at where def_disp_win is normally located
666  av_log(avctx, AV_LOG_WARNING,
667  "Strange VUI timing information, retrying...\n");
668  memcpy(vui, &backup_vui, sizeof(backup_vui));
669  memcpy(gb, &backup, sizeof(backup));
670  alt = 1;
671  goto timing_info;
672  }
673  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
674  vui->vui_time_scale = get_bits_long(gb, 32);
675  if (alt) {
676  av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
678  }
684  decode_hrd(gb, 1, sps->max_sub_layers);
685  }
686 
688  if (vui->bitstream_restriction_flag) {
689  if (get_bits_left(gb) < 8 && !alt) {
690  av_log(avctx, AV_LOG_WARNING,
691  "Strange VUI bitstream restriction information, retrying"
692  " from timing information...\n");
693  memcpy(vui, &backup_vui, sizeof(backup_vui));
694  memcpy(gb, &backup, sizeof(backup));
695  alt = 1;
696  goto timing_info;
697  }
706  }
707 
708  if (get_bits_left(gb) < 1 && !alt) {
709  // XXX: Alternate syntax when sps_range_extension_flag != 0?
710  av_log(avctx, AV_LOG_WARNING,
711  "Overread in VUI, retrying from timing information...\n");
712  memcpy(vui, &backup_vui, sizeof(backup_vui));
713  memcpy(gb, &backup, sizeof(backup));
714  alt = 1;
715  goto timing_info;
716  }
717 }
718 
720 {
721  int matrixId;
722 
723  for (matrixId = 0; matrixId < 6; matrixId++) {
724  // 4x4 default is 16
725  memset(sl->sl[0][matrixId], 16, 16);
726  sl->sl_dc[0][matrixId] = 16; // default for 16x16
727  sl->sl_dc[1][matrixId] = 16; // default for 32x32
728  }
729  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
730  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
731  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
732  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
733  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
734  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
735  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
736  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
737  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
738  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
739  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
740  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
741  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
742  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
743  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
744  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
745  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
746  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
747 }
748 
750 {
751  uint8_t scaling_list_pred_mode_flag;
752  int32_t scaling_list_dc_coef[2][6];
753  int size_id, matrix_id, pos;
754  int i;
755 
756  for (size_id = 0; size_id < 4; size_id++)
757  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
758  scaling_list_pred_mode_flag = get_bits1(gb);
759  if (!scaling_list_pred_mode_flag) {
760  unsigned int delta = get_ue_golomb_long(gb);
761  /* Only need to handle non-zero delta. Zero means default,
762  * which should already be in the arrays. */
763  if (delta) {
764  // Copy from previous array.
765  delta *= (size_id == 3) ? 3 : 1;
766  if (matrix_id < delta) {
767  av_log(avctx, AV_LOG_ERROR,
768  "Invalid delta in scaling list data: %d.\n", delta);
769  return AVERROR_INVALIDDATA;
770  }
771 
772  memcpy(sl->sl[size_id][matrix_id],
773  sl->sl[size_id][matrix_id - delta],
774  size_id > 0 ? 64 : 16);
775  if (size_id > 1)
776  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
777  }
778  } else {
779  int next_coef, coef_num;
780  int32_t scaling_list_delta_coef;
781 
782  next_coef = 8;
783  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
784  if (size_id > 1) {
785  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
786  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
787  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
788  }
789  for (i = 0; i < coef_num; i++) {
790  if (size_id == 0)
791  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
793  else
794  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
796 
797  scaling_list_delta_coef = get_se_golomb(gb);
798  next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
799  sl->sl[size_id][matrix_id][pos] = next_coef;
800  }
801  }
802  }
803 
804  if (sps->chroma_format_idc == 3) {
805  for (i = 0; i < 64; i++) {
806  sl->sl[3][1][i] = sl->sl[2][1][i];
807  sl->sl[3][2][i] = sl->sl[2][2][i];
808  sl->sl[3][4][i] = sl->sl[2][4][i];
809  sl->sl[3][5][i] = sl->sl[2][5][i];
810  }
811  sl->sl_dc[1][1] = sl->sl_dc[0][1];
812  sl->sl_dc[1][2] = sl->sl_dc[0][2];
813  sl->sl_dc[1][4] = sl->sl_dc[0][4];
814  sl->sl_dc[1][5] = sl->sl_dc[0][5];
815  }
816 
817 
818  return 0;
819 }
820 
822 {
823  const AVPixFmtDescriptor *desc;
824  switch (sps->bit_depth) {
825  case 8:
826  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
827  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
828  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
829  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
830  break;
831  case 9:
832  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
833  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
834  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
835  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
836  break;
837  case 10:
838  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
839  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
840  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
841  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
842  break;
843  case 12:
844  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
845  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
846  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
847  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
848  break;
849  default:
850  av_log(avctx, AV_LOG_ERROR,
851  "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
852  "chroma_format_idc is %d, depth is %d\n",
853  sps->chroma_format_idc, sps->bit_depth);
854  return AVERROR_INVALIDDATA;
855  }
856 
857  desc = av_pix_fmt_desc_get(sps->pix_fmt);
858  if (!desc)
859  return AVERROR(EINVAL);
860 
861  sps->hshift[0] = sps->vshift[0] = 0;
862  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
863  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
864 
865  sps->pixel_shift = sps->bit_depth > 8;
866 
867  return 0;
868 }
869 
870 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
871  int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
872 {
873  HEVCWindow *ow;
874  int ret = 0;
875  int log2_diff_max_min_transform_block_size;
876  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
877  int i;
878 
879  // Coded parameters
880 
881  sps->vps_id = get_bits(gb, 4);
882 
883  if (vps_list && !vps_list[sps->vps_id]) {
884  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
885  sps->vps_id);
886  return AVERROR_INVALIDDATA;
887  }
888 
889  sps->max_sub_layers = get_bits(gb, 3) + 1;
890  if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
891  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
892  sps->max_sub_layers);
893  return AVERROR_INVALIDDATA;
894  }
895 
896  sps->temporal_id_nesting_flag = get_bits(gb, 1);
897 
898  if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
899  return ret;
900 
901  *sps_id = get_ue_golomb_long(gb);
902  if (*sps_id >= HEVC_MAX_SPS_COUNT) {
903  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
904  return AVERROR_INVALIDDATA;
905  }
906 
908  if (sps->chroma_format_idc > 3U) {
909  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
910  return AVERROR_INVALIDDATA;
911  }
912 
913  if (sps->chroma_format_idc == 3)
915 
917  sps->chroma_format_idc = 0;
918 
919  sps->width = get_ue_golomb_long(gb);
920  sps->height = get_ue_golomb_long(gb);
921  if ((ret = av_image_check_size(sps->width,
922  sps->height, 0, avctx)) < 0)
923  return ret;
924 
925  if (get_bits1(gb)) { // pic_conformance_flag
926  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
927  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
928  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
929  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
930  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
931  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
932 
933  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
934  av_log(avctx, AV_LOG_DEBUG,
935  "discarding sps conformance window, "
936  "original values are l:%u r:%u t:%u b:%u\n",
941 
944  sps->pic_conf_win.top_offset =
945  sps->pic_conf_win.bottom_offset = 0;
946  }
947  sps->output_window = sps->pic_conf_win;
948  }
949 
950  sps->bit_depth = get_ue_golomb_long(gb) + 8;
951  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
952  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
953  av_log(avctx, AV_LOG_ERROR,
954  "Luma bit depth (%d) is different from chroma bit depth (%d), "
955  "this is unsupported.\n",
956  sps->bit_depth, bit_depth_chroma);
957  return AVERROR_INVALIDDATA;
958  }
959  sps->bit_depth_chroma = bit_depth_chroma;
960 
961  ret = map_pixel_format(avctx, sps);
962  if (ret < 0)
963  return ret;
964 
965  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
966  if (sps->log2_max_poc_lsb > 16) {
967  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
968  sps->log2_max_poc_lsb - 4);
969  return AVERROR_INVALIDDATA;
970  }
971 
972  sublayer_ordering_info = get_bits1(gb);
973  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
974  for (i = start; i < sps->max_sub_layers; i++) {
978  if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
979  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
981  return AVERROR_INVALIDDATA;
982  }
984  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
986  if (avctx->err_recognition & AV_EF_EXPLODE ||
987  sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
988  return AVERROR_INVALIDDATA;
989  }
991  }
992  }
993 
994  if (!sublayer_ordering_info) {
995  for (i = 0; i < start; i++) {
999  }
1000  }
1001 
1002  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
1004  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
1005  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
1006  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
1007  sps->log2_min_tb_size;
1008 
1009  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1010  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1011  return AVERROR_INVALIDDATA;
1012  }
1013 
1014  if (sps->log2_diff_max_min_coding_block_size > 30) {
1015  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);
1016  return AVERROR_INVALIDDATA;
1017  }
1018 
1019  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1020  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1021  return AVERROR_INVALIDDATA;
1022  }
1023 
1024  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
1025  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
1026  return AVERROR_INVALIDDATA;
1027  }
1028 
1031 
1033  if (sps->scaling_list_enable_flag) {
1035 
1036  if (get_bits1(gb)) {
1037  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1038  if (ret < 0)
1039  return ret;
1040  }
1041  }
1042 
1043  sps->amp_enabled_flag = get_bits1(gb);
1044  sps->sao_enabled = get_bits1(gb);
1045 
1046  sps->pcm_enabled_flag = get_bits1(gb);
1047  if (sps->pcm_enabled_flag) {
1048  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1049  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1052  get_ue_golomb_long(gb);
1053  if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1054  av_log(avctx, AV_LOG_ERROR,
1055  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1056  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1057  return AVERROR_INVALIDDATA;
1058  }
1059 
1061  }
1062 
1063  sps->nb_st_rps = get_ue_golomb_long(gb);
1065  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1066  sps->nb_st_rps);
1067  return AVERROR_INVALIDDATA;
1068  }
1069  for (i = 0; i < sps->nb_st_rps; i++) {
1070  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1071  sps, 0)) < 0)
1072  return ret;
1073  }
1074 
1079  av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1081  return AVERROR_INVALIDDATA;
1082  }
1083  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1086  }
1087  }
1088 
1091  sps->vui.sar = (AVRational){0, 1};
1092  vui_present = get_bits1(gb);
1093  if (vui_present)
1094  decode_vui(gb, avctx, apply_defdispwin, sps);
1095 
1096  if (get_bits1(gb)) { // sps_extension_flag
1098  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1099  if (sps->sps_range_extension_flag) {
1103 
1105 
1108  av_log(avctx, AV_LOG_WARNING,
1109  "extended_precision_processing_flag not yet implemented\n");
1110 
1114  av_log(avctx, AV_LOG_WARNING,
1115  "high_precision_offsets_enabled_flag not yet implemented\n");
1116 
1118 
1121  av_log(avctx, AV_LOG_WARNING,
1122  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1123  }
1124  }
1125  if (apply_defdispwin) {
1130  }
1131 
1132  ow = &sps->output_window;
1133  if (ow->left_offset >= INT_MAX - ow->right_offset ||
1134  ow->top_offset >= INT_MAX - ow->bottom_offset ||
1135  ow->left_offset + ow->right_offset >= sps->width ||
1136  ow->top_offset + ow->bottom_offset >= sps->height) {
1137  av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
1138  ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1139  if (avctx->err_recognition & AV_EF_EXPLODE) {
1140  return AVERROR_INVALIDDATA;
1141  }
1142  av_log(avctx, AV_LOG_WARNING,
1143  "Displaying the whole video surface.\n");
1144  memset(ow, 0, sizeof(*ow));
1145  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1146  }
1147 
1148  // Inferred parameters
1149  sps->log2_ctb_size = sps->log2_min_cb_size +
1151  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1152 
1154  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1155  return AVERROR_INVALIDDATA;
1156  }
1157  if (sps->log2_ctb_size < 4) {
1158  av_log(avctx,
1159  AV_LOG_ERROR,
1160  "log2_ctb_size %d differs from the bounds of any known profile\n",
1161  sps->log2_ctb_size);
1162  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1163  return AVERROR_INVALIDDATA;
1164  }
1165 
1166  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1167  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1168  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1169 
1170  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1171  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1172  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1173  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1174  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1175  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1176  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1177 
1178  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1179 
1180  if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
1181  av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1182  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1183  return AVERROR_INVALIDDATA;
1184  }
1185 
1187  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1189  return AVERROR_INVALIDDATA;
1190  }
1192  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1194  return AVERROR_INVALIDDATA;
1195  }
1196  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1197  av_log(avctx, AV_LOG_ERROR,
1198  "max transform block size out of range: %d\n",
1199  sps->log2_max_trafo_size);
1200  return AVERROR_INVALIDDATA;
1201  }
1202 
1203  if (get_bits_left(gb) < 0) {
1204  av_log(avctx, AV_LOG_ERROR,
1205  "Overread SPS by %d bits\n", -get_bits_left(gb));
1206  return AVERROR_INVALIDDATA;
1207  }
1208 
1209  return 0;
1210 }
1211 
1213  HEVCParamSets *ps, int apply_defdispwin)
1214 {
1215  HEVCSPS *sps;
1216  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
1217  unsigned int sps_id;
1218  int ret;
1219  ptrdiff_t nal_size;
1220 
1221  if (!sps_buf)
1222  return AVERROR(ENOMEM);
1223  sps = (HEVCSPS*)sps_buf->data;
1224 
1225  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1226 
1227  nal_size = gb->buffer_end - gb->buffer;
1228  if (nal_size > sizeof(sps->data)) {
1229  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized SPS "
1230  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1231  nal_size, sizeof(sps->data));
1232  sps->data_size = sizeof(sps->data);
1233  } else {
1234  sps->data_size = nal_size;
1235  }
1236  memcpy(sps->data, gb->buffer, sps->data_size);
1237 
1238  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1239  apply_defdispwin,
1240  ps->vps_list, avctx);
1241  if (ret < 0) {
1242  av_buffer_unref(&sps_buf);
1243  return ret;
1244  }
1245 
1246  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1247  av_log(avctx, AV_LOG_DEBUG,
1248  "Parsed SPS: id %d; coded wxh: %dx%d; "
1249  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1250  sps_id, sps->width, sps->height,
1254  }
1255 
1256  /* check if this is a repeat of an already parsed SPS, then keep the
1257  * original one.
1258  * otherwise drop all PPSes that depend on it */
1259  if (ps->sps_list[sps_id] &&
1260  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1261  av_buffer_unref(&sps_buf);
1262  } else {
1263  remove_sps(ps, sps_id);
1264  ps->sps_list[sps_id] = sps_buf;
1265  }
1266 
1267  return 0;
1268 }
1269 
1270 static void hevc_pps_free(void *opaque, uint8_t *data)
1271 {
1272  HEVCPPS *pps = (HEVCPPS*)data;
1273 
1274  av_freep(&pps->column_width);
1275  av_freep(&pps->row_height);
1276  av_freep(&pps->col_bd);
1277  av_freep(&pps->row_bd);
1278  av_freep(&pps->col_idxX);
1279  av_freep(&pps->ctb_addr_rs_to_ts);
1280  av_freep(&pps->ctb_addr_ts_to_rs);
1281  av_freep(&pps->tile_pos_rs);
1282  av_freep(&pps->tile_id);
1284 
1285  av_freep(&pps);
1286 }
1287 
1289  HEVCPPS *pps, HEVCSPS *sps) {
1290  int i;
1291 
1292  if (pps->transform_skip_enabled_flag) {
1294  }
1300  if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1301  av_log(avctx, AV_LOG_ERROR,
1302  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1303  return AVERROR_INVALIDDATA;
1304  }
1305  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1307  if (pps->cb_qp_offset_list[i]) {
1308  av_log(avctx, AV_LOG_WARNING,
1309  "cb_qp_offset_list not tested yet.\n");
1310  }
1312  if (pps->cr_qp_offset_list[i]) {
1313  av_log(avctx, AV_LOG_WARNING,
1314  "cb_qp_offset_list not tested yet.\n");
1315  }
1316  }
1317  }
1320 
1321  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1322  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1323  )
1324  return AVERROR_INVALIDDATA;
1325 
1326  return(0);
1327 }
1328 
1329 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1330  HEVCPPS *pps, HEVCSPS *sps)
1331 {
1332  int log2_diff;
1333  int pic_area_in_ctbs;
1334  int i, j, x, y, ctb_addr_rs, tile_id;
1335 
1336  // Inferred parameters
1337  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1338  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1339  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1340  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1341  return AVERROR(ENOMEM);
1342 
1343  if (pps->uniform_spacing_flag) {
1344  if (!pps->column_width) {
1345  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1346  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1347  }
1348  if (!pps->column_width || !pps->row_height)
1349  return AVERROR(ENOMEM);
1350 
1351  for (i = 0; i < pps->num_tile_columns; i++) {
1352  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1353  (i * sps->ctb_width) / pps->num_tile_columns;
1354  }
1355 
1356  for (i = 0; i < pps->num_tile_rows; i++) {
1357  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1358  (i * sps->ctb_height) / pps->num_tile_rows;
1359  }
1360  }
1361 
1362  pps->col_bd[0] = 0;
1363  for (i = 0; i < pps->num_tile_columns; i++)
1364  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1365 
1366  pps->row_bd[0] = 0;
1367  for (i = 0; i < pps->num_tile_rows; i++)
1368  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1369 
1370  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1371  if (i > pps->col_bd[j])
1372  j++;
1373  pps->col_idxX[i] = j;
1374  }
1375 
1376  /**
1377  * 6.5
1378  */
1379  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1380 
1381  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1382  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1383  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1384  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1385  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1386  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1387  return AVERROR(ENOMEM);
1388  }
1389 
1390  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1391  int tb_x = ctb_addr_rs % sps->ctb_width;
1392  int tb_y = ctb_addr_rs / sps->ctb_width;
1393  int tile_x = 0;
1394  int tile_y = 0;
1395  int val = 0;
1396 
1397  for (i = 0; i < pps->num_tile_columns; i++) {
1398  if (tb_x < pps->col_bd[i + 1]) {
1399  tile_x = i;
1400  break;
1401  }
1402  }
1403 
1404  for (i = 0; i < pps->num_tile_rows; i++) {
1405  if (tb_y < pps->row_bd[i + 1]) {
1406  tile_y = i;
1407  break;
1408  }
1409  }
1410 
1411  for (i = 0; i < tile_x; i++)
1412  val += pps->row_height[tile_y] * pps->column_width[i];
1413  for (i = 0; i < tile_y; i++)
1414  val += sps->ctb_width * pps->row_height[i];
1415 
1416  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1417  tb_x - pps->col_bd[tile_x];
1418 
1419  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1420  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1421  }
1422 
1423  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1424  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1425  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1426  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1427  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1428 
1429  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1430  if (!pps->tile_pos_rs)
1431  return AVERROR(ENOMEM);
1432 
1433  for (j = 0; j < pps->num_tile_rows; j++)
1434  for (i = 0; i < pps->num_tile_columns; i++)
1435  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1436  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1437 
1438  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1439  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1440  for (y = 0; y < sps->tb_mask+2; y++) {
1441  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1442  pps->min_tb_addr_zs_tab[y] = -1;
1443  }
1444  for (y = 0; y < sps->tb_mask+1; y++) {
1445  for (x = 0; x < sps->tb_mask+1; x++) {
1446  int tb_x = x >> log2_diff;
1447  int tb_y = y >> log2_diff;
1448  int rs = sps->ctb_width * tb_y + tb_x;
1449  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1450  for (i = 0; i < log2_diff; i++) {
1451  int m = 1 << i;
1452  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1453  }
1454  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1455  }
1456  }
1457 
1458  return 0;
1459 }
1460 
1462  HEVCParamSets *ps)
1463 {
1464  HEVCSPS *sps = NULL;
1465  int i, ret = 0;
1466  unsigned int pps_id = 0;
1467  ptrdiff_t nal_size;
1468  unsigned log2_parallel_merge_level_minus2;
1469 
1470  AVBufferRef *pps_buf;
1471  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1472 
1473  if (!pps)
1474  return AVERROR(ENOMEM);
1475 
1476  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1477  hevc_pps_free, NULL, 0);
1478  if (!pps_buf) {
1479  av_freep(&pps);
1480  return AVERROR(ENOMEM);
1481  }
1482 
1483  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1484 
1485  nal_size = gb->buffer_end - gb->buffer;
1486  if (nal_size > sizeof(pps->data)) {
1487  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized PPS "
1488  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1489  nal_size, sizeof(pps->data));
1490  pps->data_size = sizeof(pps->data);
1491  } else {
1492  pps->data_size = nal_size;
1493  }
1494  memcpy(pps->data, gb->buffer, pps->data_size);
1495 
1496  // Default values
1498  pps->num_tile_columns = 1;
1499  pps->num_tile_rows = 1;
1500  pps->uniform_spacing_flag = 1;
1501  pps->disable_dbf = 0;
1502  pps->beta_offset = 0;
1503  pps->tc_offset = 0;
1505 
1506  // Coded parameters
1507  pps_id = get_ue_golomb_long(gb);
1508  if (pps_id >= HEVC_MAX_PPS_COUNT) {
1509  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1510  ret = AVERROR_INVALIDDATA;
1511  goto err;
1512  }
1513  pps->sps_id = get_ue_golomb_long(gb);
1514  if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
1515  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1516  ret = AVERROR_INVALIDDATA;
1517  goto err;
1518  }
1519  if (!ps->sps_list[pps->sps_id]) {
1520  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1521  ret = AVERROR_INVALIDDATA;
1522  goto err;
1523  }
1524  sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1525 
1528  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1529 
1530  pps->sign_data_hiding_flag = get_bits1(gb);
1531 
1533 
1536 
1538 
1541 
1543  pps->diff_cu_qp_delta_depth = 0;
1544  if (pps->cu_qp_delta_enabled_flag)
1546 
1547  if (pps->diff_cu_qp_delta_depth < 0 ||
1549  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1550  pps->diff_cu_qp_delta_depth);
1551  ret = AVERROR_INVALIDDATA;
1552  goto err;
1553  }
1554 
1555  pps->cb_qp_offset = get_se_golomb(gb);
1556  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1557  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1558  pps->cb_qp_offset);
1559  ret = AVERROR_INVALIDDATA;
1560  goto err;
1561  }
1562  pps->cr_qp_offset = get_se_golomb(gb);
1563  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1564  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1565  pps->cr_qp_offset);
1566  ret = AVERROR_INVALIDDATA;
1567  goto err;
1568  }
1570 
1571  pps->weighted_pred_flag = get_bits1(gb);
1572  pps->weighted_bipred_flag = get_bits1(gb);
1573 
1575  pps->tiles_enabled_flag = get_bits1(gb);
1577 
1578  if (pps->tiles_enabled_flag) {
1579  int num_tile_columns_minus1 = get_ue_golomb(gb);
1580  int num_tile_rows_minus1 = get_ue_golomb(gb);
1581 
1582  if (num_tile_columns_minus1 < 0 ||
1583  num_tile_columns_minus1 >= sps->ctb_width) {
1584  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1585  num_tile_columns_minus1);
1586  ret = num_tile_columns_minus1 < 0 ? num_tile_columns_minus1 : AVERROR_INVALIDDATA;
1587  goto err;
1588  }
1589  if (num_tile_rows_minus1 < 0 ||
1590  num_tile_rows_minus1 >= sps->ctb_height) {
1591  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1592  num_tile_rows_minus1);
1593  ret = num_tile_rows_minus1 < 0 ? num_tile_rows_minus1 : AVERROR_INVALIDDATA;
1594  goto err;
1595  }
1596  pps->num_tile_columns = num_tile_columns_minus1 + 1;
1597  pps->num_tile_rows = num_tile_rows_minus1 + 1;
1598 
1599  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1600  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1601  if (!pps->column_width || !pps->row_height) {
1602  ret = AVERROR(ENOMEM);
1603  goto err;
1604  }
1605 
1606  pps->uniform_spacing_flag = get_bits1(gb);
1607  if (!pps->uniform_spacing_flag) {
1608  uint64_t sum = 0;
1609  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1610  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1611  sum += pps->column_width[i];
1612  }
1613  if (sum >= sps->ctb_width) {
1614  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1615  ret = AVERROR_INVALIDDATA;
1616  goto err;
1617  }
1618  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1619 
1620  sum = 0;
1621  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1622  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1623  sum += pps->row_height[i];
1624  }
1625  if (sum >= sps->ctb_height) {
1626  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1627  ret = AVERROR_INVALIDDATA;
1628  goto err;
1629  }
1630  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1631  }
1633  }
1634 
1636 
1640  pps->disable_dbf = get_bits1(gb);
1641  if (!pps->disable_dbf) {
1642  int beta_offset_div2 = get_se_golomb(gb);
1643  int tc_offset_div2 = get_se_golomb(gb) ;
1644  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1645  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1646  beta_offset_div2);
1647  ret = AVERROR_INVALIDDATA;
1648  goto err;
1649  }
1650  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1651  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1652  tc_offset_div2);
1653  ret = AVERROR_INVALIDDATA;
1654  goto err;
1655  }
1656  pps->beta_offset = 2 * beta_offset_div2;
1657  pps->tc_offset = 2 * tc_offset_div2;
1658  }
1659  }
1660 
1662  if (pps->scaling_list_data_present_flag) {
1664  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1665  if (ret < 0)
1666  goto err;
1667  }
1669  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
1670  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
1671  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1672  log2_parallel_merge_level_minus2);
1673  ret = AVERROR_INVALIDDATA;
1674  goto err;
1675  }
1676  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1677 
1679 
1680  if (get_bits1(gb)) { // pps_extension_present_flag
1682  skip_bits(gb, 7); // pps_extension_7bits
1684  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1685  goto err;
1686  }
1687  }
1688 
1689  ret = setup_pps(avctx, gb, pps, sps);
1690  if (ret < 0)
1691  goto err;
1692 
1693  if (get_bits_left(gb) < 0) {
1694  av_log(avctx, AV_LOG_ERROR,
1695  "Overread PPS by %d bits\n", -get_bits_left(gb));
1696  goto err;
1697  }
1698 
1699  remove_pps(ps, pps_id);
1700  ps->pps_list[pps_id] = pps_buf;
1701 
1702  return 0;
1703 
1704 err:
1705  av_buffer_unref(&pps_buf);
1706  return ret;
1707 }
1708 
1710 {
1711  int i;
1712 
1713  for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
1714  av_buffer_unref(&ps->vps_list[i]);
1715  for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
1716  av_buffer_unref(&ps->sps_list[i]);
1717  for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
1718  av_buffer_unref(&ps->pps_list[i]);
1719 
1720  ps->sps = NULL;
1721  ps->pps = NULL;
1722  ps->vps = NULL;
1723 }
1724 
1725 int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
1726 {
1727  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
1728  int prev_poc_lsb = pocTid0 % max_poc_lsb;
1729  int prev_poc_msb = pocTid0 - prev_poc_lsb;
1730  int poc_msb;
1731 
1732  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
1733  poc_msb = prev_poc_msb + max_poc_lsb;
1734  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
1735  poc_msb = prev_poc_msb - max_poc_lsb;
1736  else
1737  poc_msb = prev_poc_msb;
1738 
1739  // For BLA picture types, POCmsb is set to 0.
1740  if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
1741  nal_unit_type == HEVC_NAL_BLA_W_RADL ||
1742  nal_unit_type == HEVC_NAL_BLA_N_LP)
1743  poc_msb = 0;
1744 
1745  return poc_msb + poc_lsb;
1746 }
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
PTLCommon sub_layer_ptl[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:189
const HEVCPPS * pps
Definition: hevc_ps.h:407
#define NULL
Definition: coverity.c:32
unsigned int log2_min_cb_size
Definition: hevc_ps.h:277
int extended_precision_processing_flag
Definition: hevc_ps.h:292
const char const char void * val
Definition: avisynth_c.h:863
uint8_t log2_sao_offset_scale_luma
Definition: hevc_ps.h:378
int min_spatial_segmentation_idc
Definition: hevc_ps.h:168
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
int ctb_height
Definition: hevc_ps.h:302
AVBufferRef * vps_list[HEVC_MAX_VPS_COUNT]
Definition: hevc_ps.h:400
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint8_t diff_cu_chroma_qp_offset_depth
Definition: hevc_ps.h:374
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc_ps.h:161
int max_dec_pic_buffering
Definition: hevc_ps.h:244
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
int transform_skip_rotation_enabled_flag
Definition: hevc_ps.h:288
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
const char * desc
Definition: nvenc.c:68
unsigned int * row_height
RowHeight.
Definition: hevc_ps.h:383
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc_ps.h:211
#define avpriv_request_sample(...)
int pic_init_qp_minus26
Definition: hevc_ps.h:330
unsigned int vps_max_latency_increase[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:204
VUI vui
Definition: hevc_ps.h:250
int vshift[3]
Definition: hevc_ps.h:313
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
static const uint8_t hevc_sub_width_c[]
Definition: hevc_ps.c:73
int num
Numerator.
Definition: rational.h:59
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2656
uint32_t vui_time_scale
Definition: hevc_ps.h:159
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
uint8_t weighted_bipred_flag
Definition: hevc_ps.h:342
const uint8_t * buffer
Definition: get_bits.h:62
int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:119
unsigned int left_offset
Definition: hevc_ps.h:126
Definition: hevc_ps.h:187
#define AV_PIX_FMT_GRAY9
Definition: pixfmt.h:367
unsigned int vps_max_dec_pic_buffering[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:202
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc_ps.h:355
uint8_t cabac_init_present_flag
Definition: hevc_ps.h:326
int chroma_loc_info_present_flag
Definition: hevc_ps.h:146
static void decode_sublayer_hrd(GetBitContext *gb, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:345
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
int max_latency_increase
Definition: hevc_ps.h:246
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint8_t used_by_curr_pic_lt_sps_flag[HEVC_MAX_LONG_TERM_REF_PICS]
Definition: hevc_ps.h:264
ShortTermRPS st_rps[HEVC_MAX_SHORT_TERM_REF_PIC_SETS]
Definition: hevc_ps.h:257
int min_cb_height
Definition: hevc_ps.h:305
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc_ps.h:389
int explicit_rdpcm_enabled_flag
Definition: hevc_ps.h:291
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc_ps.h:328
static const AVRational vui_sar[]
Definition: hevc_ps.c:53
int8_t cr_qp_offset_list[6]
Definition: hevc_ps.h:377
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:498
int chroma_sample_loc_type_top_field
Definition: hevc_ps.h:147
int width
Definition: hevc_ps.h:299
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
int qp_bd_offset
Definition: hevc_ps.h:315
int pixel_shift
Definition: hevc_ps.h:236
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc_ps.h:348
HEVCWindow output_window
Definition: hevc_ps.h:230
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc_ps.h:367
uint8_t log2_sao_offset_scale_chroma
Definition: hevc_ps.h:379
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
int restricted_ref_pic_lists_flag
Definition: hevc_ps.h:167
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static void remove_vps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:105
int chroma_format_idc
Definition: hevc_ps.h:227
uint8_t disable_dbf
Definition: hevc_ps.h:359
unsigned int log2_max_trafo_size
Definition: hevc_ps.h:280
AVBufferRef * sps_list[HEVC_MAX_SPS_COUNT]
Definition: hevc_ps.h:401
uint8_t profile_compatibility_flag[32]
Definition: hevc_ps.h:179
Definition: hevc_ps.h:132
static int decode_hrd(GetBitContext *gb, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:362
unsigned int num_negative_pics
Definition: hevc_ps.h:35
uint8_t
static void remove_pps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:81
static const uint8_t default_scaling_list_inter[]
Definition: hevc_ps.c:42
float delta
HEVCWindow pic_conf_win
Definition: hevc_ps.h:232
uint8_t log2_max_transform_skip_block_size
Definition: hevc_ps.h:370
int overscan_info_present_flag
Definition: hevc_ps.h:135
uint8_t vps_timing_info_present_flag
Definition: hevc_ps.h:207
uint8_t matrix_coeffs
Definition: hevc_ps.h:144
int min_tb_width
Definition: hevc_ps.h:306
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2989
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc_data.c:39
int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id, int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
Parse the SPS from the bitstream into the provided HEVCSPS struct.
Definition: hevc_ps.c:870
const HEVCVPS * vps
Definition: hevc_ps.h:405
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc_ps.h:329
unsigned int log2_min_pcm_cb_size
Definition: hevc_ps.h:270
int min_cb_width
Definition: hevc_ps.h:304
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc_ps.h:198
int frame_field_info_present_flag
Definition: hevc_ps.h:152
uint8_t tier_flag
Definition: hevc_ps.h:177
const H265RawProfileTierLevel * ptl
Definition: h265_levels.c:170
uint8_t scaling_list_data_present_flag
Definition: hevc_ps.h:363
int high_precision_offsets_enabled_flag
Definition: hevc_ps.h:294
AVBufferRef * pps_list[HEVC_MAX_PPS_COUNT]
Definition: hevc_ps.h:402
uint8_t loop_filter_disable_flag
Definition: hevc_ps.h:272
static int map_pixel_format(AVCodecContext *avctx, HEVCSPS *sps)
Definition: hevc_ps.c:821
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2990
int8_t cb_qp_offset_list[6]
Definition: hevc_ps.h:376
int bitstream_restriction_flag
Definition: hevc_ps.h:164
uint8_t transquant_bypass_enable_flag
Definition: hevc_ps.h:344
#define av_log(a,...)
int bit_depth_chroma
Definition: hevc_ps.h:235
int vps_max_layer_id
Definition: hevc_ps.h:205
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t frame_only_constraint_flag
Definition: hevc_ps.h:184
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:949
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
unsigned int log2_max_poc_lsb
Definition: hevc_ps.h:239
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int vps_max_layers
Definition: hevc_ps.h:197
int min_pu_height
Definition: hevc_ps.h:309
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:1725
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
int persistent_rice_adaptation_enabled_flag
Definition: hevc_ps.h:295
uint8_t temporal_id_nesting_flag
Definition: hevc_ps.h:248
int ff_hevc_decode_nal_vps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:424
int data_size
Definition: hevc_ps.h:396
int vui_timing_info_present_flag
Definition: hevc_ps.h:157
uint8_t amp_enabled_flag
Definition: hevc_ps.h:259
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
unsigned int log2_ctb_size
Definition: hevc_ps.h:281
struct HEVCSPS::@94 temporal_layer[HEVC_MAX_SUB_LAYERS]
int vui_poc_proportional_to_timing_flag
Definition: hevc_ps.h:160
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
uint8_t vps_temporal_id_nesting_flag
Definition: hevc_ps.h:196
uint8_t pps_range_extensions_flag
Definition: hevc_ps.h:371
#define FFMAX(a, b)
Definition: common.h:94
uint8_t colour_primaries
Definition: hevc_ps.h:142
uint8_t used[32]
Definition: hevc_ps.h:39
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2867
int motion_vectors_over_pic_boundaries_flag
Definition: hevc_ps.h:166
uint8_t tiles_enabled_flag
Definition: hevc_ps.h:347
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
uint32_t vps_num_units_in_tick
Definition: hevc_ps.h:208
int * col_idxX
Definition: hevc_ps.h:386
uint8_t sub_layer_level_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:192
const HEVCSPS * sps
Definition: hevc_ps.h:406
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc_ps.h:206
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
uint8_t lists_modification_present_flag
Definition: hevc_ps.h:366
int * min_tb_addr_zs_tab
MinTbAddrZS.
Definition: hevc_ps.h:393
uint8_t profile_idc
Definition: hevc_ps.h:178
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:282
static int pps_range_extensions(GetBitContext *gb, AVCodecContext *avctx, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1288
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2697
int max_transform_hierarchy_depth_inter
Definition: hevc_ps.h:284
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
uint8_t vps_poc_proportional_to_timing_flag
Definition: hevc_ps.h:210
unsigned int top_offset
Definition: hevc_ps.h:128
int hshift[3]
Definition: hevc_ps.h:312
unsigned int vps_num_reorder_pics[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:203
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2991
int32_t
int max_bits_per_min_cu_denom
Definition: hevc_ps.h:170
uint8_t cu_qp_delta_enabled_flag
Definition: hevc_ps.h:335
#define s(width, name)
Definition: cbs_vp9.c:257
int ctb_width
Definition: hevc_ps.h:301
uint8_t sl_dc[2][6]
Definition: hevc_ps.h:222
int32_t delta_poc[32]
Definition: hevc_ps.h:38
uint8_t sign_data_hiding_flag
Definition: hevc_ps.h:324
int height
Definition: hevc_ps.h:300
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2708
uint8_t output_flag_present_flag
Definition: hevc_ps.h:343
int log2_max_mv_length_vertical
Definition: hevc_ps.h:172
int data_size
Definition: hevc_ps.h:215
PTLCommon general_ptl
Definition: hevc_ps.h:188
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc_data.c:32
uint8_t sub_layer_profile_present_flag[HEVC_MAX_SUB_LAYERS]
Definition: hevc_ps.h:191
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
int max_bytes_per_pic_denom
Definition: hevc_ps.h:169
int overscan_appropriate_flag
Definition: hevc_ps.h:136
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:719
int implicit_rdpcm_enabled_flag
Definition: hevc_ps.h:290
unsigned vps_id
Definition: hevc_ps.h:226
#define FF_ARRAY_ELEMS(a)
uint8_t constrained_intra_pred_flag
Definition: hevc_ps.h:332
int tb_mask
Definition: hevc_ps.h:310
uint8_t sl[4][6][64]
Definition: hevc_ps.h:221
PTL ptl
Definition: hevc_ps.h:200
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc_ps.h:340
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:105
uint32_t vps_time_scale
Definition: hevc_ps.h:209
int colour_description_present_flag
Definition: hevc_ps.h:141
void ff_hevc_ps_uninit(HEVCParamSets *ps)
Definition: hevc_ps.c:1709
enum AVPixelFormat pix_fmt
Definition: hevc_ps.h:237
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint8_t transform_skip_enabled_flag
Definition: hevc_ps.h:333
uint16_t num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc_ps.h:350
uint8_t uniform_spacing_flag
Definition: hevc_ps.h:352
int ctb_size
Definition: hevc_ps.h:303
static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps)
Definition: hevc_ps.c:554
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc_ps.h:388
PTL ptl
Definition: hevc_ps.h:251
int max_sub_layers
Definition: hevc_ps.h:242
unsigned int log2_min_pu_size
Definition: hevc_ps.h:282
unsigned int sps_id
seq_parameter_set_id
Definition: hevc_ps.h:322
int debug
debug
Definition: avcodec.h:2653
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
ScalingList scaling_list
Definition: hevc_ps.h:364
main external API structure.
Definition: avcodec.h:1568
static int parse_ptl(GetBitContext *gb, AVCodecContext *avctx, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:305
int log2_max_mv_length_horizontal
Definition: hevc_ps.h:171
uint8_t sao_enabled
Definition: hevc_ps.h:260
int num_extra_slice_header_bits
Definition: hevc_ps.h:368
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc_ps.h:353
uint8_t num_long_term_ref_pics_sps
Definition: hevc_ps.h:265
uint8_t cross_component_prediction_enabled_flag
Definition: hevc_ps.h:372
uint32_t vui_num_units_in_tick
Definition: hevc_ps.h:158
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
uint8_t deblocking_filter_control_present_flag
Definition: hevc_ps.h:357
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int transform_skip_context_enabled_flag
Definition: hevc_ps.h:289
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc_ps.h:274
unsigned int nb_st_rps
Definition: hevc_ps.h:256
int chroma_sample_loc_type_bottom_field
Definition: hevc_ps.h:148
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
uint8_t chroma_qp_offset_list_enabled_flag
Definition: hevc_ps.h:373
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int vps_num_hrd_parameters
Definition: hevc_ps.h:212
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:1270
unsigned int log2_min_tb_size
Definition: hevc_ps.h:279
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
int ff_hevc_decode_nal_pps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps)
Definition: hevc_ps.c:1461
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
static const uint8_t hevc_sub_height_c[]
Definition: hevc_ps.c:77
int ff_hevc_decode_nal_sps(GetBitContext *gb, AVCodecContext *avctx, HEVCParamSets *ps, int apply_defdispwin)
Definition: hevc_ps.c:1212
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
uint8_t scaling_list_enable_flag
Definition: hevc_ps.h:253
int * tile_id
TileId.
Definition: hevc_ps.h:390
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:31
int tc_offset
tc_offset_div2 * 2
Definition: hevc_ps.h:361
uint8_t transfer_characteristic
Definition: hevc_ps.h:143
int default_display_window_flag
Definition: hevc_ps.h:154
static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc_ps.h:155
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
int cr_qp_offset
Definition: hevc_ps.h:339
ScalingList scaling_list
Definition: hevc_ps.h:254
#define SIZE_SPECIFIER
Definition: internal.h:262
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc_ps.h:278
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
static int scaling_list_data(GetBitContext *gb, AVCodecContext *avctx, ScalingList *sl, HEVCSPS *sps)
Definition: hevc_ps.c:749
unsigned int log2_max_pcm_cb_size
Definition: hevc_ps.h:271
static int setup_pps(AVCodecContext *avctx, GetBitContext *gb, HEVCPPS *pps, HEVCSPS *sps)
Definition: hevc_ps.c:1329
uint8_t level_idc
Definition: hevc_ps.h:180
int neutra_chroma_indication_flag
Definition: hevc_ps.h:149
int * tile_pos_rs
TilePosRS.
Definition: hevc_ps.h:391
static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc_data.c:25
int data_size
Definition: hevc_ps.h:318
A reference to a data buffer.
Definition: buffer.h:81
int max_transform_hierarchy_depth_intra
Definition: hevc_ps.h:285
uint8_t profile_space
Definition: hevc_ps.h:176
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
unsigned int * row_bd
RowBd.
Definition: hevc_ps.h:385
uint16_t lt_ref_pic_poc_lsb_sps[HEVC_MAX_LONG_TERM_REF_PICS]
Definition: hevc_ps.h:263
int video_format
Definition: hevc_ps.h:139
uint8_t weighted_pred_flag
Definition: hevc_ps.h:341
uint8_t data[4096]
Definition: hevc_ps.h:214
uint16_t num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc_ps.h:351
unsigned int * col_bd
ColBd.
Definition: hevc_ps.h:384
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2891
const uint8_t * buffer_end
Definition: get_bits.h:62
unsigned int * column_width
ColumnWidth.
Definition: hevc_ps.h:382
uint8_t slice_header_extension_present_flag
Definition: hevc_ps.h:369
static int decode_profile_tier_level(GetBitContext *gb, AVCodecContext *avctx, PTLCommon *ptl)
Definition: hevc_ps.c:265
int den
Denominator.
Definition: rational.h:60
int video_full_range_flag
Definition: hevc_ps.h:140
int cabac_bypass_alignment_enabled_flag
coded frame dimension in various units
Definition: hevc_ps.h:296
AVRational sar
Definition: hevc_ps.h:133
uint8_t chroma_qp_offset_list_len_minus1
Definition: hevc_ps.h:375
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc_data.c:58
int num_delta_pocs
Definition: hevc_ps.h:36
#define FF_PROFILE_HEVC_REXT
Definition: avcodec.h:2992
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc_ps.h:275
int rps_idx_num_delta_pocs
Definition: hevc_ps.h:37
uint8_t data[4096]
Definition: hevc_ps.h:317
int min_pu_width
Definition: hevc_ps.h:308
int sps_range_extension_flag
Definition: hevc_ps.h:287
uint8_t long_term_ref_pics_present_flag
Definition: hevc_ps.h:262
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1655
int vui_hrd_parameters_present_flag
Definition: hevc_ps.h:162
unsigned int right_offset
Definition: hevc_ps.h:127
int diff_cu_qp_delta_depth
Definition: hevc_ps.h:336
struct HEVCSPS::@95 pcm
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
int num_reorder_pics
Definition: hevc_ps.h:245
static void remove_sps(HEVCParamSets *s, int id)
Definition: hevc_ps.c:88
uint8_t progressive_source_flag
Definition: hevc_ps.h:181
int cb_qp_offset
Definition: hevc_ps.h:338
#define av_malloc_array(a, b)
int video_signal_type_present_flag
Definition: hevc_ps.h:138
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc_ps.h:358
int bit_depth
Definition: hevc_ps.h:234
int beta_offset
beta_offset_div2 * 2
Definition: hevc_ps.h:360
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:2438
int min_tb_height
Definition: hevc_ps.h:307
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc_ps.h:392
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
uint8_t non_packed_constraint_flag
Definition: hevc_ps.h:183
int intra_smoothing_disabled_flag
Definition: hevc_ps.h:293
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc_ps.h:240
enum AVCodecID id
int tiles_fixed_structure_flag
Definition: hevc_ps.h:165
uint8_t interlaced_source_flag
Definition: hevc_ps.h:182
int field_seq_flag
Definition: hevc_ps.h:151
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
Definition: hevc_ps.h:228
unsigned int bottom_offset
Definition: hevc_ps.h:129
int vps_sub_layer_ordering_info_present_flag
Definition: hevc_ps.h:201
uint8_t data[4096]
Definition: hevc_ps.h:395
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc_ps.h:346
static uint8_t tmp[11]
Definition: aes_ctr.c:26