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