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