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