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