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  if (vps_id >= HEVC_MAX_VPS_COUNT) {
452  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
453  goto err;
454  }
455 
456  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
457  av_log(avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
458  goto err;
459  }
460 
461  vps->vps_max_layers = get_bits(gb, 6) + 1;
462  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
464 
465  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
466  av_log(avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
467  goto err;
468  }
469 
471  av_log(avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
472  vps->vps_max_sub_layers);
473  goto err;
474  }
475 
476  if (parse_ptl(gb, avctx, &vps->ptl, vps->vps_max_sub_layers) < 0)
477  goto err;
478 
480 
482  for (; i < vps->vps_max_sub_layers; i++) {
486 
488  av_log(avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
489  vps->vps_max_dec_pic_buffering[i] - 1);
490  goto err;
491  }
492  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
493  av_log(avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
494  vps->vps_num_reorder_pics[i]);
495  if (avctx->err_recognition & AV_EF_EXPLODE)
496  goto err;
497  }
498  }
499 
500  vps->vps_max_layer_id = get_bits(gb, 6);
501  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
502  if (vps->vps_num_layer_sets < 1 || vps->vps_num_layer_sets > 1024 ||
503  (vps->vps_num_layer_sets - 1LL) * (vps->vps_max_layer_id + 1LL) > get_bits_left(gb)) {
504  av_log(avctx, AV_LOG_ERROR, "too many layer_id_included_flags\n");
505  goto err;
506  }
507 
508  for (i = 1; i < vps->vps_num_layer_sets; i++)
509  for (j = 0; j <= vps->vps_max_layer_id; j++)
510  skip_bits(gb, 1); // layer_id_included_flag[i][j]
511 
513  if (vps->vps_timing_info_present_flag) {
514  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
515  vps->vps_time_scale = get_bits_long(gb, 32);
520  if (vps->vps_num_hrd_parameters > (unsigned)vps->vps_num_layer_sets) {
521  av_log(avctx, AV_LOG_ERROR,
522  "vps_num_hrd_parameters %d is invalid\n", vps->vps_num_hrd_parameters);
523  goto err;
524  }
525  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
526  int common_inf_present = 1;
527 
528  get_ue_golomb_long(gb); // hrd_layer_set_idx
529  if (i)
530  common_inf_present = get_bits1(gb);
531  decode_hrd(gb, common_inf_present, vps->vps_max_sub_layers);
532  }
533  }
534  get_bits1(gb); /* vps_extension_flag */
535 
536  if (get_bits_left(gb) < 0) {
537  av_log(avctx, AV_LOG_ERROR,
538  "Overread VPS by %d bits\n", -get_bits_left(gb));
539  if (ps->vps_list[vps_id])
540  goto err;
541  }
542 
543  if (ps->vps_list[vps_id] &&
544  !memcmp(ps->vps_list[vps_id]->data, vps_buf->data, vps_buf->size)) {
545  av_buffer_unref(&vps_buf);
546  } else {
547  remove_vps(ps, vps_id);
548  ps->vps_list[vps_id] = vps_buf;
549  }
550 
551  return 0;
552 
553 err:
554  av_buffer_unref(&vps_buf);
555  return AVERROR_INVALIDDATA;
556 }
557 
558 static void decode_vui(GetBitContext *gb, AVCodecContext *avctx,
559  int apply_defdispwin, HEVCSPS *sps)
560 {
561  VUI backup_vui, *vui = &sps->vui;
562  GetBitContext backup;
563  int sar_present, alt = 0;
564 
565  av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n");
566 
567  sar_present = get_bits1(gb);
568  if (sar_present) {
569  uint8_t sar_idx = get_bits(gb, 8);
570  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
571  vui->sar = vui_sar[sar_idx];
572  else if (sar_idx == 255) {
573  vui->sar.num = get_bits(gb, 16);
574  vui->sar.den = get_bits(gb, 16);
575  } else
576  av_log(avctx, AV_LOG_WARNING,
577  "Unknown SAR index: %u.\n", sar_idx);
578  }
579 
583 
586  vui->video_format = get_bits(gb, 3);
587  vui->video_full_range_flag = get_bits1(gb);
592  vui->colour_primaries = get_bits(gb, 8);
593  vui->transfer_characteristic = get_bits(gb, 8);
594  vui->matrix_coeffs = get_bits(gb, 8);
595 
596  // Set invalid values to "unspecified"
603  if (vui->matrix_coeffs == AVCOL_SPC_RGB) {
604  switch (sps->pix_fmt) {
605  case AV_PIX_FMT_YUV444P:
606  sps->pix_fmt = AV_PIX_FMT_GBRP;
607  break;
609  sps->pix_fmt = AV_PIX_FMT_GBRP10;
610  break;
612  sps->pix_fmt = AV_PIX_FMT_GBRP12;
613  break;
614  }
615  }
616  }
617  }
618 
620  if (vui->chroma_loc_info_present_flag) {
623  }
624 
626  vui->field_seq_flag = get_bits1(gb);
628 
629  // Backup context in case an alternate header is detected
630  memcpy(&backup, gb, sizeof(backup));
631  memcpy(&backup_vui, vui, sizeof(backup_vui));
632  if (get_bits_left(gb) >= 68 && show_bits_long(gb, 21) == 0x100000) {
634  av_log(avctx, AV_LOG_WARNING, "Invalid default display window\n");
635  } else
637 
638  if (vui->default_display_window_flag) {
639  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
640  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
641  vui->def_disp_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
642  vui->def_disp_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
643  vui->def_disp_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
644  vui->def_disp_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
645 
646  if (apply_defdispwin &&
648  av_log(avctx, AV_LOG_DEBUG,
649  "discarding vui default display window, "
650  "original values are l:%u r:%u t:%u b:%u\n",
655 
658  vui->def_disp_win.top_offset =
659  vui->def_disp_win.bottom_offset = 0;
660  }
661  }
662 
665 
666  if (vui->vui_timing_info_present_flag) {
667  if( get_bits_left(gb) < 66 && !alt) {
668  // The alternate syntax seem to have timing info located
669  // at where def_disp_win is normally located
670  av_log(avctx, AV_LOG_WARNING,
671  "Strange VUI timing information, retrying...\n");
672  memcpy(vui, &backup_vui, sizeof(backup_vui));
673  memcpy(gb, &backup, sizeof(backup));
674  alt = 1;
675  goto timing_info;
676  }
677  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
678  vui->vui_time_scale = get_bits_long(gb, 32);
679  if (alt) {
680  av_log(avctx, AV_LOG_INFO, "Retry got %"PRIu32"/%"PRIu32" fps\n",
682  }
688  decode_hrd(gb, 1, sps->max_sub_layers);
689  }
690 
692  if (vui->bitstream_restriction_flag) {
693  if (get_bits_left(gb) < 8 && !alt) {
694  av_log(avctx, AV_LOG_WARNING,
695  "Strange VUI bitstream restriction information, retrying"
696  " from timing information...\n");
697  memcpy(vui, &backup_vui, sizeof(backup_vui));
698  memcpy(gb, &backup, sizeof(backup));
699  alt = 1;
700  goto timing_info;
701  }
710  }
711 
712  if (get_bits_left(gb) < 1 && !alt) {
713  // XXX: Alternate syntax when sps_range_extension_flag != 0?
714  av_log(avctx, AV_LOG_WARNING,
715  "Overread in VUI, retrying from timing information...\n");
716  memcpy(vui, &backup_vui, sizeof(backup_vui));
717  memcpy(gb, &backup, sizeof(backup));
718  alt = 1;
719  goto timing_info;
720  }
721 }
722 
724 {
725  int matrixId;
726 
727  for (matrixId = 0; matrixId < 6; matrixId++) {
728  // 4x4 default is 16
729  memset(sl->sl[0][matrixId], 16, 16);
730  sl->sl_dc[0][matrixId] = 16; // default for 16x16
731  sl->sl_dc[1][matrixId] = 16; // default for 32x32
732  }
733  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
734  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
735  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
736  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
737  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
738  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
739  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
740  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
741  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
742  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
743  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
744  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
745  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
746  memcpy(sl->sl[3][1], default_scaling_list_intra, 64);
747  memcpy(sl->sl[3][2], default_scaling_list_intra, 64);
748  memcpy(sl->sl[3][3], default_scaling_list_inter, 64);
749  memcpy(sl->sl[3][4], default_scaling_list_inter, 64);
750  memcpy(sl->sl[3][5], default_scaling_list_inter, 64);
751 }
752 
754 {
755  uint8_t scaling_list_pred_mode_flag;
756  int32_t scaling_list_dc_coef[2][6];
757  int size_id, matrix_id, pos;
758  int i;
759 
760  for (size_id = 0; size_id < 4; size_id++)
761  for (matrix_id = 0; matrix_id < 6; matrix_id += ((size_id == 3) ? 3 : 1)) {
762  scaling_list_pred_mode_flag = get_bits1(gb);
763  if (!scaling_list_pred_mode_flag) {
764  unsigned int delta = get_ue_golomb_long(gb);
765  /* Only need to handle non-zero delta. Zero means default,
766  * which should already be in the arrays. */
767  if (delta) {
768  // Copy from previous array.
769  delta *= (size_id == 3) ? 3 : 1;
770  if (matrix_id < delta) {
771  av_log(avctx, AV_LOG_ERROR,
772  "Invalid delta in scaling list data: %d.\n", delta);
773  return AVERROR_INVALIDDATA;
774  }
775 
776  memcpy(sl->sl[size_id][matrix_id],
777  sl->sl[size_id][matrix_id - delta],
778  size_id > 0 ? 64 : 16);
779  if (size_id > 1)
780  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
781  }
782  } else {
783  int next_coef, coef_num;
784  int32_t scaling_list_delta_coef;
785 
786  next_coef = 8;
787  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
788  if (size_id > 1) {
789  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
790  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
791  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
792  }
793  for (i = 0; i < coef_num; i++) {
794  if (size_id == 0)
795  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
797  else
798  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
800 
801  scaling_list_delta_coef = get_se_golomb(gb);
802  next_coef = (next_coef + 256U + scaling_list_delta_coef) % 256;
803  sl->sl[size_id][matrix_id][pos] = next_coef;
804  }
805  }
806  }
807 
808  if (sps->chroma_format_idc == 3) {
809  for (i = 0; i < 64; i++) {
810  sl->sl[3][1][i] = sl->sl[2][1][i];
811  sl->sl[3][2][i] = sl->sl[2][2][i];
812  sl->sl[3][4][i] = sl->sl[2][4][i];
813  sl->sl[3][5][i] = sl->sl[2][5][i];
814  }
815  sl->sl_dc[1][1] = sl->sl_dc[0][1];
816  sl->sl_dc[1][2] = sl->sl_dc[0][2];
817  sl->sl_dc[1][4] = sl->sl_dc[0][4];
818  sl->sl_dc[1][5] = sl->sl_dc[0][5];
819  }
820 
821 
822  return 0;
823 }
824 
826 {
827  const AVPixFmtDescriptor *desc;
828  switch (sps->bit_depth) {
829  case 8:
830  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY8;
831  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P;
832  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P;
833  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P;
834  break;
835  case 9:
836  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY9;
837  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P9;
838  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P9;
839  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P9;
840  break;
841  case 10:
842  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY10;
843  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P10;
844  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P10;
845  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P10;
846  break;
847  case 12:
848  if (sps->chroma_format_idc == 0) sps->pix_fmt = AV_PIX_FMT_GRAY12;
849  if (sps->chroma_format_idc == 1) sps->pix_fmt = AV_PIX_FMT_YUV420P12;
850  if (sps->chroma_format_idc == 2) sps->pix_fmt = AV_PIX_FMT_YUV422P12;
851  if (sps->chroma_format_idc == 3) sps->pix_fmt = AV_PIX_FMT_YUV444P12;
852  break;
853  default:
854  av_log(avctx, AV_LOG_ERROR,
855  "The following bit-depths are currently specified: 8, 9, 10 and 12 bits, "
856  "chroma_format_idc is %d, depth is %d\n",
857  sps->chroma_format_idc, sps->bit_depth);
858  return AVERROR_INVALIDDATA;
859  }
860 
861  desc = av_pix_fmt_desc_get(sps->pix_fmt);
862  if (!desc)
863  return AVERROR(EINVAL);
864 
865  sps->hshift[0] = sps->vshift[0] = 0;
866  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
867  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
868 
869  sps->pixel_shift = sps->bit_depth > 8;
870 
871  return 0;
872 }
873 
874 int ff_hevc_parse_sps(HEVCSPS *sps, GetBitContext *gb, unsigned int *sps_id,
875  int apply_defdispwin, AVBufferRef **vps_list, AVCodecContext *avctx)
876 {
877  HEVCWindow *ow;
878  int ret = 0;
879  int log2_diff_max_min_transform_block_size;
880  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
881  int i;
882 
883  // Coded parameters
884 
885  sps->vps_id = get_bits(gb, 4);
886  if (sps->vps_id >= HEVC_MAX_VPS_COUNT) {
887  av_log(avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
888  return AVERROR_INVALIDDATA;
889  }
890 
891  if (vps_list && !vps_list[sps->vps_id]) {
892  av_log(avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
893  sps->vps_id);
894  return AVERROR_INVALIDDATA;
895  }
896 
897  sps->max_sub_layers = get_bits(gb, 3) + 1;
898  if (sps->max_sub_layers > HEVC_MAX_SUB_LAYERS) {
899  av_log(avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
900  sps->max_sub_layers);
901  return AVERROR_INVALIDDATA;
902  }
903 
904  sps->temporal_id_nesting_flag = get_bits(gb, 1);
905 
906  if ((ret = parse_ptl(gb, avctx, &sps->ptl, sps->max_sub_layers)) < 0)
907  return ret;
908 
909  *sps_id = get_ue_golomb_long(gb);
910  if (*sps_id >= HEVC_MAX_SPS_COUNT) {
911  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", *sps_id);
912  return AVERROR_INVALIDDATA;
913  }
914 
916  if (sps->chroma_format_idc > 3U) {
917  av_log(avctx, AV_LOG_ERROR, "chroma_format_idc %d is invalid\n", sps->chroma_format_idc);
918  return AVERROR_INVALIDDATA;
919  }
920 
921  if (sps->chroma_format_idc == 3)
923 
925  sps->chroma_format_idc = 0;
926 
927  sps->width = get_ue_golomb_long(gb);
928  sps->height = get_ue_golomb_long(gb);
929  if ((ret = av_image_check_size(sps->width,
930  sps->height, 0, avctx)) < 0)
931  return ret;
932 
933  if (get_bits1(gb)) { // pic_conformance_flag
934  int vert_mult = hevc_sub_height_c[sps->chroma_format_idc];
935  int horiz_mult = hevc_sub_width_c[sps->chroma_format_idc];
936  sps->pic_conf_win.left_offset = get_ue_golomb_long(gb) * horiz_mult;
937  sps->pic_conf_win.right_offset = get_ue_golomb_long(gb) * horiz_mult;
938  sps->pic_conf_win.top_offset = get_ue_golomb_long(gb) * vert_mult;
939  sps->pic_conf_win.bottom_offset = get_ue_golomb_long(gb) * vert_mult;
940 
941  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
942  av_log(avctx, AV_LOG_DEBUG,
943  "discarding sps conformance window, "
944  "original values are l:%u r:%u t:%u b:%u\n",
949 
952  sps->pic_conf_win.top_offset =
953  sps->pic_conf_win.bottom_offset = 0;
954  }
955  sps->output_window = sps->pic_conf_win;
956  }
957 
958  sps->bit_depth = get_ue_golomb_long(gb) + 8;
959  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
960  if (sps->chroma_format_idc && bit_depth_chroma != sps->bit_depth) {
961  av_log(avctx, AV_LOG_ERROR,
962  "Luma bit depth (%d) is different from chroma bit depth (%d), "
963  "this is unsupported.\n",
964  sps->bit_depth, bit_depth_chroma);
965  return AVERROR_INVALIDDATA;
966  }
967  sps->bit_depth_chroma = bit_depth_chroma;
968 
969  ret = map_pixel_format(avctx, sps);
970  if (ret < 0)
971  return ret;
972 
973  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
974  if (sps->log2_max_poc_lsb > 16) {
975  av_log(avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
976  sps->log2_max_poc_lsb - 4);
977  return AVERROR_INVALIDDATA;
978  }
979 
980  sublayer_ordering_info = get_bits1(gb);
981  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
982  for (i = start; i < sps->max_sub_layers; i++) {
986  if (sps->temporal_layer[i].max_dec_pic_buffering > (unsigned)HEVC_MAX_DPB_SIZE) {
987  av_log(avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
989  return AVERROR_INVALIDDATA;
990  }
992  av_log(avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
994  if (avctx->err_recognition & AV_EF_EXPLODE ||
995  sps->temporal_layer[i].num_reorder_pics > HEVC_MAX_DPB_SIZE - 1) {
996  return AVERROR_INVALIDDATA;
997  }
999  }
1000  }
1001 
1002  if (!sublayer_ordering_info) {
1003  for (i = 0; i < start; i++) {
1007  }
1008  }
1009 
1010  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
1012  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
1013  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
1014  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
1015  sps->log2_min_tb_size;
1016 
1017  if (sps->log2_min_cb_size < 3 || sps->log2_min_cb_size > 30) {
1018  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_min_cb_size", sps->log2_min_cb_size);
1019  return AVERROR_INVALIDDATA;
1020  }
1021 
1022  if (sps->log2_diff_max_min_coding_block_size > 30) {
1023  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);
1024  return AVERROR_INVALIDDATA;
1025  }
1026 
1027  if (sps->log2_min_tb_size >= sps->log2_min_cb_size || sps->log2_min_tb_size < 2) {
1028  av_log(avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
1029  return AVERROR_INVALIDDATA;
1030  }
1031 
1032  if (log2_diff_max_min_transform_block_size < 0 || log2_diff_max_min_transform_block_size > 30) {
1033  av_log(avctx, AV_LOG_ERROR, "Invalid value %d for log2_diff_max_min_transform_block_size", log2_diff_max_min_transform_block_size);
1034  return AVERROR_INVALIDDATA;
1035  }
1036 
1039 
1041  if (sps->scaling_list_enable_flag) {
1043 
1044  if (get_bits1(gb)) {
1045  ret = scaling_list_data(gb, avctx, &sps->scaling_list, sps);
1046  if (ret < 0)
1047  return ret;
1048  }
1049  }
1050 
1051  sps->amp_enabled_flag = get_bits1(gb);
1052  sps->sao_enabled = get_bits1(gb);
1053 
1054  sps->pcm_enabled_flag = get_bits1(gb);
1055  if (sps->pcm_enabled_flag) {
1056  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
1057  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
1060  get_ue_golomb_long(gb);
1061  if (FFMAX(sps->pcm.bit_depth, sps->pcm.bit_depth_chroma) > sps->bit_depth) {
1062  av_log(avctx, AV_LOG_ERROR,
1063  "PCM bit depth (%d, %d) is greater than normal bit depth (%d)\n",
1064  sps->pcm.bit_depth, sps->pcm.bit_depth_chroma, sps->bit_depth);
1065  return AVERROR_INVALIDDATA;
1066  }
1067 
1069  }
1070 
1071  sps->nb_st_rps = get_ue_golomb_long(gb);
1073  av_log(avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
1074  sps->nb_st_rps);
1075  return AVERROR_INVALIDDATA;
1076  }
1077  for (i = 0; i < sps->nb_st_rps; i++) {
1078  if ((ret = ff_hevc_decode_short_term_rps(gb, avctx, &sps->st_rps[i],
1079  sps, 0)) < 0)
1080  return ret;
1081  }
1082 
1087  av_log(avctx, AV_LOG_ERROR, "Too many long term ref pics: %d.\n",
1089  return AVERROR_INVALIDDATA;
1090  }
1091  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
1094  }
1095  }
1096 
1099  sps->vui.sar = (AVRational){0, 1};
1100  vui_present = get_bits1(gb);
1101  if (vui_present)
1102  decode_vui(gb, avctx, apply_defdispwin, sps);
1103 
1104  if (get_bits1(gb)) { // sps_extension_flag
1106  skip_bits(gb, 7); //sps_extension_7bits = get_bits(gb, 7);
1107  if (sps->sps_range_extension_flag) {
1111 
1113 
1116  av_log(avctx, AV_LOG_WARNING,
1117  "extended_precision_processing_flag not yet implemented\n");
1118 
1122  av_log(avctx, AV_LOG_WARNING,
1123  "high_precision_offsets_enabled_flag not yet implemented\n");
1124 
1126 
1129  av_log(avctx, AV_LOG_WARNING,
1130  "cabac_bypass_alignment_enabled_flag not yet implemented\n");
1131  }
1132  }
1133  if (apply_defdispwin) {
1138  }
1139 
1140  ow = &sps->output_window;
1141  if (ow->left_offset >= INT_MAX - ow->right_offset ||
1142  ow->top_offset >= INT_MAX - ow->bottom_offset ||
1143  ow->left_offset + ow->right_offset >= sps->width ||
1144  ow->top_offset + ow->bottom_offset >= sps->height) {
1145  av_log(avctx, AV_LOG_WARNING, "Invalid cropping offsets: %u/%u/%u/%u\n",
1146  ow->left_offset, ow->right_offset, ow->top_offset, ow->bottom_offset);
1147  if (avctx->err_recognition & AV_EF_EXPLODE) {
1148  return AVERROR_INVALIDDATA;
1149  }
1150  av_log(avctx, AV_LOG_WARNING,
1151  "Displaying the whole video surface.\n");
1152  memset(ow, 0, sizeof(*ow));
1153  memset(&sps->pic_conf_win, 0, sizeof(sps->pic_conf_win));
1154  }
1155 
1156  // Inferred parameters
1157  sps->log2_ctb_size = sps->log2_min_cb_size +
1159  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
1160 
1162  av_log(avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
1163  return AVERROR_INVALIDDATA;
1164  }
1165  if (sps->log2_ctb_size < 4) {
1166  av_log(avctx,
1167  AV_LOG_ERROR,
1168  "log2_ctb_size %d differs from the bounds of any known profile\n",
1169  sps->log2_ctb_size);
1170  avpriv_request_sample(avctx, "log2_ctb_size %d", sps->log2_ctb_size);
1171  return AVERROR_INVALIDDATA;
1172  }
1173 
1174  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1175  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
1176  sps->ctb_size = sps->ctb_width * sps->ctb_height;
1177 
1178  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
1179  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
1180  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
1181  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
1182  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
1183  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
1184  sps->tb_mask = (1 << (sps->log2_ctb_size - sps->log2_min_tb_size)) - 1;
1185 
1186  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
1187 
1188  if (av_mod_uintp2(sps->width, sps->log2_min_cb_size) ||
1189  av_mod_uintp2(sps->height, sps->log2_min_cb_size)) {
1190  av_log(avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
1191  return AVERROR_INVALIDDATA;
1192  }
1193 
1195  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
1197  return AVERROR_INVALIDDATA;
1198  }
1200  av_log(avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
1202  return AVERROR_INVALIDDATA;
1203  }
1204  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
1205  av_log(avctx, AV_LOG_ERROR,
1206  "max transform block size out of range: %d\n",
1207  sps->log2_max_trafo_size);
1208  return AVERROR_INVALIDDATA;
1209  }
1210 
1211  if (get_bits_left(gb) < 0) {
1212  av_log(avctx, AV_LOG_ERROR,
1213  "Overread SPS by %d bits\n", -get_bits_left(gb));
1214  return AVERROR_INVALIDDATA;
1215  }
1216 
1217  return 0;
1218 }
1219 
1221  HEVCParamSets *ps, int apply_defdispwin)
1222 {
1223  HEVCSPS *sps;
1224  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
1225  unsigned int sps_id;
1226  int ret;
1227  ptrdiff_t nal_size;
1228 
1229  if (!sps_buf)
1230  return AVERROR(ENOMEM);
1231  sps = (HEVCSPS*)sps_buf->data;
1232 
1233  av_log(avctx, AV_LOG_DEBUG, "Decoding SPS\n");
1234 
1235  nal_size = gb->buffer_end - gb->buffer;
1236  if (nal_size > sizeof(sps->data)) {
1237  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized SPS "
1238  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1239  nal_size, sizeof(sps->data));
1240  sps->data_size = sizeof(sps->data);
1241  } else {
1242  sps->data_size = nal_size;
1243  }
1244  memcpy(sps->data, gb->buffer, sps->data_size);
1245 
1246  ret = ff_hevc_parse_sps(sps, gb, &sps_id,
1247  apply_defdispwin,
1248  ps->vps_list, avctx);
1249  if (ret < 0) {
1250  av_buffer_unref(&sps_buf);
1251  return ret;
1252  }
1253 
1254  if (avctx->debug & FF_DEBUG_BITSTREAM) {
1255  av_log(avctx, AV_LOG_DEBUG,
1256  "Parsed SPS: id %d; coded wxh: %dx%d; "
1257  "cropped wxh: %dx%d; pix_fmt: %s.\n",
1258  sps_id, sps->width, sps->height,
1262  }
1263 
1264  /* check if this is a repeat of an already parsed SPS, then keep the
1265  * original one.
1266  * otherwise drop all PPSes that depend on it */
1267  if (ps->sps_list[sps_id] &&
1268  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
1269  av_buffer_unref(&sps_buf);
1270  } else {
1271  remove_sps(ps, sps_id);
1272  ps->sps_list[sps_id] = sps_buf;
1273  }
1274 
1275  return 0;
1276 }
1277 
1278 static void hevc_pps_free(void *opaque, uint8_t *data)
1279 {
1280  HEVCPPS *pps = (HEVCPPS*)data;
1281 
1282  av_freep(&pps->column_width);
1283  av_freep(&pps->row_height);
1284  av_freep(&pps->col_bd);
1285  av_freep(&pps->row_bd);
1286  av_freep(&pps->col_idxX);
1287  av_freep(&pps->ctb_addr_rs_to_ts);
1288  av_freep(&pps->ctb_addr_ts_to_rs);
1289  av_freep(&pps->tile_pos_rs);
1290  av_freep(&pps->tile_id);
1292 
1293  av_freep(&pps);
1294 }
1295 
1297  HEVCPPS *pps, HEVCSPS *sps) {
1298  int i;
1299 
1300  if (pps->transform_skip_enabled_flag) {
1302  }
1308  if (pps->chroma_qp_offset_list_len_minus1 > 5) {
1309  av_log(avctx, AV_LOG_ERROR,
1310  "chroma_qp_offset_list_len_minus1 shall be in the range [0, 5].\n");
1311  return AVERROR_INVALIDDATA;
1312  }
1313  for (i = 0; i <= pps->chroma_qp_offset_list_len_minus1; i++) {
1315  if (pps->cb_qp_offset_list[i]) {
1316  av_log(avctx, AV_LOG_WARNING,
1317  "cb_qp_offset_list not tested yet.\n");
1318  }
1320  if (pps->cr_qp_offset_list[i]) {
1321  av_log(avctx, AV_LOG_WARNING,
1322  "cb_qp_offset_list not tested yet.\n");
1323  }
1324  }
1325  }
1328 
1329  if ( pps->log2_sao_offset_scale_luma > FFMAX(sps->bit_depth - 10, 0)
1330  || pps->log2_sao_offset_scale_chroma > FFMAX(sps->bit_depth_chroma - 10, 0)
1331  )
1332  return AVERROR_INVALIDDATA;
1333 
1334  return(0);
1335 }
1336 
1337 static inline int setup_pps(AVCodecContext *avctx, GetBitContext *gb,
1338  HEVCPPS *pps, HEVCSPS *sps)
1339 {
1340  int log2_diff;
1341  int pic_area_in_ctbs;
1342  int i, j, x, y, ctb_addr_rs, tile_id;
1343 
1344  // Inferred parameters
1345  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1346  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1347  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1348  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX)
1349  return AVERROR(ENOMEM);
1350 
1351  if (pps->uniform_spacing_flag) {
1352  if (!pps->column_width) {
1353  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1354  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1355  }
1356  if (!pps->column_width || !pps->row_height)
1357  return AVERROR(ENOMEM);
1358 
1359  for (i = 0; i < pps->num_tile_columns; i++) {
1360  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1361  (i * sps->ctb_width) / pps->num_tile_columns;
1362  }
1363 
1364  for (i = 0; i < pps->num_tile_rows; i++) {
1365  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1366  (i * sps->ctb_height) / pps->num_tile_rows;
1367  }
1368  }
1369 
1370  pps->col_bd[0] = 0;
1371  for (i = 0; i < pps->num_tile_columns; i++)
1372  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1373 
1374  pps->row_bd[0] = 0;
1375  for (i = 0; i < pps->num_tile_rows; i++)
1376  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1377 
1378  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1379  if (i > pps->col_bd[j])
1380  j++;
1381  pps->col_idxX[i] = j;
1382  }
1383 
1384  /**
1385  * 6.5
1386  */
1387  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1388 
1389  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1390  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1391  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1392  pps->min_tb_addr_zs_tab = av_malloc_array((sps->tb_mask+2) * (sps->tb_mask+2), sizeof(*pps->min_tb_addr_zs_tab));
1393  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1394  !pps->tile_id || !pps->min_tb_addr_zs_tab) {
1395  return AVERROR(ENOMEM);
1396  }
1397 
1398  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1399  int tb_x = ctb_addr_rs % sps->ctb_width;
1400  int tb_y = ctb_addr_rs / sps->ctb_width;
1401  int tile_x = 0;
1402  int tile_y = 0;
1403  int val = 0;
1404 
1405  for (i = 0; i < pps->num_tile_columns; i++) {
1406  if (tb_x < pps->col_bd[i + 1]) {
1407  tile_x = i;
1408  break;
1409  }
1410  }
1411 
1412  for (i = 0; i < pps->num_tile_rows; i++) {
1413  if (tb_y < pps->row_bd[i + 1]) {
1414  tile_y = i;
1415  break;
1416  }
1417  }
1418 
1419  for (i = 0; i < tile_x; i++)
1420  val += pps->row_height[tile_y] * pps->column_width[i];
1421  for (i = 0; i < tile_y; i++)
1422  val += sps->ctb_width * pps->row_height[i];
1423 
1424  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1425  tb_x - pps->col_bd[tile_x];
1426 
1427  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1428  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1429  }
1430 
1431  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1432  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1433  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1434  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1435  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1436 
1437  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1438  if (!pps->tile_pos_rs)
1439  return AVERROR(ENOMEM);
1440 
1441  for (j = 0; j < pps->num_tile_rows; j++)
1442  for (i = 0; i < pps->num_tile_columns; i++)
1443  pps->tile_pos_rs[j * pps->num_tile_columns + i] =
1444  pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1445 
1446  log2_diff = sps->log2_ctb_size - sps->log2_min_tb_size;
1447  pps->min_tb_addr_zs = &pps->min_tb_addr_zs_tab[1*(sps->tb_mask+2)+1];
1448  for (y = 0; y < sps->tb_mask+2; y++) {
1449  pps->min_tb_addr_zs_tab[y*(sps->tb_mask+2)] = -1;
1450  pps->min_tb_addr_zs_tab[y] = -1;
1451  }
1452  for (y = 0; y < sps->tb_mask+1; y++) {
1453  for (x = 0; x < sps->tb_mask+1; x++) {
1454  int tb_x = x >> log2_diff;
1455  int tb_y = y >> log2_diff;
1456  int rs = sps->ctb_width * tb_y + tb_x;
1457  int val = pps->ctb_addr_rs_to_ts[rs] << (log2_diff * 2);
1458  for (i = 0; i < log2_diff; i++) {
1459  int m = 1 << i;
1460  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1461  }
1462  pps->min_tb_addr_zs[y * (sps->tb_mask+2) + x] = val;
1463  }
1464  }
1465 
1466  return 0;
1467 }
1468 
1470  HEVCParamSets *ps)
1471 {
1472  HEVCSPS *sps = NULL;
1473  int i, ret = 0;
1474  unsigned int pps_id = 0;
1475  ptrdiff_t nal_size;
1476  unsigned log2_parallel_merge_level_minus2;
1477 
1478  AVBufferRef *pps_buf;
1479  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1480 
1481  if (!pps)
1482  return AVERROR(ENOMEM);
1483 
1484  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1485  hevc_pps_free, NULL, 0);
1486  if (!pps_buf) {
1487  av_freep(&pps);
1488  return AVERROR(ENOMEM);
1489  }
1490 
1491  av_log(avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1492 
1493  nal_size = gb->buffer_end - gb->buffer;
1494  if (nal_size > sizeof(pps->data)) {
1495  av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized PPS "
1496  "(%"PTRDIFF_SPECIFIER" > %"SIZE_SPECIFIER")\n",
1497  nal_size, sizeof(pps->data));
1498  pps->data_size = sizeof(pps->data);
1499  } else {
1500  pps->data_size = nal_size;
1501  }
1502  memcpy(pps->data, gb->buffer, pps->data_size);
1503 
1504  // Default values
1506  pps->num_tile_columns = 1;
1507  pps->num_tile_rows = 1;
1508  pps->uniform_spacing_flag = 1;
1509  pps->disable_dbf = 0;
1510  pps->beta_offset = 0;
1511  pps->tc_offset = 0;
1513 
1514  // Coded parameters
1515  pps_id = get_ue_golomb_long(gb);
1516  if (pps_id >= HEVC_MAX_PPS_COUNT) {
1517  av_log(avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1518  ret = AVERROR_INVALIDDATA;
1519  goto err;
1520  }
1521  pps->sps_id = get_ue_golomb_long(gb);
1522  if (pps->sps_id >= HEVC_MAX_SPS_COUNT) {
1523  av_log(avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1524  ret = AVERROR_INVALIDDATA;
1525  goto err;
1526  }
1527  if (!ps->sps_list[pps->sps_id]) {
1528  av_log(avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1529  ret = AVERROR_INVALIDDATA;
1530  goto err;
1531  }
1532  sps = (HEVCSPS *)ps->sps_list[pps->sps_id]->data;
1533 
1536  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1537 
1538  pps->sign_data_hiding_flag = get_bits1(gb);
1539 
1541 
1544 
1546 
1549 
1551  pps->diff_cu_qp_delta_depth = 0;
1552  if (pps->cu_qp_delta_enabled_flag)
1554 
1555  if (pps->diff_cu_qp_delta_depth < 0 ||
1557  av_log(avctx, AV_LOG_ERROR, "diff_cu_qp_delta_depth %d is invalid\n",
1558  pps->diff_cu_qp_delta_depth);
1559  ret = AVERROR_INVALIDDATA;
1560  goto err;
1561  }
1562 
1563  pps->cb_qp_offset = get_se_golomb(gb);
1564  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1565  av_log(avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1566  pps->cb_qp_offset);
1567  ret = AVERROR_INVALIDDATA;
1568  goto err;
1569  }
1570  pps->cr_qp_offset = get_se_golomb(gb);
1571  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1572  av_log(avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1573  pps->cr_qp_offset);
1574  ret = AVERROR_INVALIDDATA;
1575  goto err;
1576  }
1578 
1579  pps->weighted_pred_flag = get_bits1(gb);
1580  pps->weighted_bipred_flag = get_bits1(gb);
1581 
1583  pps->tiles_enabled_flag = get_bits1(gb);
1585 
1586  if (pps->tiles_enabled_flag) {
1587  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1588  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1589  if (pps->num_tile_columns <= 0 ||
1590  pps->num_tile_columns >= sps->width) {
1591  av_log(avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1592  pps->num_tile_columns - 1);
1593  ret = AVERROR_INVALIDDATA;
1594  goto err;
1595  }
1596  if (pps->num_tile_rows <= 0 ||
1597  pps->num_tile_rows >= sps->height) {
1598  av_log(avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1599  pps->num_tile_rows - 1);
1600  ret = AVERROR_INVALIDDATA;
1601  goto err;
1602  }
1603 
1604  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1605  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1606  if (!pps->column_width || !pps->row_height) {
1607  ret = AVERROR(ENOMEM);
1608  goto err;
1609  }
1610 
1611  pps->uniform_spacing_flag = get_bits1(gb);
1612  if (!pps->uniform_spacing_flag) {
1613  uint64_t sum = 0;
1614  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1615  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1616  sum += pps->column_width[i];
1617  }
1618  if (sum >= sps->ctb_width) {
1619  av_log(avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1620  ret = AVERROR_INVALIDDATA;
1621  goto err;
1622  }
1623  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1624 
1625  sum = 0;
1626  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1627  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1628  sum += pps->row_height[i];
1629  }
1630  if (sum >= sps->ctb_height) {
1631  av_log(avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1632  ret = AVERROR_INVALIDDATA;
1633  goto err;
1634  }
1635  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1636  }
1638  }
1639 
1641 
1645  pps->disable_dbf = get_bits1(gb);
1646  if (!pps->disable_dbf) {
1647  int beta_offset_div2 = get_se_golomb(gb);
1648  int tc_offset_div2 = get_se_golomb(gb) ;
1649  if (beta_offset_div2 < -6 || beta_offset_div2 > 6) {
1650  av_log(avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1651  beta_offset_div2);
1652  ret = AVERROR_INVALIDDATA;
1653  goto err;
1654  }
1655  if (tc_offset_div2 < -6 || tc_offset_div2 > 6) {
1656  av_log(avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1657  tc_offset_div2);
1658  ret = AVERROR_INVALIDDATA;
1659  goto err;
1660  }
1661  pps->beta_offset = 2 * beta_offset_div2;
1662  pps->tc_offset = 2 * tc_offset_div2;
1663  }
1664  }
1665 
1667  if (pps->scaling_list_data_present_flag) {
1669  ret = scaling_list_data(gb, avctx, &pps->scaling_list, sps);
1670  if (ret < 0)
1671  goto err;
1672  }
1674  log2_parallel_merge_level_minus2 = get_ue_golomb_long(gb);
1675  if (log2_parallel_merge_level_minus2 > sps->log2_ctb_size) {
1676  av_log(avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1677  log2_parallel_merge_level_minus2);
1678  ret = AVERROR_INVALIDDATA;
1679  goto err;
1680  }
1681  pps->log2_parallel_merge_level = log2_parallel_merge_level_minus2 + 2;
1682 
1684 
1685  if (get_bits1(gb)) { // pps_extension_present_flag
1687  skip_bits(gb, 7); // pps_extension_7bits
1689  if ((ret = pps_range_extensions(gb, avctx, pps, sps)) < 0)
1690  goto err;
1691  }
1692  }
1693 
1694  ret = setup_pps(avctx, gb, pps, sps);
1695  if (ret < 0)
1696  goto err;
1697 
1698  if (get_bits_left(gb) < 0) {
1699  av_log(avctx, AV_LOG_ERROR,
1700  "Overread PPS by %d bits\n", -get_bits_left(gb));
1701  goto err;
1702  }
1703 
1704  remove_pps(ps, pps_id);
1705  ps->pps_list[pps_id] = pps_buf;
1706 
1707  return 0;
1708 
1709 err:
1710  av_buffer_unref(&pps_buf);
1711  return ret;
1712 }
1713 
1715 {
1716  int i;
1717 
1718  for (i = 0; i < FF_ARRAY_ELEMS(ps->vps_list); i++)
1719  av_buffer_unref(&ps->vps_list[i]);
1720  for (i = 0; i < FF_ARRAY_ELEMS(ps->sps_list); i++)
1721  av_buffer_unref(&ps->sps_list[i]);
1722  for (i = 0; i < FF_ARRAY_ELEMS(ps->pps_list); i++)
1723  av_buffer_unref(&ps->pps_list[i]);
1724 
1725  ps->sps = NULL;
1726  ps->pps = NULL;
1727  ps->vps = NULL;
1728 }
1729 
1730 int ff_hevc_compute_poc(const HEVCSPS *sps, int pocTid0, int poc_lsb, int nal_unit_type)
1731 {
1732  int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
1733  int prev_poc_lsb = pocTid0 % max_poc_lsb;
1734  int prev_poc_msb = pocTid0 - prev_poc_lsb;
1735  int poc_msb;
1736 
1737  if (poc_lsb < prev_poc_lsb && prev_poc_lsb - poc_lsb >= max_poc_lsb / 2)
1738  poc_msb = prev_poc_msb + max_poc_lsb;
1739  else if (poc_lsb > prev_poc_lsb && poc_lsb - prev_poc_lsb > max_poc_lsb / 2)
1740  poc_msb = prev_poc_msb - max_poc_lsb;
1741  else
1742  poc_msb = prev_poc_msb;
1743 
1744  // For BLA picture types, POCmsb is set to 0.
1745  if (nal_unit_type == HEVC_NAL_BLA_W_LP ||
1746  nal_unit_type == HEVC_NAL_BLA_W_RADL ||
1747  nal_unit_type == HEVC_NAL_BLA_N_LP)
1748  poc_msb = 0;
1749 
1750  return poc_msb + poc_lsb;
1751 }
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:237
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
struct HEVCSPS::@94 pcm
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:2649
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:497
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:2982
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:874
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
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:825
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2983
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:260
#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:946
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:1730
#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
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:1296
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2690
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
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc_ps.h:350
unsigned int top_offset
Definition: hevc_ps.h:128
int hshift[3]
Definition: hevc_ps.h:312
struct HEVCSPS::@93 temporal_layer[HEVC_MAX_SUB_LAYERS]
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:2984
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:2701
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:723
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:103
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:1714
enum AVPixelFormat pix_fmt
Definition: hevc_ps.h:237
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:292
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
uint8_t transform_skip_enabled_flag
Definition: hevc_ps.h:333
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:558
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:2646
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:1565
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
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc_ps.h:351
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:1278
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:1469
#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:1220
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:753
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:1337
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
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:2985
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:1652
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
#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