Libav
hevc_ps.c
Go to the documentation of this file.
1 /*
2  * HEVC Parameter Set decoding
3  *
4  * Copyright (C) 2012 - 2103 Guillaume Martres
5  * Copyright (C) 2012 - 2103 Mickael Raulet
6  * Copyright (C) 2012 - 2013 Gildas Cocherel
7  * Copyright (C) 2013 Vittorio Giovara
8  *
9  * This file is part of Libav.
10  *
11  * Libav 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  * Libav 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 Libav; 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 
28 #include "golomb.h"
29 #include "hevc.h"
30 
32  16, 16, 16, 16, 17, 18, 21, 24,
33  16, 16, 16, 16, 17, 19, 22, 25,
34  16, 16, 17, 18, 20, 22, 25, 29,
35  16, 16, 18, 21, 24, 27, 31, 36,
36  17, 17, 20, 24, 30, 35, 41, 47,
37  18, 19, 22, 27, 35, 44, 54, 65,
38  21, 22, 25, 31, 41, 54, 70, 88,
39  24, 25, 29, 36, 47, 65, 88, 115
40 };
41 
43  16, 16, 16, 16, 17, 18, 20, 24,
44  16, 16, 16, 17, 18, 20, 24, 25,
45  16, 16, 17, 18, 20, 24, 25, 28,
46  16, 17, 18, 20, 24, 25, 28, 33,
47  17, 18, 20, 24, 25, 28, 33, 41,
48  18, 20, 24, 25, 28, 33, 41, 54,
49  20, 24, 25, 28, 33, 41, 54, 71,
50  24, 25, 28, 33, 41, 54, 71, 91
51 };
52 
53 static const AVRational vui_sar[] = {
54  { 0, 1 },
55  { 1, 1 },
56  { 12, 11 },
57  { 10, 11 },
58  { 16, 11 },
59  { 40, 33 },
60  { 24, 11 },
61  { 20, 11 },
62  { 32, 11 },
63  { 80, 33 },
64  { 18, 11 },
65  { 15, 11 },
66  { 64, 33 },
67  { 160, 99 },
68  { 4, 3 },
69  { 3, 2 },
70  { 2, 1 },
71 };
72 
74  const HEVCSPS *sps, int is_slice_header)
75 {
76  HEVCLocalContext *lc = &s->HEVClc;
77  uint8_t rps_predict = 0;
78  int delta_poc;
79  int k0 = 0;
80  int k1 = 0;
81  int k = 0;
82  int i;
83 
84  GetBitContext *gb = &lc->gb;
85 
86  if (rps != sps->st_rps && sps->nb_st_rps)
87  rps_predict = get_bits1(gb);
88 
89  if (rps_predict) {
90  const ShortTermRPS *rps_ridx;
91  int delta_rps, abs_delta_rps;
92  uint8_t use_delta_flag = 0;
93  uint8_t delta_rps_sign;
94 
95  if (is_slice_header) {
96  unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
97  if (delta_idx > sps->nb_st_rps) {
99  "Invalid value of delta_idx in slice header RPS: %d > %d.\n",
100  delta_idx, sps->nb_st_rps);
101  return AVERROR_INVALIDDATA;
102  }
103  rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
104  } else
105  rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
106 
107  delta_rps_sign = get_bits1(gb);
108  abs_delta_rps = get_ue_golomb_long(gb) + 1;
109  delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
110  for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
111  int used = rps->used[k] = get_bits1(gb);
112 
113  if (!used)
114  use_delta_flag = get_bits1(gb);
115 
116  if (used || use_delta_flag) {
117  if (i < rps_ridx->num_delta_pocs)
118  delta_poc = delta_rps + rps_ridx->delta_poc[i];
119  else
120  delta_poc = delta_rps;
121  rps->delta_poc[k] = delta_poc;
122  if (delta_poc < 0)
123  k0++;
124  else
125  k1++;
126  k++;
127  }
128  }
129 
130  rps->num_delta_pocs = k;
131  rps->num_negative_pics = k0;
132  // sort in increasing order (smallest first)
133  if (rps->num_delta_pocs != 0) {
134  int used, tmp;
135  for (i = 1; i < rps->num_delta_pocs; i++) {
136  delta_poc = rps->delta_poc[i];
137  used = rps->used[i];
138  for (k = i - 1; k >= 0; k--) {
139  tmp = rps->delta_poc[k];
140  if (delta_poc < tmp) {
141  rps->delta_poc[k + 1] = tmp;
142  rps->used[k + 1] = rps->used[k];
143  rps->delta_poc[k] = delta_poc;
144  rps->used[k] = used;
145  }
146  }
147  }
148  }
149  if ((rps->num_negative_pics >> 1) != 0) {
150  int used;
151  k = rps->num_negative_pics - 1;
152  // flip the negative values to largest first
153  for (i = 0; i < rps->num_negative_pics >> 1; i++) {
154  delta_poc = rps->delta_poc[i];
155  used = rps->used[i];
156  rps->delta_poc[i] = rps->delta_poc[k];
157  rps->used[i] = rps->used[k];
158  rps->delta_poc[k] = delta_poc;
159  rps->used[k] = used;
160  k--;
161  }
162  }
163  } else {
164  unsigned int prev, nb_positive_pics;
166  nb_positive_pics = get_ue_golomb_long(gb);
167 
168  if (rps->num_negative_pics >= MAX_REFS ||
169  nb_positive_pics >= MAX_REFS) {
170  av_log(s->avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
171  return AVERROR_INVALIDDATA;
172  }
173 
174  rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
175  if (rps->num_delta_pocs) {
176  prev = 0;
177  for (i = 0; i < rps->num_negative_pics; i++) {
178  delta_poc = get_ue_golomb_long(gb) + 1;
179  prev -= delta_poc;
180  rps->delta_poc[i] = prev;
181  rps->used[i] = get_bits1(gb);
182  }
183  prev = 0;
184  for (i = 0; i < nb_positive_pics; i++) {
185  delta_poc = get_ue_golomb_long(gb) + 1;
186  prev += delta_poc;
187  rps->delta_poc[rps->num_negative_pics + i] = prev;
188  rps->used[rps->num_negative_pics + i] = get_bits1(gb);
189  }
190  }
191  }
192  return 0;
193 }
194 
195 
197 {
198  int i;
199  GetBitContext *gb = &s->HEVClc.gb;
200 
201  ptl->profile_space = get_bits(gb, 2);
202  ptl->tier_flag = get_bits1(gb);
203  ptl->profile_idc = get_bits(gb, 5);
204  if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN)
205  av_log(s->avctx, AV_LOG_DEBUG, "Main profile bitstream\n");
206  else if (ptl->profile_idc == FF_PROFILE_HEVC_MAIN_10)
207  av_log(s->avctx, AV_LOG_DEBUG, "Main 10 profile bitstream\n");
209  av_log(s->avctx, AV_LOG_DEBUG, "Main Still Picture profile bitstream\n");
210  else
211  av_log(s->avctx, AV_LOG_WARNING, "Unknown HEVC profile: %d\n", ptl->profile_idc);
212 
213  for (i = 0; i < 32; i++)
219 
220  skip_bits(gb, 16); // XXX_reserved_zero_44bits[0..15]
221  skip_bits(gb, 16); // XXX_reserved_zero_44bits[16..31]
222  skip_bits(gb, 12); // XXX_reserved_zero_44bits[32..43]
223 }
224 
225 static void parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
226 {
227  int i;
228  GetBitContext *gb = &s->HEVClc.gb;
230  ptl->general_ptl.level_idc = get_bits(gb, 8);
231 
232  for (i = 0; i < max_num_sub_layers - 1; i++) {
235  }
236  if (max_num_sub_layers - 1 > 0)
237  for (i = max_num_sub_layers - 1; i < 8; i++)
238  skip_bits(gb, 2); // reserved_zero_2bits[i]
239  for (i = 0; i < max_num_sub_layers - 1; i++) {
240  if (ptl->sub_layer_profile_present_flag[i])
242  if (ptl->sub_layer_level_present_flag[i])
243  ptl->sub_layer_ptl[i].level_idc = get_bits(gb, 8);
244  }
245 }
246 
247 static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb,
248  int subpic_params_present)
249 {
250  GetBitContext *gb = &s->HEVClc.gb;
251  int i;
252 
253  for (i = 0; i < nb_cpb; i++) {
254  get_ue_golomb_long(gb); // bit_rate_value_minus1
255  get_ue_golomb_long(gb); // cpb_size_value_minus1
256 
257  if (subpic_params_present) {
258  get_ue_golomb_long(gb); // cpb_size_du_value_minus1
259  get_ue_golomb_long(gb); // bit_rate_du_value_minus1
260  }
261  skip_bits1(gb); // cbr_flag
262  }
263 }
264 
265 static void decode_hrd(HEVCContext *s, int common_inf_present,
266  int max_sublayers)
267 {
268  GetBitContext *gb = &s->HEVClc.gb;
269  int nal_params_present = 0, vcl_params_present = 0;
270  int subpic_params_present = 0;
271  int i;
272 
273  if (common_inf_present) {
274  nal_params_present = get_bits1(gb);
275  vcl_params_present = get_bits1(gb);
276 
277  if (nal_params_present || vcl_params_present) {
278  subpic_params_present = get_bits1(gb);
279 
280  if (subpic_params_present) {
281  skip_bits(gb, 8); // tick_divisor_minus2
282  skip_bits(gb, 5); // du_cpb_removal_delay_increment_length_minus1
283  skip_bits(gb, 1); // sub_pic_cpb_params_in_pic_timing_sei_flag
284  skip_bits(gb, 5); // dpb_output_delay_du_length_minus1
285  }
286 
287  skip_bits(gb, 4); // bit_rate_scale
288  skip_bits(gb, 4); // cpb_size_scale
289 
290  if (subpic_params_present)
291  skip_bits(gb, 4); // cpb_size_du_scale
292 
293  skip_bits(gb, 5); // initial_cpb_removal_delay_length_minus1
294  skip_bits(gb, 5); // au_cpb_removal_delay_length_minus1
295  skip_bits(gb, 5); // dpb_output_delay_length_minus1
296  }
297  }
298 
299  for (i = 0; i < max_sublayers; i++) {
300  int low_delay = 0;
301  unsigned int nb_cpb = 1;
302  int fixed_rate = get_bits1(gb);
303 
304  if (!fixed_rate)
305  fixed_rate = get_bits1(gb);
306 
307  if (fixed_rate)
308  get_ue_golomb_long(gb); // elemental_duration_in_tc_minus1
309  else
310  low_delay = get_bits1(gb);
311 
312  if (!low_delay)
313  nb_cpb = get_ue_golomb_long(gb) + 1;
314 
315  if (nal_params_present)
316  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
317  if (vcl_params_present)
318  decode_sublayer_hrd(s, nb_cpb, subpic_params_present);
319  }
320 }
321 
323 {
324  int i,j;
325  GetBitContext *gb = &s->HEVClc.gb;
326  int vps_id = 0;
327  HEVCVPS *vps;
328  AVBufferRef *vps_buf = av_buffer_allocz(sizeof(*vps));
329 
330  if (!vps_buf)
331  return AVERROR(ENOMEM);
332  vps = (HEVCVPS*)vps_buf->data;
333 
334  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VPS\n");
335 
336  vps_id = get_bits(gb, 4);
337  if (vps_id >= MAX_VPS_COUNT) {
338  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", vps_id);
339  goto err;
340  }
341 
342  if (get_bits(gb, 2) != 3) { // vps_reserved_three_2bits
343  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_three_2bits is not three\n");
344  goto err;
345  }
346 
347  vps->vps_max_layers = get_bits(gb, 6) + 1;
348  vps->vps_max_sub_layers = get_bits(gb, 3) + 1;
350 
351  if (get_bits(gb, 16) != 0xffff) { // vps_reserved_ffff_16bits
352  av_log(s->avctx, AV_LOG_ERROR, "vps_reserved_ffff_16bits is not 0xffff\n");
353  goto err;
354  }
355 
356  if (vps->vps_max_sub_layers > MAX_SUB_LAYERS) {
357  av_log(s->avctx, AV_LOG_ERROR, "vps_max_sub_layers out of range: %d\n",
358  vps->vps_max_sub_layers);
359  goto err;
360  }
361 
362  parse_ptl(s, &vps->ptl, vps->vps_max_sub_layers);
363 
365 
367  for (; i < vps->vps_max_sub_layers; i++) {
371 
372  if (vps->vps_max_dec_pic_buffering[i] > MAX_DPB_SIZE) {
373  av_log(s->avctx, AV_LOG_ERROR, "vps_max_dec_pic_buffering_minus1 out of range: %d\n",
374  vps->vps_max_dec_pic_buffering[i] - 1);
375  goto err;
376  }
377  if (vps->vps_num_reorder_pics[i] > vps->vps_max_dec_pic_buffering[i] - 1) {
378  av_log(s->avctx, AV_LOG_WARNING, "vps_max_num_reorder_pics out of range: %d\n",
379  vps->vps_num_reorder_pics[i]);
381  goto err;
382  }
383  }
384 
385  vps->vps_max_layer_id = get_bits(gb, 6);
386  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
387  for (i = 1; i < vps->vps_num_layer_sets; i++)
388  for (j = 0; j <= vps->vps_max_layer_id; j++)
389  skip_bits(gb, 1); // layer_id_included_flag[i][j]
390 
392  if (vps->vps_timing_info_present_flag) {
393  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
394  vps->vps_time_scale = get_bits_long(gb, 32);
399  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
400  int common_inf_present = 1;
401 
402  get_ue_golomb_long(gb); // hrd_layer_set_idx
403  if (i)
404  common_inf_present = get_bits1(gb);
405  decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
406  }
407  }
408  get_bits1(gb); /* vps_extension_flag */
409 
410  av_buffer_unref(&s->vps_list[vps_id]);
411  s->vps_list[vps_id] = vps_buf;
412  return 0;
413 
414 err:
415  av_buffer_unref(&vps_buf);
416  return AVERROR_INVALIDDATA;
417 }
418 
419 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
420 {
421  VUI *vui = &sps->vui;
422  GetBitContext *gb = &s->HEVClc.gb;
423  int sar_present;
424 
425  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
426 
427  sar_present = get_bits1(gb);
428  if (sar_present) {
429  uint8_t sar_idx = get_bits(gb, 8);
430  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
431  vui->sar = vui_sar[sar_idx];
432  else if (sar_idx == 255) {
433  vui->sar.num = get_bits(gb, 16);
434  vui->sar.den = get_bits(gb, 16);
435  } else
437  "Unknown SAR index: %u.\n", sar_idx);
438  }
439 
443 
446  vui->video_format = get_bits(gb, 3);
447  vui->video_full_range_flag = get_bits1(gb);
452  vui->colour_primaries = get_bits(gb, 8);
453  vui->transfer_characteristic = get_bits(gb, 8);
454  vui->matrix_coeffs = get_bits(gb, 8);
455 
456  // Set invalid values to "unspecified"
457  if (vui->colour_primaries >= AVCOL_PRI_NB)
461  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
463  }
464  }
465 
467  if (vui->chroma_loc_info_present_flag) {
470  }
471 
473  vui->field_seq_flag = get_bits1(gb);
475 
477  if (vui->default_display_window_flag) {
478  //TODO: * 2 is only valid for 420
483 
484  if (s->apply_defdispwin &&
487  "discarding vui default display window, "
488  "original values are l:%u r:%u t:%u b:%u\n",
493 
496  vui->def_disp_win.top_offset =
497  vui->def_disp_win.bottom_offset = 0;
498  }
499  }
500 
502  if (vui->vui_timing_info_present_flag) {
503  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
504  vui->vui_time_scale = get_bits_long(gb, 32);
510  decode_hrd(s, 1, sps->max_sub_layers);
511  }
512 
514  if (vui->bitstream_restriction_flag) {
523  }
524 }
525 
527 {
528  int matrixId;
529 
530  for (matrixId = 0; matrixId < 6; matrixId++) {
531  // 4x4 default is 16
532  memset(sl->sl[0][matrixId], 16, 16);
533  sl->sl_dc[0][matrixId] = 16; // default for 16x16
534  sl->sl_dc[1][matrixId] = 16; // default for 32x32
535  }
536  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
537  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
538  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
539  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
540  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
541  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
542  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
543  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
544  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
545  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
546  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
547  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
548  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
549  memcpy(sl->sl[3][1], default_scaling_list_inter, 64);
550 }
551 
553 {
554  GetBitContext *gb = &s->HEVClc.gb;
555  uint8_t scaling_list_pred_mode_flag[4][6];
556  int32_t scaling_list_dc_coef[2][6];
557  int size_id, matrix_id, i, pos;
558 
559  for (size_id = 0; size_id < 4; size_id++)
560  for (matrix_id = 0; matrix_id < (size_id == 3 ? 2 : 6); matrix_id++) {
561  scaling_list_pred_mode_flag[size_id][matrix_id] = get_bits1(gb);
562  if (!scaling_list_pred_mode_flag[size_id][matrix_id]) {
563  unsigned int delta = get_ue_golomb_long(gb);
564  /* Only need to handle non-zero delta. Zero means default,
565  * which should already be in the arrays. */
566  if (delta) {
567  // Copy from previous array.
568  if (matrix_id < delta) {
570  "Invalid delta in scaling list data: %d.\n", delta);
571  return AVERROR_INVALIDDATA;
572  }
573 
574  memcpy(sl->sl[size_id][matrix_id],
575  sl->sl[size_id][matrix_id - delta],
576  size_id > 0 ? 64 : 16);
577  if (size_id > 1)
578  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
579  }
580  } else {
581  int next_coef, coef_num;
582  int32_t scaling_list_delta_coef;
583 
584  next_coef = 8;
585  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
586  if (size_id > 1) {
587  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
588  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
589  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
590  }
591  for (i = 0; i < coef_num; i++) {
592  if (size_id == 0)
593  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
595  else
596  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
598 
599  scaling_list_delta_coef = get_se_golomb(gb);
600  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
601  sl->sl[size_id][matrix_id][pos] = next_coef;
602  }
603  }
604  }
605 
606  return 0;
607 }
608 
610 {
611  const AVPixFmtDescriptor *desc;
612  GetBitContext *gb = &s->HEVClc.gb;
613  int ret = 0;
614  unsigned int sps_id = 0;
615  int log2_diff_max_min_transform_block_size;
616  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
617  int i;
618 
619  HEVCSPS *sps;
620  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
621 
622  if (!sps_buf)
623  return AVERROR(ENOMEM);
624  sps = (HEVCSPS*)sps_buf->data;
625 
626  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
627 
628  // Coded parameters
629 
630  sps->vps_id = get_bits(gb, 4);
631  if (sps->vps_id >= MAX_VPS_COUNT) {
632  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
633  ret = AVERROR_INVALIDDATA;
634  goto err;
635  }
636 
637  if (!s->vps_list[sps->vps_id]) {
638  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
639  sps->vps_id);
640  ret = AVERROR_INVALIDDATA;
641  goto err;
642  }
643 
644  sps->max_sub_layers = get_bits(gb, 3) + 1;
645  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
646  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
647  sps->max_sub_layers);
648  ret = AVERROR_INVALIDDATA;
649  goto err;
650  }
651 
652  skip_bits1(gb); // temporal_id_nesting_flag
653 
654  parse_ptl(s, &sps->ptl, sps->max_sub_layers);
655 
656  sps_id = get_ue_golomb_long(gb);
657  if (sps_id >= MAX_SPS_COUNT) {
658  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
659  ret = AVERROR_INVALIDDATA;
660  goto err;
661  }
662 
664  if (sps->chroma_format_idc != 1) {
665  avpriv_report_missing_feature(s->avctx, "chroma_format_idc != 1\n");
666  ret = AVERROR_PATCHWELCOME;
667  goto err;
668  }
669 
670  if (sps->chroma_format_idc == 3)
672 
673  sps->width = get_ue_golomb_long(gb);
674  sps->height = get_ue_golomb_long(gb);
675  if ((ret = av_image_check_size(sps->width,
676  sps->height, 0, s->avctx)) < 0)
677  goto err;
678 
679  if (get_bits1(gb)) { // pic_conformance_flag
680  //TODO: * 2 is only valid for 420
685 
688  "discarding sps conformance window, "
689  "original values are l:%u r:%u t:%u b:%u\n",
694 
697  sps->pic_conf_win.top_offset =
698  sps->pic_conf_win.bottom_offset = 0;
699  }
700  sps->output_window = sps->pic_conf_win;
701  }
702 
703  sps->bit_depth = get_ue_golomb_long(gb) + 8;
704  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
705  if (bit_depth_chroma != sps->bit_depth) {
707  "Luma bit depth (%d) is different from chroma bit depth (%d), "
708  "this is unsupported.\n",
709  sps->bit_depth, bit_depth_chroma);
710  ret = AVERROR_INVALIDDATA;
711  goto err;
712  }
713 
714  if (sps->chroma_format_idc == 1) {
715  switch (sps->bit_depth) {
716  case 8: sps->pix_fmt = AV_PIX_FMT_YUV420P; break;
717  case 9: sps->pix_fmt = AV_PIX_FMT_YUV420P9; break;
718  case 10: sps->pix_fmt = AV_PIX_FMT_YUV420P10; break;
719  default:
720  av_log(s->avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n",
721  sps->bit_depth);
722  ret = AVERROR_PATCHWELCOME;
723  goto err;
724  }
725  } else {
727  "non-4:2:0 support is currently unspecified.\n");
728  return AVERROR_PATCHWELCOME;
729  }
730 
731  desc = av_pix_fmt_desc_get(sps->pix_fmt);
732  if (!desc) {
733  ret = AVERROR(EINVAL);
734  goto err;
735  }
736 
737  sps->hshift[0] = sps->vshift[0] = 0;
738  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
739  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
740 
741  sps->pixel_shift = sps->bit_depth > 8;
742 
743  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
744  if (sps->log2_max_poc_lsb > 16) {
745  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
746  sps->log2_max_poc_lsb - 4);
747  ret = AVERROR_INVALIDDATA;
748  goto err;
749  }
750 
751  sublayer_ordering_info = get_bits1(gb);
752  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
753  for (i = start; i < sps->max_sub_layers; i++) {
758  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
760  ret = AVERROR_INVALIDDATA;
761  goto err;
762  }
764  av_log(s->avctx, AV_LOG_WARNING, "sps_max_num_reorder_pics out of range: %d\n",
766  if (s->avctx->err_recognition & AV_EF_EXPLODE ||
768  ret = AVERROR_INVALIDDATA;
769  goto err;
770  }
772  }
773  }
774 
775  if (!sublayer_ordering_info) {
776  for (i = 0; i < start; i++) {
780  }
781  }
782 
783  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
785  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
786  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
787  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
788  sps->log2_min_tb_size;
789 
790  if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {
791  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
792  ret = AVERROR_INVALIDDATA;
793  goto err;
794  }
797 
799  if (sps->scaling_list_enable_flag) {
801 
802  if (get_bits1(gb)) {
803  ret = scaling_list_data(s, &sps->scaling_list);
804  if (ret < 0)
805  goto err;
806  }
807  }
808 
809  sps->amp_enabled_flag = get_bits1(gb);
810  sps->sao_enabled = get_bits1(gb);
811 
812  sps->pcm_enabled_flag = get_bits1(gb);
813  if (sps->pcm_enabled_flag) {
814  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
815  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
818  get_ue_golomb_long(gb);
819  if (sps->pcm.bit_depth > sps->bit_depth) {
821  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
822  sps->pcm.bit_depth, sps->bit_depth);
823  ret = AVERROR_INVALIDDATA;
824  goto err;
825  }
826 
828  }
829 
830  sps->nb_st_rps = get_ue_golomb_long(gb);
831  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
832  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
833  sps->nb_st_rps);
834  ret = AVERROR_INVALIDDATA;
835  goto err;
836  }
837  for (i = 0; i < sps->nb_st_rps; i++) {
838  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
839  sps, 0)) < 0)
840  goto err;
841  }
842 
846  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
849  }
850  }
851 
854  sps->vui.sar = (AVRational){0, 1};
855  vui_present = get_bits1(gb);
856  if (vui_present)
857  decode_vui(s, sps);
858  skip_bits1(gb); // sps_extension_flag
859 
860  if (s->apply_defdispwin) {
865  }
866  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
867  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
868  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
869  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
870  "chroma samples to preserve alignment.\n",
872  }
873  sps->output_width = sps->width -
875  sps->output_height = sps->height -
877  if (sps->output_width <= 0 || sps->output_height <= 0) {
878  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
879  sps->output_width, sps->output_height);
880  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
881  ret = AVERROR_INVALIDDATA;
882  goto err;
883  }
885  "Displaying the whole video surface.\n");
889  sps->output_window.bottom_offset = 0;
890  sps->output_width = sps->width;
891  sps->output_height = sps->height;
892  }
893 
894  // Inferred parameters
895  sps->log2_ctb_size = sps->log2_min_cb_size +
897  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
898 
899  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
900  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
901  sps->ctb_size = sps->ctb_width * sps->ctb_height;
902 
903  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
904  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
905  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
906  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
907  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
908  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
909 
910  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
911 
912  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
913  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
914  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
915  goto err;
916  }
917 
918  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
919  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
920  goto err;
921  }
923  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
925  goto err;
926  }
928  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
930  goto err;
931  }
932  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
934  "max transform block size out of range: %d\n",
935  sps->log2_max_trafo_size);
936  goto err;
937  }
938 
939  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
941  "Parsed SPS: id %d; coded wxh: %dx%d; "
942  "cropped wxh: %dx%d; pix_fmt: %s.\n",
943  sps_id, sps->width, sps->height,
944  sps->output_width, sps->output_height,
946  }
947 
948  /* check if this is a repeat of an already parsed SPS, then keep the
949  * original one.
950  * otherwise drop all PPSes that depend on it */
951  if (s->sps_list[sps_id] &&
952  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
953  av_buffer_unref(&sps_buf);
954  } else {
955  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
956  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
957  av_buffer_unref(&s->pps_list[i]);
958  }
959  av_buffer_unref(&s->sps_list[sps_id]);
960  s->sps_list[sps_id] = sps_buf;
961  }
962 
963  return 0;
964 
965 err:
966  av_buffer_unref(&sps_buf);
967  return ret;
968 }
969 
970 static void hevc_pps_free(void *opaque, uint8_t *data)
971 {
972  HEVCPPS *pps = (HEVCPPS*)data;
973 
974  av_freep(&pps->column_width);
975  av_freep(&pps->row_height);
976  av_freep(&pps->col_bd);
977  av_freep(&pps->row_bd);
978  av_freep(&pps->col_idxX);
981  av_freep(&pps->tile_pos_rs);
982  av_freep(&pps->tile_id);
983  av_freep(&pps->min_tb_addr_zs);
984 
985  av_freep(&pps);
986 }
987 
989 {
990  GetBitContext *gb = &s->HEVClc.gb;
991  HEVCSPS *sps = NULL;
992  int pic_area_in_ctbs, pic_area_in_min_tbs;
993  int log2_diff_ctb_min_tb_size;
994  int i, j, x, y, ctb_addr_rs, tile_id;
995  int ret = 0;
996  unsigned int pps_id = 0;
997 
998  AVBufferRef *pps_buf;
999  HEVCPPS *pps = av_mallocz(sizeof(*pps));
1000 
1001  if (!pps)
1002  return AVERROR(ENOMEM);
1003 
1004  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1005  hevc_pps_free, NULL, 0);
1006  if (!pps_buf) {
1007  av_freep(&pps);
1008  return AVERROR(ENOMEM);
1009  }
1010 
1011  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1012 
1013  // Default values
1015  pps->num_tile_columns = 1;
1016  pps->num_tile_rows = 1;
1017  pps->uniform_spacing_flag = 1;
1018  pps->disable_dbf = 0;
1019  pps->beta_offset = 0;
1020  pps->tc_offset = 0;
1021 
1022  // Coded parameters
1023  pps_id = get_ue_golomb_long(gb);
1024  if (pps_id >= MAX_PPS_COUNT) {
1025  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1026  ret = AVERROR_INVALIDDATA;
1027  goto err;
1028  }
1029  pps->sps_id = get_ue_golomb_long(gb);
1030  if (pps->sps_id >= MAX_SPS_COUNT) {
1031  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1032  ret = AVERROR_INVALIDDATA;
1033  goto err;
1034  }
1035  if (!s->sps_list[pps->sps_id]) {
1036  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1037  ret = AVERROR_INVALIDDATA;
1038  goto err;
1039  }
1040  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1041 
1044  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1045 
1046  pps->sign_data_hiding_flag = get_bits1(gb);
1047 
1049 
1052 
1054 
1057 
1059  pps->diff_cu_qp_delta_depth = 0;
1060  if (pps->cu_qp_delta_enabled_flag)
1062 
1063  pps->cb_qp_offset = get_se_golomb(gb);
1064  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1065  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1066  pps->cb_qp_offset);
1067  ret = AVERROR_INVALIDDATA;
1068  goto err;
1069  }
1070  pps->cr_qp_offset = get_se_golomb(gb);
1071  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1072  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1073  pps->cr_qp_offset);
1074  ret = AVERROR_INVALIDDATA;
1075  goto err;
1076  }
1078 
1079  pps->weighted_pred_flag = get_bits1(gb);
1080  pps->weighted_bipred_flag = get_bits1(gb);
1081 
1083  pps->tiles_enabled_flag = get_bits1(gb);
1085 
1086  if (pps->tiles_enabled_flag) {
1087  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1088  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1089  if (pps->num_tile_columns == 0 ||
1090  pps->num_tile_columns >= sps->width) {
1091  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1092  pps->num_tile_columns - 1);
1093  ret = AVERROR_INVALIDDATA;
1094  goto err;
1095  }
1096  if (pps->num_tile_rows == 0 ||
1097  pps->num_tile_rows >= sps->height) {
1098  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1099  pps->num_tile_rows - 1);
1100  ret = AVERROR_INVALIDDATA;
1101  goto err;
1102  }
1103 
1104  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1105  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1106  if (!pps->column_width || !pps->row_height) {
1107  ret = AVERROR(ENOMEM);
1108  goto err;
1109  }
1110 
1111  pps->uniform_spacing_flag = get_bits1(gb);
1112  if (!pps->uniform_spacing_flag) {
1113  uint64_t sum = 0;
1114  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1115  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1116  sum += pps->column_width[i];
1117  }
1118  if (sum >= sps->ctb_width) {
1119  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1120  ret = AVERROR_INVALIDDATA;
1121  goto err;
1122  }
1123  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1124 
1125  sum = 0;
1126  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1127  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1128  sum += pps->row_height[i];
1129  }
1130  if (sum >= sps->ctb_height) {
1131  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1132  ret = AVERROR_INVALIDDATA;
1133  goto err;
1134  }
1135  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1136  }
1138  }
1139 
1141 
1145  pps->disable_dbf = get_bits1(gb);
1146  if (!pps->disable_dbf) {
1147  pps->beta_offset = get_se_golomb(gb) * 2;
1148  pps->tc_offset = get_se_golomb(gb) * 2;
1149  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1150  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1151  pps->beta_offset/2);
1152  ret = AVERROR_INVALIDDATA;
1153  goto err;
1154  }
1155  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1156  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1157  pps->tc_offset/2);
1158  ret = AVERROR_INVALIDDATA;
1159  goto err;
1160  }
1161  }
1162  }
1163 
1165  if (pps->scaling_list_data_present_flag) {
1167  ret = scaling_list_data(s, &pps->scaling_list);
1168  if (ret < 0)
1169  goto err;
1170  }
1173  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1174  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1175  pps->log2_parallel_merge_level - 2);
1176  ret = AVERROR_INVALIDDATA;
1177  goto err;
1178  }
1179 
1181  skip_bits1(gb); // pps_extension_flag
1182 
1183  // Inferred parameters
1184  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1185  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1186  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1187  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1188  ret = AVERROR(ENOMEM);
1189  goto err;
1190  }
1191 
1192  if (pps->uniform_spacing_flag) {
1193  if (!pps->column_width) {
1194  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1195  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1196  }
1197  if (!pps->column_width || !pps->row_height) {
1198  ret = AVERROR(ENOMEM);
1199  goto err;
1200  }
1201 
1202  for (i = 0; i < pps->num_tile_columns; i++) {
1203  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1204  (i * sps->ctb_width) / pps->num_tile_columns;
1205  }
1206 
1207  for (i = 0; i < pps->num_tile_rows; i++) {
1208  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1209  (i * sps->ctb_height) / pps->num_tile_rows;
1210  }
1211  }
1212 
1213  pps->col_bd[0] = 0;
1214  for (i = 0; i < pps->num_tile_columns; i++)
1215  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1216 
1217  pps->row_bd[0] = 0;
1218  for (i = 0; i < pps->num_tile_rows; i++)
1219  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1220 
1221  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1222  if (i > pps->col_bd[j])
1223  j++;
1224  pps->col_idxX[i] = j;
1225  }
1226 
1230  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1231  pic_area_in_min_tbs = sps->min_tb_width * sps->min_tb_height;
1232 
1233  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1234  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1235  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1236  pps->min_tb_addr_zs = av_malloc_array(pic_area_in_min_tbs, sizeof(*pps->min_tb_addr_zs));
1237  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1238  !pps->tile_id || !pps->min_tb_addr_zs) {
1239  ret = AVERROR(ENOMEM);
1240  goto err;
1241  }
1242 
1243  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1244  int tb_x = ctb_addr_rs % sps->ctb_width;
1245  int tb_y = ctb_addr_rs / sps->ctb_width;
1246  int tile_x = 0;
1247  int tile_y = 0;
1248  int val = 0;
1249 
1250  for (i = 0; i < pps->num_tile_columns; i++) {
1251  if (tb_x < pps->col_bd[i + 1]) {
1252  tile_x = i;
1253  break;
1254  }
1255  }
1256 
1257  for (i = 0; i < pps->num_tile_rows; i++) {
1258  if (tb_y < pps->row_bd[i + 1]) {
1259  tile_y = i;
1260  break;
1261  }
1262  }
1263 
1264  for (i = 0; i < tile_x; i++)
1265  val += pps->row_height[tile_y] * pps->column_width[i];
1266  for (i = 0; i < tile_y; i++)
1267  val += sps->ctb_width * pps->row_height[i];
1268 
1269  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1270  tb_x - pps->col_bd[tile_x];
1271 
1272  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1273  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1274  }
1275 
1276  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1277  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1278  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1279  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1280  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1281 
1282  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1283  if (!pps->tile_pos_rs) {
1284  ret = AVERROR(ENOMEM);
1285  goto err;
1286  }
1287 
1288  for (j = 0; j < pps->num_tile_rows; j++)
1289  for (i = 0; i < pps->num_tile_columns; i++)
1290  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1291 
1292  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1293  for (y = 0; y < sps->min_tb_height; y++) {
1294  for (x = 0; x < sps->min_tb_width; x++) {
1295  int tb_x = x >> log2_diff_ctb_min_tb_size;
1296  int tb_y = y >> log2_diff_ctb_min_tb_size;
1297  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1298  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1299  (log2_diff_ctb_min_tb_size * 2);
1300  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1301  int m = 1 << i;
1302  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1303  }
1304  pps->min_tb_addr_zs[y * sps->min_tb_width + x] = val;
1305  }
1306  }
1307 
1308  av_buffer_unref(&s->pps_list[pps_id]);
1309  s->pps_list[pps_id] = pps_buf;
1310 
1311  return 0;
1312 
1313 err:
1314  av_buffer_unref(&pps_buf);
1315  return ret;
1316 }
unsigned int log2_min_cb_size
Definition: hevc.h:435
int min_spatial_segmentation_idc
Definition: hevc.h:329
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
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:106
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1599
int ctb_height
Definition: hevc.h:449
#define CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:610
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:179
int vui_num_ticks_poc_diff_one_minus1
Definition: hevc.h:322
int max_dec_pic_buffering
Definition: hevc.h:403
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
#define CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:667
int ff_hevc_decode_nal_sps(HEVCContext *s)
Definition: hevc_ps.c:609
int vps_id
Definition: hevc.h:384
unsigned int * row_height
RowHeight.
Definition: hevc.h:516
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc.h:372
#define MAX_REFS
Definition: hevc.h:42
int pic_init_qp_minus26
Definition: hevc.h:473
#define MAX_PPS_COUNT
Definition: h264.h:50
VUI vui
Definition: hevc.h:408
#define MAX_DPB_SIZE
Definition: hevc.h:41
int vshift[3]
Definition: hevc.h:459
int num
numerator
Definition: rational.h:44
#define MAX_LOG2_CTB_SIZE
Definition: hevc.h:59
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2365
uint32_t vui_time_scale
Definition: hevc.h:320
uint8_t weighted_bipred_flag
Definition: hevc.h:485
unsigned int left_offset
Definition: hevc.h:287
Definition: hevc.h:348
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:498
uint8_t cabac_init_present_flag
Definition: hevc.h:469
int chroma_loc_info_present_flag
Definition: hevc.h:307
int max_latency_increase
Definition: hevc.h:405
#define FF_ARRAY_ELEMS(a)
int min_cb_height
Definition: hevc.h:452
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:522
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:471
static const AVRational vui_sar[]
Definition: hevc_ps.c:53
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:415
int chroma_sample_loc_type_top_field
Definition: hevc.h:308
int width
Definition: hevc.h:446
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
int qp_bd_offset
Definition: hevc.h:461
int pixel_shift
Definition: hevc.h:395
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:491
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
HEVCWindow output_window
Definition: hevc.h:390
int output_width
Definition: hevc.h:389
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc.h:510
int restricted_ref_pic_lists_flag
Definition: hevc.h:328
int chroma_format_idc
Definition: hevc.h:385
uint8_t disable_dbf
Definition: hevc.h:502
unsigned int log2_max_trafo_size
Definition: hevc.h:438
uint8_t profile_compatibility_flag[32]
Definition: hevc.h:340
Definition: hevc.h:293
unsigned int num_negative_pics
Definition: hevc.h:263
uint8_t
uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:352
struct HEVCSPS::@23 pcm
static const uint8_t default_scaling_list_inter[]
Definition: hevc_ps.c:42
unsigned int vps_num_reorder_pics[MAX_SUB_LAYERS]
Definition: hevc.h:364
float delta
HEVCWindow pic_conf_win
Definition: hevc.h:392
int overscan_info_present_flag
Definition: hevc.h:296
uint8_t vps_timing_info_present_flag
Definition: hevc.h:368
uint8_t matrix_coeffs
Definition: hevc.h:305
int min_tb_width
Definition: hevc.h:453
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2696
int apply_defdispwin
Definition: hevc.h:845
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:472
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:428
AVCodecContext * avctx
Definition: hevc.h:754
int min_cb_width
Definition: hevc.h:451
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc.h:359
int frame_field_info_present_flag
Definition: hevc.h:313
uint8_t tier_flag
Definition: hevc.h:338
const char data[16]
Definition: mxf.c:70
uint8_t scaling_list_data_present_flag
Definition: hevc.h:506
uint8_t bit_depth_chroma
Definition: hevc.h:427
static void decode_hrd(HEVCContext *s, int common_inf_present, int max_sublayers)
Definition: hevc_ps.c:265
int ff_hevc_decode_nal_vps(HEVCContext *s)
Definition: hevc_ps.c:322
uint8_t loop_filter_disable_flag
Definition: hevc.h:430
int ff_hevc_decode_nal_pps(HEVCContext *s)
Definition: hevc_ps.c:988
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2697
int bitstream_restriction_flag
Definition: hevc.h:325
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:487
struct HEVCSPS::@22 temporal_layer[MAX_SUB_LAYERS]
int vps_max_layer_id
Definition: hevc.h:366
static void parse_ptl(HEVCContext *s, PTL *ptl, int max_num_sub_layers)
Definition: hevc_ps.c:225
static void decode_profile_tier_level(HEVCContext *s, PTLCommon *ptl)
Definition: hevc_ps.c:196
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
uint8_t frame_only_constraint_flag
Definition: hevc.h:345
unsigned int log2_max_poc_lsb
Definition: hevc.h:398
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
int vps_max_layers
Definition: hevc.h:358
int min_pu_height
Definition: hevc.h:456
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:771
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:318
uint8_t amp_enabled_flag
Definition: hevc.h:417
HEVCLocalContext HEVClc
Definition: hevc.h:756
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
#define MAX_SHORT_TERM_RPS_COUNT
Definition: hevc.h:51
Not part of ABI.
Definition: pixfmt.h:316
unsigned int log2_ctb_size
Definition: hevc.h:439
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1144
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:321
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:28
uint8_t vps_temporal_id_nesting_flag
Definition: hevc.h:357
uint8_t colour_primaries
Definition: hevc.h:303
uint8_t used[32]
Definition: hevc.h:266
int motion_vectors_over_pic_boundaries_flag
Definition: hevc.h:327
uint8_t tiles_enabled_flag
Definition: hevc.h:490
uint32_t vps_num_units_in_tick
Definition: hevc.h:369
int * col_idxX
Definition: hevc.h:519
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc.h:367
uint8_t lists_modification_present_flag
Definition: hevc.h:509
uint8_t profile_idc
Definition: hevc.h:339
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:222
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2406
int max_transform_hierarchy_depth_inter
Definition: hevc.h:442
#define FFMIN(a, b)
Definition: common.h:57
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
Definition: pixfmt.h:77
uint8_t vps_poc_proportional_to_timing_flag
Definition: hevc.h:371
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:493
int output_height
Definition: hevc.h:389
unsigned int top_offset
Definition: hevc.h:289
int hshift[3]
Definition: hevc.h:458
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2698
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:772
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:331
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:478
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:422
#define MAX_SPS_COUNT
Definition: h264.h:49
int ctb_width
Definition: hevc.h:448
uint8_t sl_dc[2][6]
Definition: hevc.h:380
int32_t delta_poc[32]
Definition: hevc.h:265
uint8_t sign_data_hiding_flag
Definition: hevc.h:467
int height
Definition: hevc.h:447
#define AV_EF_EXPLODE
Definition: avcodec.h:2417
uint8_t output_flag_present_flag
Definition: hevc.h:486
int log2_max_mv_length_vertical
Definition: hevc.h:333
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc.c:92
PTLCommon general_ptl
Definition: hevc.h:349
int max_bytes_per_pic_denom
Definition: hevc.h:330
static int scaling_list_data(HEVCContext *s, ScalingList *sl)
Definition: hevc_ps.c:552
int overscan_appropriate_flag
Definition: hevc.h:297
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:526
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:773
uint8_t constrained_intra_pred_flag
Definition: hevc.h:475
uint8_t sl[4][6][64]
Definition: hevc.h:379
PTL ptl
Definition: hevc.h:361
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:483
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:81
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
uint32_t vps_time_scale
Definition: hevc.h:370
int colour_description_present_flag
Definition: hevc.h:302
uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:353
Definition: hevc.h:383
enum AVPixelFormat pix_fmt
Definition: hevc.h:396
Definition: hevc.h:356
NULL
Definition: eval.c:55
Definition: hevc.h:464
uint8_t transform_skip_enabled_flag
Definition: hevc.h:476
uint8_t uniform_spacing_flag
Definition: hevc.h:495
int ctb_size
Definition: hevc.h:450
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:521
PTL ptl
Definition: hevc.h:409
int max_sub_layers
Definition: hevc.h:401
unsigned int log2_min_pu_size
Definition: hevc.h:440
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:465
int debug
debug
Definition: avcodec.h:2362
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
#define MAX_VPS_COUNT
Definition: hevc.h:48
ScalingList scaling_list
Definition: hevc.h:507
int log2_max_mv_length_horizontal
Definition: hevc.h:332
uint8_t sao_enabled
Definition: hevc.h:418
int num_extra_slice_header_bits
Definition: hevc.h:511
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc.h:496
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:423
uint32_t vui_num_units_in_tick
Definition: hevc.h:319
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:82
uint8_t deblocking_filter_control_present_flag
Definition: hevc.h:500
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:296
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:243
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:432
unsigned int nb_st_rps
Definition: hevc.h:414
int chroma_sample_loc_type_bottom_field
Definition: hevc.h:309
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc.h:494
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
rational number numerator/denominator
Definition: rational.h:43
int vps_num_hrd_parameters
Definition: hevc.h:373
#define MAX_SUB_LAYERS
7.4.2.1
Definition: hevc.h:47
Not part of ABI.
Definition: pixfmt.h:338
GetBitContext gb
Definition: hevc.h:721
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:970
unsigned int log2_min_tb_size
Definition: hevc.h:437
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:421
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:240
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:304
uint8_t scaling_list_enable_flag
Definition: hevc.h:411
int * tile_id
TileId.
Definition: hevc.h:523
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:31
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:504
uint8_t transfer_characteristic
Definition: hevc.h:304
int default_display_window_flag
Definition: hevc.h:315
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc.h:316
int cr_qp_offset
Definition: hevc.h:482
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ScalingList scaling_list
Definition: hevc.h:412
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:436
static void * av_malloc_array(size_t nmemb, size_t size)
Definition: mem.h:92
unsigned int log2_max_pcm_cb_size
Definition: hevc.h:429
uint8_t level_idc
Definition: hevc.h:341
int neutra_chroma_indication_flag
Definition: hevc.h:310
int * tile_pos_rs
TilePosRS.
Definition: hevc.h:524
static void decode_vui(HEVCContext *s, HEVCSPS *sps)
Definition: hevc_ps.c:419
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc.c:106
A reference to a data buffer.
Definition: buffer.h:81
int max_transform_hierarchy_depth_intra
coded frame dimension in various units
Definition: hevc.h:443
uint8_t profile_space
Definition: hevc.h:337
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
unsigned int * row_bd
RowBd.
Definition: hevc.h:518
int video_format
Definition: hevc.h:300
uint8_t weighted_pred_flag
Definition: hevc.h:484
unsigned int * col_bd
ColBd.
Definition: hevc.h:517
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:515
uint8_t slice_header_extension_present_flag
Definition: hevc.h:512
int den
denominator
Definition: rational.h:45
int video_full_range_flag
Definition: hevc.h:301
PTLCommon sub_layer_ptl[MAX_SUB_LAYERS]
Definition: hevc.h:350
AVRational sar
Definition: hevc.h:294
int num_delta_pocs
Definition: hevc.h:264
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:433
int min_pu_width
Definition: hevc.h:455
int ff_hevc_decode_short_term_rps(HEVCContext *s, ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
Definition: hevc_ps.c:73
const uint8_t ff_hevc_diag_scan4x4_x[16]
Definition: hevc.c:85
unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS]
Definition: hevc.h:363
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:420
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:365
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1151
static void decode_sublayer_hrd(HEVCContext *s, unsigned int nb_cpb, int subpic_params_present)
Definition: hevc_ps.c:247
int vui_hrd_parameters_present_flag
Definition: hevc.h:323
unsigned int right_offset
Definition: hevc.h:288
int diff_cu_qp_delta_depth
Definition: hevc.h:479
int num_reorder_pics
Definition: hevc.h:404
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc.c:125
uint8_t progressive_source_flag
Definition: hevc.h:342
int cb_qp_offset
Definition: hevc.h:481
int video_signal_type_present_flag
Definition: hevc.h:299
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:501
int bit_depth
Definition: hevc.h:394
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:503
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:1540
int min_tb_height
Definition: hevc.h:454
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc.h:525
uint8_t non_packed_constraint_flag
Definition: hevc.h:344
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:399
int tiles_fixed_structure_flag
Definition: hevc.h:326
uint8_t interlaced_source_flag
Definition: hevc.h:343
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
int field_seq_flag
Definition: hevc.h:312
Not part of ABI.
Definition: pixfmt.h:356
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:386
unsigned int bottom_offset
Definition: hevc.h:290
int vps_sub_layer_ordering_info_present_flag
Definition: hevc.h:362
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:489