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_ERROR, "vps_max_num_reorder_pics out of range: %d\n",
379  vps->vps_num_reorder_pics[i]);
380  goto err;
381  }
382  }
383 
384  vps->vps_max_layer_id = get_bits(gb, 6);
385  vps->vps_num_layer_sets = get_ue_golomb_long(gb) + 1;
386  for (i = 1; i < vps->vps_num_layer_sets; i++)
387  for (j = 0; j <= vps->vps_max_layer_id; j++)
388  skip_bits(gb, 1); // layer_id_included_flag[i][j]
389 
391  if (vps->vps_timing_info_present_flag) {
392  vps->vps_num_units_in_tick = get_bits_long(gb, 32);
393  vps->vps_time_scale = get_bits_long(gb, 32);
398  for (i = 0; i < vps->vps_num_hrd_parameters; i++) {
399  int common_inf_present = 1;
400 
401  get_ue_golomb_long(gb); // hrd_layer_set_idx
402  if (i)
403  common_inf_present = get_bits1(gb);
404  decode_hrd(s, common_inf_present, vps->vps_max_sub_layers);
405  }
406  }
407  get_bits1(gb); /* vps_extension_flag */
408 
409  av_buffer_unref(&s->vps_list[vps_id]);
410  s->vps_list[vps_id] = vps_buf;
411  return 0;
412 
413 err:
414  av_buffer_unref(&vps_buf);
415  return AVERROR_INVALIDDATA;
416 }
417 
418 static void decode_vui(HEVCContext *s, HEVCSPS *sps)
419 {
420  VUI *vui = &sps->vui;
421  GetBitContext *gb = &s->HEVClc.gb;
422  int sar_present;
423 
424  av_log(s->avctx, AV_LOG_DEBUG, "Decoding VUI\n");
425 
426  sar_present = get_bits1(gb);
427  if (sar_present) {
428  uint8_t sar_idx = get_bits(gb, 8);
429  if (sar_idx < FF_ARRAY_ELEMS(vui_sar))
430  vui->sar = vui_sar[sar_idx];
431  else if (sar_idx == 255) {
432  vui->sar.num = get_bits(gb, 16);
433  vui->sar.den = get_bits(gb, 16);
434  } else
436  "Unknown SAR index: %u.\n", sar_idx);
437  }
438 
442 
445  vui->video_format = get_bits(gb, 3);
446  vui->video_full_range_flag = get_bits1(gb);
451  vui->colour_primaries = get_bits(gb, 8);
452  vui->transfer_characteristic = get_bits(gb, 8);
453  vui->matrix_coeffs = get_bits(gb, 8);
454 
455  // Set invalid values to "unspecified"
456  if (vui->colour_primaries >= AVCOL_PRI_NB)
460  if (vui->matrix_coeffs >= AVCOL_SPC_NB)
462  }
463  }
464 
466  if (vui->chroma_loc_info_present_flag) {
469  }
470 
472  vui->field_seq_flag = get_bits1(gb);
474 
476  if (vui->default_display_window_flag) {
477  //TODO: * 2 is only valid for 420
482 
483  if (s->apply_defdispwin &&
486  "discarding vui default display window, "
487  "original values are l:%u r:%u t:%u b:%u\n",
492 
495  vui->def_disp_win.top_offset =
496  vui->def_disp_win.bottom_offset = 0;
497  }
498  }
499 
501  if (vui->vui_timing_info_present_flag) {
502  vui->vui_num_units_in_tick = get_bits_long(gb, 32);
503  vui->vui_time_scale = get_bits_long(gb, 32);
509  decode_hrd(s, 1, sps->max_sub_layers);
510  }
511 
513  if (vui->bitstream_restriction_flag) {
522  }
523 }
524 
526 {
527  int matrixId;
528 
529  for (matrixId = 0; matrixId < 6; matrixId++) {
530  // 4x4 default is 16
531  memset(sl->sl[0][matrixId], 16, 16);
532  sl->sl_dc[0][matrixId] = 16; // default for 16x16
533  sl->sl_dc[1][matrixId] = 16; // default for 32x32
534  }
535  memcpy(sl->sl[1][0], default_scaling_list_intra, 64);
536  memcpy(sl->sl[1][1], default_scaling_list_intra, 64);
537  memcpy(sl->sl[1][2], default_scaling_list_intra, 64);
538  memcpy(sl->sl[1][3], default_scaling_list_inter, 64);
539  memcpy(sl->sl[1][4], default_scaling_list_inter, 64);
540  memcpy(sl->sl[1][5], default_scaling_list_inter, 64);
541  memcpy(sl->sl[2][0], default_scaling_list_intra, 64);
542  memcpy(sl->sl[2][1], default_scaling_list_intra, 64);
543  memcpy(sl->sl[2][2], default_scaling_list_intra, 64);
544  memcpy(sl->sl[2][3], default_scaling_list_inter, 64);
545  memcpy(sl->sl[2][4], default_scaling_list_inter, 64);
546  memcpy(sl->sl[2][5], default_scaling_list_inter, 64);
547  memcpy(sl->sl[3][0], default_scaling_list_intra, 64);
548  memcpy(sl->sl[3][1], default_scaling_list_inter, 64);
549 }
550 
552 {
553  GetBitContext *gb = &s->HEVClc.gb;
554  uint8_t scaling_list_pred_mode_flag[4][6];
555  int32_t scaling_list_dc_coef[2][6];
556  int size_id, matrix_id, i, pos;
557 
558  for (size_id = 0; size_id < 4; size_id++)
559  for (matrix_id = 0; matrix_id < (size_id == 3 ? 2 : 6); matrix_id++) {
560  scaling_list_pred_mode_flag[size_id][matrix_id] = get_bits1(gb);
561  if (!scaling_list_pred_mode_flag[size_id][matrix_id]) {
562  unsigned int delta = get_ue_golomb_long(gb);
563  /* Only need to handle non-zero delta. Zero means default,
564  * which should already be in the arrays. */
565  if (delta) {
566  // Copy from previous array.
567  if (matrix_id < delta) {
569  "Invalid delta in scaling list data: %d.\n", delta);
570  return AVERROR_INVALIDDATA;
571  }
572 
573  memcpy(sl->sl[size_id][matrix_id],
574  sl->sl[size_id][matrix_id - delta],
575  size_id > 0 ? 64 : 16);
576  if (size_id > 1)
577  sl->sl_dc[size_id - 2][matrix_id] = sl->sl_dc[size_id - 2][matrix_id - delta];
578  }
579  } else {
580  int next_coef, coef_num;
581  int32_t scaling_list_delta_coef;
582 
583  next_coef = 8;
584  coef_num = FFMIN(64, 1 << (4 + (size_id << 1)));
585  if (size_id > 1) {
586  scaling_list_dc_coef[size_id - 2][matrix_id] = get_se_golomb(gb) + 8;
587  next_coef = scaling_list_dc_coef[size_id - 2][matrix_id];
588  sl->sl_dc[size_id - 2][matrix_id] = next_coef;
589  }
590  for (i = 0; i < coef_num; i++) {
591  if (size_id == 0)
592  pos = 4 * ff_hevc_diag_scan4x4_y[i] +
594  else
595  pos = 8 * ff_hevc_diag_scan8x8_y[i] +
597 
598  scaling_list_delta_coef = get_se_golomb(gb);
599  next_coef = (next_coef + scaling_list_delta_coef + 256) % 256;
600  sl->sl[size_id][matrix_id][pos] = next_coef;
601  }
602  }
603  }
604 
605  return 0;
606 }
607 
609 {
610  const AVPixFmtDescriptor *desc;
611  GetBitContext *gb = &s->HEVClc.gb;
612  int ret = 0;
613  unsigned int sps_id = 0;
614  int log2_diff_max_min_transform_block_size;
615  int bit_depth_chroma, start, vui_present, sublayer_ordering_info;
616  int i;
617 
618  HEVCSPS *sps;
619  AVBufferRef *sps_buf = av_buffer_allocz(sizeof(*sps));
620 
621  if (!sps_buf)
622  return AVERROR(ENOMEM);
623  sps = (HEVCSPS*)sps_buf->data;
624 
625  av_log(s->avctx, AV_LOG_DEBUG, "Decoding SPS\n");
626 
627  // Coded parameters
628 
629  sps->vps_id = get_bits(gb, 4);
630  if (sps->vps_id >= MAX_VPS_COUNT) {
631  av_log(s->avctx, AV_LOG_ERROR, "VPS id out of range: %d\n", sps->vps_id);
632  ret = AVERROR_INVALIDDATA;
633  goto err;
634  }
635 
636  if (!s->vps_list[sps->vps_id]) {
637  av_log(s->avctx, AV_LOG_ERROR, "VPS %d does not exist\n",
638  sps->vps_id);
639  ret = AVERROR_INVALIDDATA;
640  goto err;
641  }
642 
643  sps->max_sub_layers = get_bits(gb, 3) + 1;
644  if (sps->max_sub_layers > MAX_SUB_LAYERS) {
645  av_log(s->avctx, AV_LOG_ERROR, "sps_max_sub_layers out of range: %d\n",
646  sps->max_sub_layers);
647  ret = AVERROR_INVALIDDATA;
648  goto err;
649  }
650 
651  skip_bits1(gb); // temporal_id_nesting_flag
652 
653  parse_ptl(s, &sps->ptl, sps->max_sub_layers);
654 
655  sps_id = get_ue_golomb_long(gb);
656  if (sps_id >= MAX_SPS_COUNT) {
657  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", sps_id);
658  ret = AVERROR_INVALIDDATA;
659  goto err;
660  }
661 
663  if (sps->chroma_format_idc != 1) {
664  avpriv_report_missing_feature(s->avctx, "chroma_format_idc != 1\n");
665  ret = AVERROR_PATCHWELCOME;
666  goto err;
667  }
668 
669  if (sps->chroma_format_idc == 3)
671 
672  sps->width = get_ue_golomb_long(gb);
673  sps->height = get_ue_golomb_long(gb);
674  if ((ret = av_image_check_size(sps->width,
675  sps->height, 0, s->avctx)) < 0)
676  goto err;
677 
678  if (get_bits1(gb)) { // pic_conformance_flag
679  //TODO: * 2 is only valid for 420
684 
687  "discarding sps conformance window, "
688  "original values are l:%u r:%u t:%u b:%u\n",
693 
696  sps->pic_conf_win.top_offset =
697  sps->pic_conf_win.bottom_offset = 0;
698  }
699  sps->output_window = sps->pic_conf_win;
700  }
701 
702  sps->bit_depth = get_ue_golomb_long(gb) + 8;
703  bit_depth_chroma = get_ue_golomb_long(gb) + 8;
704  if (bit_depth_chroma != sps->bit_depth) {
706  "Luma bit depth (%d) is different from chroma bit depth (%d), "
707  "this is unsupported.\n",
708  sps->bit_depth, bit_depth_chroma);
709  ret = AVERROR_INVALIDDATA;
710  goto err;
711  }
712 
713  if (sps->chroma_format_idc == 1) {
714  switch (sps->bit_depth) {
715  case 8: sps->pix_fmt = AV_PIX_FMT_YUV420P; break;
716  case 9: sps->pix_fmt = AV_PIX_FMT_YUV420P9; break;
717  case 10: sps->pix_fmt = AV_PIX_FMT_YUV420P10; break;
718  default:
719  av_log(s->avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n",
720  sps->bit_depth);
721  ret = AVERROR_PATCHWELCOME;
722  goto err;
723  }
724  } else {
726  "non-4:2:0 support is currently unspecified.\n");
727  return AVERROR_PATCHWELCOME;
728  }
729 
730  desc = av_pix_fmt_desc_get(sps->pix_fmt);
731  if (!desc) {
732  ret = AVERROR(EINVAL);
733  goto err;
734  }
735 
736  sps->hshift[0] = sps->vshift[0] = 0;
737  sps->hshift[2] = sps->hshift[1] = desc->log2_chroma_w;
738  sps->vshift[2] = sps->vshift[1] = desc->log2_chroma_h;
739 
740  sps->pixel_shift = sps->bit_depth > 8;
741 
742  sps->log2_max_poc_lsb = get_ue_golomb_long(gb) + 4;
743  if (sps->log2_max_poc_lsb > 16) {
744  av_log(s->avctx, AV_LOG_ERROR, "log2_max_pic_order_cnt_lsb_minus4 out range: %d\n",
745  sps->log2_max_poc_lsb - 4);
746  ret = AVERROR_INVALIDDATA;
747  goto err;
748  }
749 
750  sublayer_ordering_info = get_bits1(gb);
751  start = sublayer_ordering_info ? 0 : sps->max_sub_layers - 1;
752  for (i = start; i < sps->max_sub_layers; i++) {
757  av_log(s->avctx, AV_LOG_ERROR, "sps_max_dec_pic_buffering_minus1 out of range: %d\n",
759  ret = AVERROR_INVALIDDATA;
760  goto err;
761  }
763  av_log(s->avctx, AV_LOG_ERROR, "sps_max_num_reorder_pics out of range: %d\n",
765  ret = AVERROR_INVALIDDATA;
766  goto err;
767  }
768  }
769 
770  if (!sublayer_ordering_info) {
771  for (i = 0; i < start; i++) {
775  }
776  }
777 
778  sps->log2_min_cb_size = get_ue_golomb_long(gb) + 3;
780  sps->log2_min_tb_size = get_ue_golomb_long(gb) + 2;
781  log2_diff_max_min_transform_block_size = get_ue_golomb_long(gb);
782  sps->log2_max_trafo_size = log2_diff_max_min_transform_block_size +
783  sps->log2_min_tb_size;
784 
785  if (sps->log2_min_tb_size >= sps->log2_min_cb_size) {
786  av_log(s->avctx, AV_LOG_ERROR, "Invalid value for log2_min_tb_size");
787  ret = AVERROR_INVALIDDATA;
788  goto err;
789  }
792 
794  if (sps->scaling_list_enable_flag) {
796 
797  if (get_bits1(gb)) {
798  ret = scaling_list_data(s, &sps->scaling_list);
799  if (ret < 0)
800  goto err;
801  }
802  }
803 
804  sps->amp_enabled_flag = get_bits1(gb);
805  sps->sao_enabled = get_bits1(gb);
806 
807  sps->pcm_enabled_flag = get_bits1(gb);
808  if (sps->pcm_enabled_flag) {
809  sps->pcm.bit_depth = get_bits(gb, 4) + 1;
810  sps->pcm.bit_depth_chroma = get_bits(gb, 4) + 1;
813  get_ue_golomb_long(gb);
814  if (sps->pcm.bit_depth > sps->bit_depth) {
816  "PCM bit depth (%d) is greater than normal bit depth (%d)\n",
817  sps->pcm.bit_depth, sps->bit_depth);
818  ret = AVERROR_INVALIDDATA;
819  goto err;
820  }
821 
823  }
824 
825  sps->nb_st_rps = get_ue_golomb_long(gb);
826  if (sps->nb_st_rps > MAX_SHORT_TERM_RPS_COUNT) {
827  av_log(s->avctx, AV_LOG_ERROR, "Too many short term RPS: %d.\n",
828  sps->nb_st_rps);
829  ret = AVERROR_INVALIDDATA;
830  goto err;
831  }
832  for (i = 0; i < sps->nb_st_rps; i++) {
833  if ((ret = ff_hevc_decode_short_term_rps(s, &sps->st_rps[i],
834  sps, 0)) < 0)
835  goto err;
836  }
837 
841  for (i = 0; i < sps->num_long_term_ref_pics_sps; i++) {
844  }
845  }
846 
849  sps->vui.sar = (AVRational){0, 1};
850  vui_present = get_bits1(gb);
851  if (vui_present)
852  decode_vui(s, sps);
853  skip_bits1(gb); // sps_extension_flag
854 
855  if (s->apply_defdispwin) {
860  }
861  if (sps->output_window.left_offset & (0x1F >> (sps->pixel_shift)) &&
862  !(s->avctx->flags & CODEC_FLAG_UNALIGNED)) {
863  sps->output_window.left_offset &= ~(0x1F >> (sps->pixel_shift));
864  av_log(s->avctx, AV_LOG_WARNING, "Reducing left output window to %d "
865  "chroma samples to preserve alignment.\n",
867  }
868  sps->output_width = sps->width -
870  sps->output_height = sps->height -
872  if (sps->output_width <= 0 || sps->output_height <= 0) {
873  av_log(s->avctx, AV_LOG_WARNING, "Invalid visible frame dimensions: %dx%d.\n",
874  sps->output_width, sps->output_height);
875  if (s->avctx->err_recognition & AV_EF_EXPLODE) {
876  ret = AVERROR_INVALIDDATA;
877  goto err;
878  }
880  "Displaying the whole video surface.\n");
883  sps->pic_conf_win.top_offset =
884  sps->pic_conf_win.bottom_offset = 0;
885  sps->output_width = sps->width;
886  sps->output_height = sps->height;
887  }
888 
889  // Inferred parameters
890  sps->log2_ctb_size = sps->log2_min_cb_size +
892  sps->log2_min_pu_size = sps->log2_min_cb_size - 1;
893 
894  sps->ctb_width = (sps->width + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
895  sps->ctb_height = (sps->height + (1 << sps->log2_ctb_size) - 1) >> sps->log2_ctb_size;
896  sps->ctb_size = sps->ctb_width * sps->ctb_height;
897 
898  sps->min_cb_width = sps->width >> sps->log2_min_cb_size;
899  sps->min_cb_height = sps->height >> sps->log2_min_cb_size;
900  sps->min_tb_width = sps->width >> sps->log2_min_tb_size;
901  sps->min_tb_height = sps->height >> sps->log2_min_tb_size;
902  sps->min_pu_width = sps->width >> sps->log2_min_pu_size;
903  sps->min_pu_height = sps->height >> sps->log2_min_pu_size;
904 
905  sps->qp_bd_offset = 6 * (sps->bit_depth - 8);
906 
907  if (sps->width & ((1 << sps->log2_min_cb_size) - 1) ||
908  sps->height & ((1 << sps->log2_min_cb_size) - 1)) {
909  av_log(s->avctx, AV_LOG_ERROR, "Invalid coded frame dimensions.\n");
910  goto err;
911  }
912 
913  if (sps->log2_ctb_size > MAX_LOG2_CTB_SIZE) {
914  av_log(s->avctx, AV_LOG_ERROR, "CTB size out of range: 2^%d\n", sps->log2_ctb_size);
915  goto err;
916  }
918  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_inter out of range: %d\n",
920  goto err;
921  }
923  av_log(s->avctx, AV_LOG_ERROR, "max_transform_hierarchy_depth_intra out of range: %d\n",
925  goto err;
926  }
927  if (sps->log2_max_trafo_size > FFMIN(sps->log2_ctb_size, 5)) {
929  "max transform block size out of range: %d\n",
930  sps->log2_max_trafo_size);
931  goto err;
932  }
933 
934  if (s->avctx->debug & FF_DEBUG_BITSTREAM) {
936  "Parsed SPS: id %d; coded wxh: %dx%d; "
937  "cropped wxh: %dx%d; pix_fmt: %s.\n",
938  sps_id, sps->width, sps->height,
939  sps->output_width, sps->output_height,
941  }
942 
943  /* check if this is a repeat of an already parsed SPS, then keep the
944  * original one.
945  * otherwise drop all PPSes that depend on it */
946  if (s->sps_list[sps_id] &&
947  !memcmp(s->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
948  av_buffer_unref(&sps_buf);
949  } else {
950  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++) {
951  if (s->pps_list[i] && ((HEVCPPS*)s->pps_list[i]->data)->sps_id == sps_id)
952  av_buffer_unref(&s->pps_list[i]);
953  }
954  av_buffer_unref(&s->sps_list[sps_id]);
955  s->sps_list[sps_id] = sps_buf;
956  }
957 
958  return 0;
959 
960 err:
961  av_buffer_unref(&sps_buf);
962  return ret;
963 }
964 
965 static void hevc_pps_free(void *opaque, uint8_t *data)
966 {
967  HEVCPPS *pps = (HEVCPPS*)data;
968 
969  av_freep(&pps->column_width);
970  av_freep(&pps->row_height);
971  av_freep(&pps->col_bd);
972  av_freep(&pps->row_bd);
973  av_freep(&pps->col_idxX);
976  av_freep(&pps->tile_pos_rs);
977  av_freep(&pps->tile_id);
978  av_freep(&pps->min_cb_addr_zs);
979  av_freep(&pps->min_tb_addr_zs);
980 
981  av_freep(&pps);
982 }
983 
985 {
986  GetBitContext *gb = &s->HEVClc.gb;
987  HEVCSPS *sps = NULL;
988  int pic_area_in_ctbs, pic_area_in_min_cbs, pic_area_in_min_tbs;
989  int log2_diff_ctb_min_tb_size;
990  int i, j, x, y, ctb_addr_rs, tile_id;
991  int ret = 0;
992  unsigned int pps_id = 0;
993 
994  AVBufferRef *pps_buf;
995  HEVCPPS *pps = av_mallocz(sizeof(*pps));
996 
997  if (!pps)
998  return AVERROR(ENOMEM);
999 
1000  pps_buf = av_buffer_create((uint8_t *)pps, sizeof(*pps),
1001  hevc_pps_free, NULL, 0);
1002  if (!pps_buf) {
1003  av_freep(&pps);
1004  return AVERROR(ENOMEM);
1005  }
1006 
1007  av_log(s->avctx, AV_LOG_DEBUG, "Decoding PPS\n");
1008 
1009  // Default values
1011  pps->num_tile_columns = 1;
1012  pps->num_tile_rows = 1;
1013  pps->uniform_spacing_flag = 1;
1014  pps->disable_dbf = 0;
1015  pps->beta_offset = 0;
1016  pps->tc_offset = 0;
1017 
1018  // Coded parameters
1019  pps_id = get_ue_golomb_long(gb);
1020  if (pps_id >= MAX_PPS_COUNT) {
1021  av_log(s->avctx, AV_LOG_ERROR, "PPS id out of range: %d\n", pps_id);
1022  ret = AVERROR_INVALIDDATA;
1023  goto err;
1024  }
1025  pps->sps_id = get_ue_golomb_long(gb);
1026  if (pps->sps_id >= MAX_SPS_COUNT) {
1027  av_log(s->avctx, AV_LOG_ERROR, "SPS id out of range: %d\n", pps->sps_id);
1028  ret = AVERROR_INVALIDDATA;
1029  goto err;
1030  }
1031  if (!s->sps_list[pps->sps_id]) {
1032  av_log(s->avctx, AV_LOG_ERROR, "SPS %u does not exist.\n", pps->sps_id);
1033  ret = AVERROR_INVALIDDATA;
1034  goto err;
1035  }
1036  sps = (HEVCSPS *)s->sps_list[pps->sps_id]->data;
1037 
1040  pps->num_extra_slice_header_bits = get_bits(gb, 3);
1041 
1042  pps->sign_data_hiding_flag = get_bits1(gb);
1043 
1045 
1048 
1050 
1053 
1055  pps->diff_cu_qp_delta_depth = 0;
1056  if (pps->cu_qp_delta_enabled_flag)
1058 
1059  pps->cb_qp_offset = get_se_golomb(gb);
1060  if (pps->cb_qp_offset < -12 || pps->cb_qp_offset > 12) {
1061  av_log(s->avctx, AV_LOG_ERROR, "pps_cb_qp_offset out of range: %d\n",
1062  pps->cb_qp_offset);
1063  ret = AVERROR_INVALIDDATA;
1064  goto err;
1065  }
1066  pps->cr_qp_offset = get_se_golomb(gb);
1067  if (pps->cr_qp_offset < -12 || pps->cr_qp_offset > 12) {
1068  av_log(s->avctx, AV_LOG_ERROR, "pps_cr_qp_offset out of range: %d\n",
1069  pps->cr_qp_offset);
1070  ret = AVERROR_INVALIDDATA;
1071  goto err;
1072  }
1074 
1075  pps->weighted_pred_flag = get_bits1(gb);
1076  pps->weighted_bipred_flag = get_bits1(gb);
1077 
1079  pps->tiles_enabled_flag = get_bits1(gb);
1081 
1082  if (pps->tiles_enabled_flag) {
1083  pps->num_tile_columns = get_ue_golomb_long(gb) + 1;
1084  pps->num_tile_rows = get_ue_golomb_long(gb) + 1;
1085  if (pps->num_tile_columns == 0 ||
1086  pps->num_tile_columns >= sps->width) {
1087  av_log(s->avctx, AV_LOG_ERROR, "num_tile_columns_minus1 out of range: %d\n",
1088  pps->num_tile_columns - 1);
1089  ret = AVERROR_INVALIDDATA;
1090  goto err;
1091  }
1092  if (pps->num_tile_rows == 0 ||
1093  pps->num_tile_rows >= sps->height) {
1094  av_log(s->avctx, AV_LOG_ERROR, "num_tile_rows_minus1 out of range: %d\n",
1095  pps->num_tile_rows - 1);
1096  ret = AVERROR_INVALIDDATA;
1097  goto err;
1098  }
1099 
1100  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1101  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1102  if (!pps->column_width || !pps->row_height) {
1103  ret = AVERROR(ENOMEM);
1104  goto err;
1105  }
1106 
1107  pps->uniform_spacing_flag = get_bits1(gb);
1108  if (!pps->uniform_spacing_flag) {
1109  uint64_t sum = 0;
1110  for (i = 0; i < pps->num_tile_columns - 1; i++) {
1111  pps->column_width[i] = get_ue_golomb_long(gb) + 1;
1112  sum += pps->column_width[i];
1113  }
1114  if (sum >= sps->ctb_width) {
1115  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile widths.\n");
1116  ret = AVERROR_INVALIDDATA;
1117  goto err;
1118  }
1119  pps->column_width[pps->num_tile_columns - 1] = sps->ctb_width - sum;
1120 
1121  sum = 0;
1122  for (i = 0; i < pps->num_tile_rows - 1; i++) {
1123  pps->row_height[i] = get_ue_golomb_long(gb) + 1;
1124  sum += pps->row_height[i];
1125  }
1126  if (sum >= sps->ctb_height) {
1127  av_log(s->avctx, AV_LOG_ERROR, "Invalid tile heights.\n");
1128  ret = AVERROR_INVALIDDATA;
1129  goto err;
1130  }
1131  pps->row_height[pps->num_tile_rows - 1] = sps->ctb_height - sum;
1132  }
1134  }
1135 
1137 
1141  pps->disable_dbf = get_bits1(gb);
1142  if (!pps->disable_dbf) {
1143  pps->beta_offset = get_se_golomb(gb) * 2;
1144  pps->tc_offset = get_se_golomb(gb) * 2;
1145  if (pps->beta_offset/2 < -6 || pps->beta_offset/2 > 6) {
1146  av_log(s->avctx, AV_LOG_ERROR, "pps_beta_offset_div2 out of range: %d\n",
1147  pps->beta_offset/2);
1148  ret = AVERROR_INVALIDDATA;
1149  goto err;
1150  }
1151  if (pps->tc_offset/2 < -6 || pps->tc_offset/2 > 6) {
1152  av_log(s->avctx, AV_LOG_ERROR, "pps_tc_offset_div2 out of range: %d\n",
1153  pps->tc_offset/2);
1154  ret = AVERROR_INVALIDDATA;
1155  goto err;
1156  }
1157  }
1158  }
1159 
1161  if (pps->scaling_list_data_present_flag) {
1163  ret = scaling_list_data(s, &pps->scaling_list);
1164  if (ret < 0)
1165  goto err;
1166  }
1169  if (pps->log2_parallel_merge_level > sps->log2_ctb_size) {
1170  av_log(s->avctx, AV_LOG_ERROR, "log2_parallel_merge_level_minus2 out of range: %d\n",
1171  pps->log2_parallel_merge_level - 2);
1172  ret = AVERROR_INVALIDDATA;
1173  goto err;
1174  }
1175 
1177  skip_bits1(gb); // pps_extension_flag
1178 
1179  // Inferred parameters
1180  pps->col_bd = av_malloc_array(pps->num_tile_columns + 1, sizeof(*pps->col_bd));
1181  pps->row_bd = av_malloc_array(pps->num_tile_rows + 1, sizeof(*pps->row_bd));
1182  pps->col_idxX = av_malloc_array(sps->ctb_width, sizeof(*pps->col_idxX));
1183  if (!pps->col_bd || !pps->row_bd || !pps->col_idxX) {
1184  ret = AVERROR(ENOMEM);
1185  goto err;
1186  }
1187 
1188  if (pps->uniform_spacing_flag) {
1189  if (!pps->column_width) {
1190  pps->column_width = av_malloc_array(pps->num_tile_columns, sizeof(*pps->column_width));
1191  pps->row_height = av_malloc_array(pps->num_tile_rows, sizeof(*pps->row_height));
1192  }
1193  if (!pps->column_width || !pps->row_height) {
1194  ret = AVERROR(ENOMEM);
1195  goto err;
1196  }
1197 
1198  for (i = 0; i < pps->num_tile_columns; i++) {
1199  pps->column_width[i] = ((i + 1) * sps->ctb_width) / pps->num_tile_columns -
1200  (i * sps->ctb_width) / pps->num_tile_columns;
1201  }
1202 
1203  for (i = 0; i < pps->num_tile_rows; i++) {
1204  pps->row_height[i] = ((i + 1) * sps->ctb_height) / pps->num_tile_rows -
1205  (i * sps->ctb_height) / pps->num_tile_rows;
1206  }
1207  }
1208 
1209  pps->col_bd[0] = 0;
1210  for (i = 0; i < pps->num_tile_columns; i++)
1211  pps->col_bd[i + 1] = pps->col_bd[i] + pps->column_width[i];
1212 
1213  pps->row_bd[0] = 0;
1214  for (i = 0; i < pps->num_tile_rows; i++)
1215  pps->row_bd[i + 1] = pps->row_bd[i] + pps->row_height[i];
1216 
1217  for (i = 0, j = 0; i < sps->ctb_width; i++) {
1218  if (i > pps->col_bd[j])
1219  j++;
1220  pps->col_idxX[i] = j;
1221  }
1222 
1226  pic_area_in_ctbs = sps->ctb_width * sps->ctb_height;
1227  pic_area_in_min_cbs = sps->min_cb_width * sps->min_cb_height;
1228  pic_area_in_min_tbs = sps->min_tb_width * sps->min_tb_height;
1229 
1230  pps->ctb_addr_rs_to_ts = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_rs_to_ts));
1231  pps->ctb_addr_ts_to_rs = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->ctb_addr_ts_to_rs));
1232  pps->tile_id = av_malloc_array(pic_area_in_ctbs, sizeof(*pps->tile_id));
1233  pps->min_cb_addr_zs = av_malloc_array(pic_area_in_min_cbs, sizeof(*pps->min_cb_addr_zs));
1234  pps->min_tb_addr_zs = av_malloc_array(pic_area_in_min_tbs, sizeof(*pps->min_tb_addr_zs));
1235  if (!pps->ctb_addr_rs_to_ts || !pps->ctb_addr_ts_to_rs ||
1236  !pps->tile_id || !pps->min_cb_addr_zs || !pps->min_tb_addr_zs) {
1237  ret = AVERROR(ENOMEM);
1238  goto err;
1239  }
1240 
1241  for (ctb_addr_rs = 0; ctb_addr_rs < pic_area_in_ctbs; ctb_addr_rs++) {
1242  int tb_x = ctb_addr_rs % sps->ctb_width;
1243  int tb_y = ctb_addr_rs / sps->ctb_width;
1244  int tile_x = 0;
1245  int tile_y = 0;
1246  int val = 0;
1247 
1248  for (i = 0; i < pps->num_tile_columns; i++) {
1249  if (tb_x < pps->col_bd[i + 1]) {
1250  tile_x = i;
1251  break;
1252  }
1253  }
1254 
1255  for (i = 0; i < pps->num_tile_rows; i++) {
1256  if (tb_y < pps->row_bd[i + 1]) {
1257  tile_y = i;
1258  break;
1259  }
1260  }
1261 
1262  for (i = 0; i < tile_x; i++)
1263  val += pps->row_height[tile_y] * pps->column_width[i];
1264  for (i = 0; i < tile_y; i++)
1265  val += sps->ctb_width * pps->row_height[i];
1266 
1267  val += (tb_y - pps->row_bd[tile_y]) * pps->column_width[tile_x] +
1268  tb_x - pps->col_bd[tile_x];
1269 
1270  pps->ctb_addr_rs_to_ts[ctb_addr_rs] = val;
1271  pps->ctb_addr_ts_to_rs[val] = ctb_addr_rs;
1272  }
1273 
1274  for (j = 0, tile_id = 0; j < pps->num_tile_rows; j++)
1275  for (i = 0; i < pps->num_tile_columns; i++, tile_id++)
1276  for (y = pps->row_bd[j]; y < pps->row_bd[j + 1]; y++)
1277  for (x = pps->col_bd[i]; x < pps->col_bd[i + 1]; x++)
1278  pps->tile_id[pps->ctb_addr_rs_to_ts[y * sps->ctb_width + x]] = tile_id;
1279 
1280  pps->tile_pos_rs = av_malloc_array(tile_id, sizeof(*pps->tile_pos_rs));
1281  if (!pps->tile_pos_rs) {
1282  ret = AVERROR(ENOMEM);
1283  goto err;
1284  }
1285 
1286  for (j = 0; j < pps->num_tile_rows; j++)
1287  for (i = 0; i < pps->num_tile_columns; i++)
1288  pps->tile_pos_rs[j * pps->num_tile_columns + i] = pps->row_bd[j] * sps->ctb_width + pps->col_bd[i];
1289 
1290  for (y = 0; y < sps->min_cb_height; y++) {
1291  for (x = 0; x < sps->min_cb_width; x++) {
1292  int tb_x = x >> sps->log2_diff_max_min_coding_block_size;
1293  int tb_y = y >> sps->log2_diff_max_min_coding_block_size;
1294  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1295  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1297  for (i = 0; i < sps->log2_diff_max_min_coding_block_size; i++) {
1298  int m = 1 << i;
1299  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1300  }
1301  pps->min_cb_addr_zs[y * sps->min_cb_width + x] = val;
1302  }
1303  }
1304 
1305  log2_diff_ctb_min_tb_size = sps->log2_ctb_size - sps->log2_min_tb_size;
1306  for (y = 0; y < sps->min_tb_height; y++) {
1307  for (x = 0; x < sps->min_tb_width; x++) {
1308  int tb_x = x >> log2_diff_ctb_min_tb_size;
1309  int tb_y = y >> log2_diff_ctb_min_tb_size;
1310  int ctb_addr_rs = sps->ctb_width * tb_y + tb_x;
1311  int val = pps->ctb_addr_rs_to_ts[ctb_addr_rs] <<
1312  (log2_diff_ctb_min_tb_size * 2);
1313  for (i = 0; i < log2_diff_ctb_min_tb_size; i++) {
1314  int m = 1 << i;
1315  val += (m & x ? m * m : 0) + (m & y ? 2 * m * m : 0);
1316  }
1317  pps->min_tb_addr_zs[y * sps->min_tb_width + x] = val;
1318  }
1319  }
1320 
1321  av_buffer_unref(&s->pps_list[pps_id]);
1322  s->pps_list[pps_id] = pps_buf;
1323 
1324  return 0;
1325 
1326 err:
1327  av_buffer_unref(&pps_buf);
1328  return ret;
1329 }
unsigned int log2_min_cb_size
Definition: hevc.h:436
int min_spatial_segmentation_idc
Definition: hevc.h:330
#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:105
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1507
int ctb_height
Definition: hevc.h:450
#define CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:655
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:323
int max_dec_pic_buffering
Definition: hevc.h:404
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:694
int ff_hevc_decode_nal_sps(HEVCContext *s)
Definition: hevc_ps.c:608
int vps_id
Definition: hevc.h:385
unsigned int * row_height
RowHeight.
Definition: hevc.h:517
int vps_num_ticks_poc_diff_one
vps_num_ticks_poc_diff_one_minus1 + 1
Definition: hevc.h:373
#define MAX_REFS
Definition: hevc.h:42
int pic_init_qp_minus26
Definition: hevc.h:474
#define MAX_PPS_COUNT
Definition: h264.h:43
VUI vui
Definition: hevc.h:409
#define MAX_DPB_SIZE
Definition: hevc.h:41
int vshift[3]
Definition: hevc.h:460
struct HEVCSPS::@24 pcm
int num
numerator
Definition: rational.h:44
#define MAX_LOG2_CTB_SIZE
Definition: hevc.h:59
#define FF_DEBUG_BITSTREAM
Definition: avcodec.h:2351
uint32_t vui_time_scale
Definition: hevc.h:321
uint8_t weighted_bipred_flag
Definition: hevc.h:486
Definition: hevc.h:349
uint8_t seq_loop_filter_across_slices_enabled_flag
Definition: hevc.h:499
uint8_t cabac_init_present_flag
Definition: hevc.h:470
int chroma_loc_info_present_flag
Definition: hevc.h:308
int max_latency_increase
Definition: hevc.h:406
#define FF_ARRAY_ELEMS(a)
int min_cb_height
Definition: hevc.h:453
int * ctb_addr_ts_to_rs
CtbAddrTSToRS.
Definition: hevc.h:523
int num_ref_idx_l0_default_active
num_ref_idx_l0_default_active_minus1 + 1
Definition: hevc.h:472
static const AVRational vui_sar[]
Definition: hevc_ps.c:53
Not part of ABI.
Definition: avcodec.h:558
int bottom_offset
Definition: hevc.h:291
ShortTermRPS st_rps[MAX_SHORT_TERM_RPS_COUNT]
Definition: hevc.h:416
int chroma_sample_loc_type_top_field
Definition: hevc.h:309
int width
Definition: hevc.h:447
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:68
int qp_bd_offset
Definition: hevc.h:462
int pixel_shift
Definition: hevc.h:396
uint8_t entropy_coding_sync_enabled_flag
Definition: hevc.h:492
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:391
int output_width
Definition: hevc.h:390
int log2_parallel_merge_level
log2_parallel_merge_level_minus2 + 2
Definition: hevc.h:511
int restricted_ref_pic_lists_flag
Definition: hevc.h:329
int chroma_format_idc
Definition: hevc.h:386
uint8_t disable_dbf
Definition: hevc.h:503
unsigned int log2_max_trafo_size
Definition: hevc.h:439
uint8_t profile_compatibility_flag[32]
Definition: hevc.h:341
Definition: hevc.h:294
unsigned int num_negative_pics
Definition: hevc.h:264
uint8_t
uint8_t sub_layer_profile_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:353
int * min_cb_addr_zs
MinCbAddrZS.
Definition: hevc.h:526
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:365
float delta
HEVCWindow pic_conf_win
Definition: hevc.h:393
int overscan_info_present_flag
Definition: hevc.h:297
uint8_t vps_timing_info_present_flag
Definition: hevc.h:369
uint8_t matrix_coeffs
Definition: hevc.h:306
int min_tb_width
Definition: hevc.h:454
#define FF_PROFILE_HEVC_MAIN
Definition: avcodec.h:2670
int apply_defdispwin
Definition: hevc.h:854
int num_ref_idx_l1_default_active
num_ref_idx_l1_default_active_minus1 + 1
Definition: hevc.h:473
unsigned int log2_min_pcm_cb_size
Definition: hevc.h:429
AVCodecContext * avctx
Definition: hevc.h:762
int min_cb_width
Definition: hevc.h:452
int vps_max_sub_layers
vps_max_temporal_layers_minus1 + 1
Definition: hevc.h:360
int frame_field_info_present_flag
Definition: hevc.h:314
uint8_t tier_flag
Definition: hevc.h:339
const char data[16]
Definition: mxf.c:66
uint8_t scaling_list_data_present_flag
Definition: hevc.h:507
uint8_t bit_depth_chroma
Definition: hevc.h:428
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:431
int ff_hevc_decode_nal_pps(HEVCContext *s)
Definition: hevc_ps.c:984
#define FF_PROFILE_HEVC_MAIN_10
Definition: avcodec.h:2671
int bitstream_restriction_flag
Definition: hevc.h:326
uint8_t transquant_bypass_enable_flag
Definition: hevc.h:488
int vps_max_layer_id
Definition: hevc.h:367
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:346
unsigned int log2_max_poc_lsb
Definition: hevc.h:399
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:77
int vps_max_layers
Definition: hevc.h:359
int min_pu_height
Definition: hevc.h:457
AVBufferRef * vps_list[MAX_VPS_COUNT]
Definition: hevc.h:779
#define AVERROR(e)
Definition: error.h:43
int vui_timing_info_present_flag
Definition: hevc.h:319
uint8_t amp_enabled_flag
Definition: hevc.h:418
HEVCLocalContext HEVClc
Definition: hevc.h:764
#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
unsigned int log2_ctb_size
Definition: hevc.h:440
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1142
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
int vui_poc_proportional_to_timing_flag
Definition: hevc.h:322
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:27
uint8_t vps_temporal_id_nesting_flag
Definition: hevc.h:358
uint8_t colour_primaries
Definition: hevc.h:304
uint8_t used[32]
Definition: hevc.h:267
int motion_vectors_over_pic_boundaries_flag
Definition: hevc.h:328
uint8_t tiles_enabled_flag
Definition: hevc.h:491
uint32_t vps_num_units_in_tick
Definition: hevc.h:370
int * col_idxX
Definition: hevc.h:520
int vps_num_layer_sets
vps_num_layer_sets_minus1 + 1
Definition: hevc.h:368
uint8_t lists_modification_present_flag
Definition: hevc.h:510
uint8_t profile_idc
Definition: hevc.h:340
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:220
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2390
int max_transform_hierarchy_depth_inter
Definition: hevc.h:443
#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:372
int num_tile_columns
num_tile_columns_minus1 + 1
Definition: hevc.h:494
int output_height
Definition: hevc.h:390
int hshift[3]
Definition: hevc.h:459
#define FF_PROFILE_HEVC_MAIN_STILL_PICTURE
Definition: avcodec.h:2672
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: hevc.h:780
int32_t
int max_bits_per_min_cu_denom
Definition: hevc.h:332
uint8_t cu_qp_delta_enabled_flag
Definition: hevc.h:479
uint8_t used_by_curr_pic_lt_sps_flag[32]
Definition: hevc.h:423
#define MAX_SPS_COUNT
Definition: h264.h:42
int ctb_width
Definition: hevc.h:449
uint8_t sl_dc[2][6]
Definition: hevc.h:381
int32_t delta_poc[32]
Definition: hevc.h:266
uint8_t sign_data_hiding_flag
Definition: hevc.h:468
int height
Definition: hevc.h:448
#define AV_EF_EXPLODE
Definition: avcodec.h:2401
uint8_t output_flag_present_flag
Definition: hevc.h:487
int log2_max_mv_length_vertical
Definition: hevc.h:334
const uint8_t ff_hevc_diag_scan4x4_y[16]
Definition: hevc.c:91
PTLCommon general_ptl
Definition: hevc.h:350
int max_bytes_per_pic_denom
Definition: hevc.h:331
static int scaling_list_data(HEVCContext *s, ScalingList *sl)
Definition: hevc_ps.c:551
int overscan_appropriate_flag
Definition: hevc.h:298
static void set_default_scaling_list_data(ScalingList *sl)
Definition: hevc_ps.c:525
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: hevc.h:781
uint8_t constrained_intra_pred_flag
Definition: hevc.h:476
uint8_t sl[4][6][64]
Definition: hevc.h:380
PTL ptl
Definition: hevc.h:362
uint8_t pic_slice_level_chroma_qp_offsets_present_flag
Definition: hevc.h:484
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:371
int colour_description_present_flag
Definition: hevc.h:303
uint8_t sub_layer_level_present_flag[MAX_SUB_LAYERS]
Definition: hevc.h:354
Definition: hevc.h:384
enum AVPixelFormat pix_fmt
Definition: hevc.h:397
Definition: hevc.h:357
NULL
Definition: eval.c:55
Definition: hevc.h:465
uint8_t transform_skip_enabled_flag
Definition: hevc.h:477
uint8_t uniform_spacing_flag
Definition: hevc.h:496
int ctb_size
Definition: hevc.h:451
int * ctb_addr_rs_to_ts
CtbAddrRSToTS.
Definition: hevc.h:522
PTL ptl
Definition: hevc.h:410
int max_sub_layers
Definition: hevc.h:402
unsigned int log2_min_pu_size
Definition: hevc.h:441
unsigned int sps_id
seq_parameter_set_id
Definition: hevc.h:466
int debug
debug
Definition: avcodec.h:2348
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
#define MAX_VPS_COUNT
Definition: hevc.h:48
ScalingList scaling_list
Definition: hevc.h:508
int log2_max_mv_length_horizontal
Definition: hevc.h:333
uint8_t sao_enabled
Definition: hevc.h:419
int num_extra_slice_header_bits
Definition: hevc.h:512
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t loop_filter_across_tiles_enabled_flag
Definition: hevc.h:497
uint8_t num_long_term_ref_pics_sps
Definition: hevc.h:424
uint32_t vui_num_units_in_tick
Definition: hevc.h:320
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:81
uint8_t deblocking_filter_control_present_flag
Definition: hevc.h:501
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:224
uint8_t sps_temporal_mvp_enabled_flag
Definition: hevc.h:433
unsigned int nb_st_rps
Definition: hevc.h:415
int chroma_sample_loc_type_bottom_field
Definition: hevc.h:310
int num_tile_rows
num_tile_rows_minus1 + 1
Definition: hevc.h:495
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:374
#define MAX_SUB_LAYERS
7.4.2.1
Definition: hevc.h:47
GetBitContext gb
Definition: hevc.h:733
static void hevc_pps_free(void *opaque, uint8_t *data)
Definition: hevc_ps.c:965
unsigned int log2_min_tb_size
Definition: hevc.h:438
uint16_t lt_ref_pic_poc_lsb_sps[32]
Definition: hevc.h:422
int top_offset
Definition: hevc.h:290
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:221
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:412
int * tile_id
TileId.
Definition: hevc.h:524
static const uint8_t default_scaling_list_intra[]
Definition: hevc_ps.c:31
int tc_offset
tc_offset_div2 * 2
Definition: hevc.h:505
uint8_t transfer_characteristic
Definition: hevc.h:305
int default_display_window_flag
Definition: hevc.h:316
int size
Size of data in bytes.
Definition: buffer.h:93
HEVCWindow def_disp_win
Definition: hevc.h:317
int cr_qp_offset
Definition: hevc.h:483
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:413
unsigned int log2_diff_max_min_coding_block_size
Definition: hevc.h:437
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:430
uint8_t level_idc
Definition: hevc.h:342
struct HEVCSPS::@23 temporal_layer[MAX_SUB_LAYERS]
int neutra_chroma_indication_flag
Definition: hevc.h:311
int * tile_pos_rs
TilePosRS.
Definition: hevc.h:525
static void decode_vui(HEVCContext *s, HEVCSPS *sps)
Definition: hevc_ps.c:418
const uint8_t ff_hevc_diag_scan8x8_x[64]
Definition: hevc.c:105
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:444
uint8_t profile_space
Definition: hevc.h:338
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:519
int video_format
Definition: hevc.h:301
uint8_t weighted_pred_flag
Definition: hevc.h:485
unsigned int * col_bd
ColBd.
Definition: hevc.h:518
unsigned int * column_width
ColumnWidth.
Definition: hevc.h:516
int right_offset
Definition: hevc.h:289
uint8_t slice_header_extension_present_flag
Definition: hevc.h:513
int den
denominator
Definition: rational.h:45
int video_full_range_flag
Definition: hevc.h:302
PTLCommon sub_layer_ptl[MAX_SUB_LAYERS]
Definition: hevc.h:351
AVRational sar
Definition: hevc.h:295
int num_delta_pocs
Definition: hevc.h:265
uint8_t sps_strong_intra_smoothing_enable_flag
Definition: hevc.h:434
int min_pu_width
Definition: hevc.h:456
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:84
unsigned int vps_max_dec_pic_buffering[MAX_SUB_LAYERS]
Definition: hevc.h:364
uint8_t long_term_ref_pics_present_flag
Definition: hevc.h:421
unsigned int vps_max_latency_increase[MAX_SUB_LAYERS]
Definition: hevc.h:366
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1149
Not part of ABI.
Definition: avcodec.h:590
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:324
int diff_cu_qp_delta_depth
Definition: hevc.h:480
int num_reorder_pics
Definition: hevc.h:405
const uint8_t ff_hevc_diag_scan8x8_y[64]
Definition: hevc.c:124
uint8_t progressive_source_flag
Definition: hevc.h:343
int cb_qp_offset
Definition: hevc.h:482
int video_signal_type_present_flag
Definition: hevc.h:300
uint8_t deblocking_filter_override_enabled_flag
Definition: hevc.h:502
int bit_depth
Definition: hevc.h:395
int beta_offset
beta_offset_div2 * 2
Definition: hevc.h:504
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:1449
int min_tb_height
Definition: hevc.h:455
int * min_tb_addr_zs
MinTbAddrZS.
Definition: hevc.h:527
int left_offset
Definition: hevc.h:288
uint8_t non_packed_constraint_flag
Definition: hevc.h:345
exp golomb vlc stuff
int pcm_enabled_flag
Definition: hevc.h:400
int tiles_fixed_structure_flag
Definition: hevc.h:327
uint8_t interlaced_source_flag
Definition: hevc.h:344
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:313
Not part of ABI.
Definition: avcodec.h:576
for(j=16;j >0;--j)
uint8_t separate_colour_plane_flag
output (i.e. cropped) values
Definition: hevc.h:387
int vps_sub_layer_ordering_info_present_flag
Definition: hevc.h:363
uint8_t dependent_slice_segments_enabled_flag
Definition: hevc.h:490