FFmpeg
h264_ps.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 parameter set decoding.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #include <inttypes.h>
29 
30 #include "libavutil/imgutils.h"
31 #include "mathops.h"
32 #include "avcodec.h"
33 #include "h264data.h"
34 #include "h2645_vui.h"
35 #include "h264_ps.h"
36 #include "golomb.h"
37 #include "refstruct.h"
38 
39 #define MIN_LOG2_MAX_FRAME_NUM 4
40 
41 static const uint8_t default_scaling4[2][16] = {
42  { 6, 13, 20, 28, 13, 20, 28, 32,
43  20, 28, 32, 37, 28, 32, 37, 42 },
44  { 10, 14, 20, 24, 14, 20, 24, 27,
45  20, 24, 27, 30, 24, 27, 30, 34 }
46 };
47 
48 static const uint8_t default_scaling8[2][64] = {
49  { 6, 10, 13, 16, 18, 23, 25, 27,
50  10, 11, 16, 18, 23, 25, 27, 29,
51  13, 16, 18, 23, 25, 27, 29, 31,
52  16, 18, 23, 25, 27, 29, 31, 33,
53  18, 23, 25, 27, 29, 31, 33, 36,
54  23, 25, 27, 29, 31, 33, 36, 38,
55  25, 27, 29, 31, 33, 36, 38, 40,
56  27, 29, 31, 33, 36, 38, 40, 42 },
57  { 9, 13, 15, 17, 19, 21, 22, 24,
58  13, 13, 17, 19, 21, 22, 24, 25,
59  15, 17, 19, 21, 22, 24, 25, 27,
60  17, 19, 21, 22, 24, 25, 27, 28,
61  19, 21, 22, 24, 25, 27, 28, 30,
62  21, 22, 24, 25, 27, 28, 30, 32,
63  22, 24, 25, 27, 28, 30, 32, 33,
64  24, 25, 27, 28, 30, 32, 33, 35 }
65 };
66 
67 /* maximum number of MBs in the DPB for a given level */
68 static const int level_max_dpb_mbs[][2] = {
69  { 10, 396 },
70  { 11, 900 },
71  { 12, 2376 },
72  { 13, 2376 },
73  { 20, 2376 },
74  { 21, 4752 },
75  { 22, 8100 },
76  { 30, 8100 },
77  { 31, 18000 },
78  { 32, 20480 },
79  { 40, 32768 },
80  { 41, 32768 },
81  { 42, 34816 },
82  { 50, 110400 },
83  { 51, 184320 },
84  { 52, 184320 },
85 };
86 
87 static void remove_pps(H264ParamSets *s, int id)
88 {
89  ff_refstruct_unref(&s->pps_list[id]);
90 }
91 
92 static void remove_sps(H264ParamSets *s, int id)
93 {
94 #if 0
95  int i;
96  if (s->sps_list[id]) {
97  /* drop all PPS that depend on this SPS */
98  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
99  if (s->pps_list[i] && s->pps_list[i]->sps_id == id)
100  remove_pps(s, i);
101  }
102 #endif
103  ff_refstruct_unref(&s->sps_list[id]);
104 }
105 
106 static inline int decode_hrd_parameters(GetBitContext *gb, void *logctx,
107  SPS *sps)
108 {
109  int cpb_count, i;
110  cpb_count = get_ue_golomb_31(gb) + 1;
111 
112  if (cpb_count > 32U) {
113  av_log(logctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
114  return AVERROR_INVALIDDATA;
115  }
116 
117  sps->cpr_flag = 0x0;
118  sps->bit_rate_scale = get_bits(gb, 4);
119  get_bits(gb, 4); /* cpb_size_scale */
120  for (i = 0; i < cpb_count; i++) {
121  sps->bit_rate_value[i] = get_ue_golomb_long(gb) + 1; /* bit_rate_value_minus1 + 1 */
122  sps->cpb_size_value[i] = get_ue_golomb_long(gb) + 1; /* cpb_size_value_minus1 + 1 */
123  sps->cpr_flag |= get_bits1(gb) << i;
124  }
125  sps->initial_cpb_removal_delay_length = get_bits(gb, 5) + 1;
126  sps->cpb_removal_delay_length = get_bits(gb, 5) + 1;
127  sps->dpb_output_delay_length = get_bits(gb, 5) + 1;
128  sps->time_offset_length = get_bits(gb, 5);
129  sps->cpb_cnt = cpb_count;
130  return 0;
131 }
132 
133 static inline int decode_vui_parameters(GetBitContext *gb, void *logctx,
134  SPS *sps)
135 {
136  ff_h2645_decode_common_vui_params(gb, &sps->vui, logctx);
137 
138  if (show_bits1(gb) && get_bits_left(gb) < 10) {
139  av_log(logctx, AV_LOG_WARNING, "Truncated VUI (%d)\n", get_bits_left(gb));
140  return 0;
141  }
142 
143  sps->timing_info_present_flag = get_bits1(gb);
144  if (sps->timing_info_present_flag) {
145  unsigned num_units_in_tick = get_bits_long(gb, 32);
146  unsigned time_scale = get_bits_long(gb, 32);
147  if (!num_units_in_tick || !time_scale) {
148  av_log(logctx, AV_LOG_ERROR,
149  "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
150  time_scale, num_units_in_tick);
151  sps->timing_info_present_flag = 0;
152  } else {
153  sps->num_units_in_tick = num_units_in_tick;
154  sps->time_scale = time_scale;
155  }
156  sps->fixed_frame_rate_flag = get_bits1(gb);
157  }
158 
159  sps->nal_hrd_parameters_present_flag = get_bits1(gb);
160  if (sps->nal_hrd_parameters_present_flag)
161  if (decode_hrd_parameters(gb, logctx, sps) < 0)
162  return AVERROR_INVALIDDATA;
163  sps->vcl_hrd_parameters_present_flag = get_bits1(gb);
164  if (sps->vcl_hrd_parameters_present_flag)
165  if (decode_hrd_parameters(gb, logctx, sps) < 0)
166  return AVERROR_INVALIDDATA;
167  if (sps->nal_hrd_parameters_present_flag ||
168  sps->vcl_hrd_parameters_present_flag)
169  get_bits1(gb); /* low_delay_hrd_flag */
170  sps->pic_struct_present_flag = get_bits1(gb);
171  if (!get_bits_left(gb))
172  return 0;
173  sps->bitstream_restriction_flag = get_bits1(gb);
174  if (sps->bitstream_restriction_flag) {
175  get_bits1(gb); /* motion_vectors_over_pic_boundaries_flag */
176  get_ue_golomb_31(gb); /* max_bytes_per_pic_denom */
177  get_ue_golomb_31(gb); /* max_bits_per_mb_denom */
178  get_ue_golomb_31(gb); /* log2_max_mv_length_horizontal */
179  get_ue_golomb_31(gb); /* log2_max_mv_length_vertical */
180  sps->num_reorder_frames = get_ue_golomb_31(gb);
181  sps->max_dec_frame_buffering = get_ue_golomb_31(gb);
182 
183  if (get_bits_left(gb) < 0) {
184  sps->num_reorder_frames = 0;
185  sps->bitstream_restriction_flag = 0;
186  }
187 
188  if (sps->num_reorder_frames > 16U
189  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
190  av_log(logctx, AV_LOG_ERROR,
191  "Clipping illegal num_reorder_frames %d\n",
192  sps->num_reorder_frames);
193  sps->num_reorder_frames = 16;
194  return AVERROR_INVALIDDATA;
195  }
196  }
197 
198  return 0;
199 }
200 
201 static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
202  const uint8_t *jvt_list, const uint8_t *fallback_list,
203  uint16_t *mask, int pos)
204 {
205  int i, last = 8, next = 8;
206  const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
207  uint16_t seq_scaling_list_present_flag = get_bits1(gb);
208  *mask |= (seq_scaling_list_present_flag << pos);
209  if (!seq_scaling_list_present_flag) /* matrix not written, we use the predicted one */
210  memcpy(factors, fallback_list, size * sizeof(uint8_t));
211  else
212  for (i = 0; i < size; i++) {
213  if (next) {
214  int v = get_se_golomb(gb);
215  if (v < -128 || v > 127) {
216  av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);
217  return AVERROR_INVALIDDATA;
218  }
219  next = (last + v) & 0xff;
220  }
221  if (!i && !next) { /* matrix not written, we use the preset one */
222  memcpy(factors, jvt_list, size * sizeof(uint8_t));
223  break;
224  }
225  last = factors[scan[i]] = next ? next : last;
226  }
227  return 0;
228 }
229 
230 /* returns non zero if the provided SPS scaling matrix has been filled */
232  const PPS *pps, int is_sps,
233  int present_flag, uint16_t *mask,
234  uint8_t(*scaling_matrix4)[16],
235  uint8_t(*scaling_matrix8)[64])
236 {
237  int fallback_sps = !is_sps && sps->scaling_matrix_present;
238  const uint8_t *fallback[4] = {
239  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
240  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
241  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
242  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
243  };
244  int ret = 0;
245  *mask = 0x0;
246  if (present_flag) {
247  ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0], mask, 0); // Intra, Y
248  ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0], mask, 1); // Intra, Cr
249  ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1], mask, 2); // Intra, Cb
250  ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1], mask, 3); // Inter, Y
251  ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3], mask, 4); // Inter, Cr
252  ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4], mask, 5); // Inter, Cb
253  if (is_sps || pps->transform_8x8_mode) {
254  ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2], mask, 6); // Intra, Y
255  ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3], mask, 7); // Inter, Y
256  if (sps->chroma_format_idc == 3) {
257  ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0], mask, 8); // Intra, Cr
258  ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3], mask, 9); // Inter, Cr
259  ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1], mask, 10); // Intra, Cb
260  ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4], mask, 11); // Inter, Cb
261  }
262  }
263  if (!ret)
264  ret = is_sps;
265  }
266 
267  return ret;
268 }
269 
271 {
272  int i;
273 
274  for (i = 0; i < MAX_SPS_COUNT; i++)
276 
277  for (i = 0; i < MAX_PPS_COUNT; i++)
279 
280  ff_refstruct_unref(&ps->pps);
281  ps->sps = NULL;
282 }
283 
285  H264ParamSets *ps, int ignore_truncation)
286 {
287  int profile_idc, level_idc, constraint_set_flags = 0;
288  unsigned int sps_id;
289  int i, log2_max_frame_num_minus4;
290  SPS *sps;
291  int ret;
292 
293  sps = ff_refstruct_allocz(sizeof(*sps));
294  if (!sps)
295  return AVERROR(ENOMEM);
296 
297  sps->data_size = gb->buffer_end - gb->buffer;
298  if (sps->data_size > sizeof(sps->data)) {
299  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized SPS\n");
300  sps->data_size = sizeof(sps->data);
301  }
302  memcpy(sps->data, gb->buffer, sps->data_size);
303 
304  // Re-add the removed stop bit (may be used by hwaccels).
305  if (!(gb->size_in_bits & 7) && sps->data_size < sizeof(sps->data))
306  sps->data[sps->data_size++] = 0x80;
307 
308  profile_idc = get_bits(gb, 8);
309  constraint_set_flags |= get_bits1(gb) << 0; // constraint_set0_flag
310  constraint_set_flags |= get_bits1(gb) << 1; // constraint_set1_flag
311  constraint_set_flags |= get_bits1(gb) << 2; // constraint_set2_flag
312  constraint_set_flags |= get_bits1(gb) << 3; // constraint_set3_flag
313  constraint_set_flags |= get_bits1(gb) << 4; // constraint_set4_flag
314  constraint_set_flags |= get_bits1(gb) << 5; // constraint_set5_flag
315  skip_bits(gb, 2); // reserved_zero_2bits
316  level_idc = get_bits(gb, 8);
317  sps_id = get_ue_golomb_31(gb);
318 
319  if (sps_id >= MAX_SPS_COUNT) {
320  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
321  goto fail;
322  }
323 
324  sps->sps_id = sps_id;
325  sps->time_offset_length = 24;
326  sps->profile_idc = profile_idc;
327  sps->constraint_set_flags = constraint_set_flags;
328  sps->level_idc = level_idc;
329  sps->vui.video_full_range_flag = -1;
330 
331  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
332  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
333  sps->scaling_matrix_present = 0;
334  sps->vui.matrix_coeffs = AVCOL_SPC_UNSPECIFIED;
335 
336  if (sps->profile_idc == 100 || // High profile
337  sps->profile_idc == 110 || // High10 profile
338  sps->profile_idc == 122 || // High422 profile
339  sps->profile_idc == 244 || // High444 Predictive profile
340  sps->profile_idc == 44 || // Cavlc444 profile
341  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
342  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
343  sps->profile_idc == 118 || // Stereo High profile (MVC)
344  sps->profile_idc == 128 || // Multiview High profile (MVC)
345  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
346  sps->profile_idc == 144) { // old High444 profile
347  sps->chroma_format_idc = get_ue_golomb_31(gb);
348  if (sps->chroma_format_idc > 3U) {
349  avpriv_request_sample(avctx, "chroma_format_idc %u",
350  sps->chroma_format_idc);
351  goto fail;
352  } else if (sps->chroma_format_idc == 3) {
353  sps->residual_color_transform_flag = get_bits1(gb);
354  if (sps->residual_color_transform_flag) {
355  av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
356  goto fail;
357  }
358  }
359  sps->bit_depth_luma = get_ue_golomb_31(gb) + 8;
360  sps->bit_depth_chroma = get_ue_golomb_31(gb) + 8;
361  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
362  avpriv_request_sample(avctx,
363  "Different chroma and luma bit depth");
364  goto fail;
365  }
366  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
367  sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
368  av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
369  sps->bit_depth_luma, sps->bit_depth_chroma);
370  goto fail;
371  }
372  sps->transform_bypass = get_bits1(gb);
374  &sps->scaling_matrix_present_mask,
375  sps->scaling_matrix4, sps->scaling_matrix8);
376  if (ret < 0)
377  goto fail;
378  sps->scaling_matrix_present |= ret;
379  } else {
380  sps->chroma_format_idc = 1;
381  sps->bit_depth_luma = 8;
382  sps->bit_depth_chroma = 8;
383  }
384 
385  log2_max_frame_num_minus4 = get_ue_golomb_31(gb);
386  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
387  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
388  av_log(avctx, AV_LOG_ERROR,
389  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
390  log2_max_frame_num_minus4);
391  goto fail;
392  }
393  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
394 
395  sps->poc_type = get_ue_golomb_31(gb);
396 
397  if (sps->poc_type == 0) { // FIXME #define
398  unsigned t = get_ue_golomb_31(gb);
399  if (t>12) {
400  av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
401  goto fail;
402  }
403  sps->log2_max_poc_lsb = t + 4;
404  } else if (sps->poc_type == 1) { // FIXME #define
405  sps->delta_pic_order_always_zero_flag = get_bits1(gb);
406  sps->offset_for_non_ref_pic = get_se_golomb_long(gb);
407  sps->offset_for_top_to_bottom_field = get_se_golomb_long(gb);
408 
409  if ( sps->offset_for_non_ref_pic == INT32_MIN
410  || sps->offset_for_top_to_bottom_field == INT32_MIN
411  ) {
412  av_log(avctx, AV_LOG_ERROR,
413  "offset_for_non_ref_pic or offset_for_top_to_bottom_field is out of range\n");
414  goto fail;
415  }
416 
417  sps->poc_cycle_length = get_ue_golomb(gb);
418 
419  if ((unsigned)sps->poc_cycle_length >=
420  FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
421  av_log(avctx, AV_LOG_ERROR,
422  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
423  goto fail;
424  }
425 
426  for (i = 0; i < sps->poc_cycle_length; i++) {
427  sps->offset_for_ref_frame[i] = get_se_golomb_long(gb);
428  if (sps->offset_for_ref_frame[i] == INT32_MIN) {
429  av_log(avctx, AV_LOG_ERROR,
430  "offset_for_ref_frame is out of range\n");
431  goto fail;
432  }
433  }
434  } else if (sps->poc_type != 2) {
435  av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
436  goto fail;
437  }
438 
439  sps->ref_frame_count = get_ue_golomb_31(gb);
440  if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
441  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
442  if (sps->ref_frame_count > H264_MAX_DPB_FRAMES) {
443  av_log(avctx, AV_LOG_ERROR,
444  "too many reference frames %d\n", sps->ref_frame_count);
445  goto fail;
446  }
447  sps->gaps_in_frame_num_allowed_flag = get_bits1(gb);
448  sps->mb_width = get_ue_golomb(gb) + 1;
449  sps->mb_height = get_ue_golomb(gb) + 1;
450 
451  sps->frame_mbs_only_flag = get_bits1(gb);
452 
453  if (sps->mb_height >= INT_MAX / 2U) {
454  av_log(avctx, AV_LOG_ERROR, "height overflow\n");
455  goto fail;
456  }
457  sps->mb_height *= 2 - sps->frame_mbs_only_flag;
458 
459  if (!sps->frame_mbs_only_flag)
460  sps->mb_aff = get_bits1(gb);
461  else
462  sps->mb_aff = 0;
463 
464  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
465  (unsigned)sps->mb_height >= INT_MAX / 16 ||
466  av_image_check_size(16 * sps->mb_width,
467  16 * sps->mb_height, 0, avctx)) {
468  av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
469  goto fail;
470  }
471 
472  sps->direct_8x8_inference_flag = get_bits1(gb);
473 
474  sps->crop = get_bits1(gb);
475  if (sps->crop) {
476  unsigned int crop_left = get_ue_golomb(gb);
477  unsigned int crop_right = get_ue_golomb(gb);
478  unsigned int crop_top = get_ue_golomb(gb);
479  unsigned int crop_bottom = get_ue_golomb(gb);
480  int width = 16 * sps->mb_width;
481  int height = 16 * sps->mb_height;
482 
483  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
484  av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
485  "values are l:%d r:%d t:%d b:%d\n",
486  crop_left, crop_right, crop_top, crop_bottom);
487 
488  sps->crop_left =
489  sps->crop_right =
490  sps->crop_top =
491  sps->crop_bottom = 0;
492  } else {
493  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
494  int hsub = (sps->chroma_format_idc == 1 ||
495  sps->chroma_format_idc == 2) ? 1 : 0;
496  int step_x = 1 << hsub;
497  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
498 
499  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
500  crop_right > (unsigned)INT_MAX / 4 / step_x ||
501  crop_top > (unsigned)INT_MAX / 4 / step_y ||
502  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
503  (crop_left + crop_right ) * step_x >= width ||
504  (crop_top + crop_bottom) * step_y >= height
505  ) {
506  av_log(avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
507  goto fail;
508  }
509 
510  sps->crop_left = crop_left * step_x;
511  sps->crop_right = crop_right * step_x;
512  sps->crop_top = crop_top * step_y;
513  sps->crop_bottom = crop_bottom * step_y;
514  }
515  } else {
516  sps->crop_left =
517  sps->crop_right =
518  sps->crop_top =
519  sps->crop_bottom =
520  sps->crop = 0;
521  }
522 
523  sps->vui_parameters_present_flag = get_bits1(gb);
524  if (sps->vui_parameters_present_flag) {
525  ret = decode_vui_parameters(gb, avctx, sps);
526  if (ret < 0)
527  goto fail;
528  }
529 
530  if (get_bits_left(gb) < 0) {
531  av_log_once(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR, AV_LOG_DEBUG,
532  &ps->overread_warning_printed[sps->vui_parameters_present_flag],
533  "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));
534  if (!ignore_truncation)
535  goto fail;
536  }
537 
538  /* if the maximum delay is not stored in the SPS, derive it based on the
539  * level */
540  if (!sps->bitstream_restriction_flag &&
541  (sps->ref_frame_count || avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT)) {
542  sps->num_reorder_frames = H264_MAX_DPB_FRAMES - 1;
543  for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
544  if (level_max_dpb_mbs[i][0] == sps->level_idc) {
545  sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
546  sps->num_reorder_frames);
547  break;
548  }
549  }
550  }
551 
552  if (!sps->vui.sar.den)
553  sps->vui.sar.den = 1;
554 
555  if (avctx->debug & FF_DEBUG_PICT_INFO) {
556  static const char csp[4][5] = { "Gray", "420", "422", "444" };
557  av_log(avctx, AV_LOG_DEBUG,
558  "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",
559  sps_id, sps->profile_idc, sps->level_idc,
560  sps->poc_type,
561  sps->ref_frame_count,
562  sps->mb_width, sps->mb_height,
563  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
564  sps->direct_8x8_inference_flag ? "8B8" : "",
565  sps->crop_left, sps->crop_right,
566  sps->crop_top, sps->crop_bottom,
567  sps->vui_parameters_present_flag ? "VUI" : "",
568  csp[sps->chroma_format_idc],
569  sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
570  sps->timing_info_present_flag ? sps->time_scale : 0,
571  sps->bit_depth_luma,
572  sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
573  );
574  }
575 
576  /* check if this is a repeat of an already parsed SPS, then keep the
577  * original one.
578  * otherwise drop all PPSes that depend on it */
579  if (ps->sps_list[sps_id] &&
580  !memcmp(ps->sps_list[sps_id], sps, sizeof(*sps))) {
582  } else {
583  remove_sps(ps, sps_id);
584  ps->sps_list[sps_id] = sps;
585  }
586 
587  return 0;
588 
589 fail:
591  return AVERROR_INVALIDDATA;
592 }
593 
594 static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
595 {
596  int i, j, q, x;
597  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
598 
599  for (i = 0; i < 6; i++) {
600  pps->dequant8_coeff[i] = pps->dequant8_buffer[i];
601  for (j = 0; j < i; j++)
602  if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],
603  64 * sizeof(uint8_t))) {
604  pps->dequant8_coeff[i] = pps->dequant8_buffer[j];
605  break;
606  }
607  if (j < i)
608  continue;
609 
610  for (q = 0; q < max_qp + 1; q++) {
611  int shift = ff_h264_quant_div6[q];
612  int idx = ff_h264_quant_rem6[q];
613  for (x = 0; x < 64; x++)
614  pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
615  ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
616  pps->scaling_matrix8[i][x]) << shift;
617  }
618  }
619 }
620 
621 static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
622 {
623  int i, j, q, x;
624  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
625  for (i = 0; i < 6; i++) {
626  pps->dequant4_coeff[i] = pps->dequant4_buffer[i];
627  for (j = 0; j < i; j++)
628  if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],
629  16 * sizeof(uint8_t))) {
630  pps->dequant4_coeff[i] = pps->dequant4_buffer[j];
631  break;
632  }
633  if (j < i)
634  continue;
635 
636  for (q = 0; q < max_qp + 1; q++) {
637  int shift = ff_h264_quant_div6[q] + 2;
638  int idx = ff_h264_quant_rem6[q];
639  for (x = 0; x < 16; x++)
640  pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
641  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
642  pps->scaling_matrix4[i][x]) << shift;
643  }
644  }
645 }
646 
647 static void init_dequant_tables(PPS *pps, const SPS *sps)
648 {
649  int i, x;
651  memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));
652 
653  if (pps->transform_8x8_mode)
655  if (sps->transform_bypass) {
656  for (i = 0; i < 6; i++)
657  for (x = 0; x < 16; x++)
658  pps->dequant4_coeff[i][0][x] = 1 << 6;
659  if (pps->transform_8x8_mode)
660  for (i = 0; i < 6; i++)
661  for (x = 0; x < 64; x++)
662  pps->dequant8_coeff[i][0][x] = 1 << 6;
663  }
664 }
665 
666 static void build_qp_table(PPS *pps, int t, int index, const int depth)
667 {
668  int i;
669  const int max_qp = 51 + 6 * (depth - 8);
670  for (i = 0; i < max_qp + 1; i++)
671  pps->chroma_qp_table[t][i] =
672  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
673 }
674 
675 static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
676 {
677  int profile_idc = sps->profile_idc;
678 
679  if ((profile_idc == 66 || profile_idc == 77 ||
680  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
681  av_log(logctx, AV_LOG_VERBOSE,
682  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
683  return 0;
684  }
685 
686  return 1;
687 }
688 
689 static void pps_free(FFRefStructOpaque unused, void *obj)
690 {
691  PPS *pps = obj;
692 
693  ff_refstruct_unref(&pps->sps);
694 }
695 
697  H264ParamSets *ps, int bit_length)
698 {
699  const SPS *sps;
700  unsigned int pps_id = get_ue_golomb(gb);
701  PPS *pps;
702  int qp_bd_offset;
703  int bits_left;
704  int ret;
705 
706  if (pps_id >= MAX_PPS_COUNT) {
707  av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
708  return AVERROR_INVALIDDATA;
709  }
710 
711  pps = ff_refstruct_alloc_ext(sizeof(*pps), 0, NULL, pps_free);
712  if (!pps)
713  return AVERROR(ENOMEM);
714 
715  pps->data_size = gb->buffer_end - gb->buffer;
716  if (pps->data_size > sizeof(pps->data)) {
717  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized PPS "
718  "(%"SIZE_SPECIFIER" > %"SIZE_SPECIFIER")\n",
719  pps->data_size, sizeof(pps->data));
720  pps->data_size = sizeof(pps->data);
721  }
722  memcpy(pps->data, gb->buffer, pps->data_size);
723 
724  // Re-add the removed stop bit (may be used by hwaccels).
725  if (!(bit_length & 7) && pps->data_size < sizeof(pps->data))
726  pps->data[pps->data_size++] = 0x80;
727 
728  pps->pps_id = pps_id;
729  pps->sps_id = get_ue_golomb_31(gb);
730  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
731  !ps->sps_list[pps->sps_id]) {
732  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
734  goto fail;
735  }
736  pps->sps = ff_refstruct_ref_c(ps->sps_list[pps->sps_id]);
737  sps = pps->sps;
738 
739  if (sps->bit_depth_luma > 14) {
740  av_log(avctx, AV_LOG_ERROR,
741  "Invalid luma bit depth=%d\n",
742  sps->bit_depth_luma);
744  goto fail;
745  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
747  "Unimplemented luma bit depth=%d",
748  sps->bit_depth_luma);
750  goto fail;
751  }
752 
753  pps->cabac = get_bits1(gb);
754  pps->pic_order_present = get_bits1(gb);
755  pps->slice_group_count = get_ue_golomb(gb) + 1;
756  if (pps->slice_group_count > 1) {
757  pps->mb_slice_group_map_type = get_ue_golomb(gb);
758  avpriv_report_missing_feature(avctx, "FMO");
760  goto fail;
761  }
762  pps->ref_count[0] = get_ue_golomb(gb) + 1;
763  pps->ref_count[1] = get_ue_golomb(gb) + 1;
764  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
765  av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
767  goto fail;
768  }
769 
770  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
771 
772  pps->weighted_pred = get_bits1(gb);
773  pps->weighted_bipred_idc = get_bits(gb, 2);
774  pps->init_qp = get_se_golomb(gb) + 26U + qp_bd_offset;
775  pps->init_qs = get_se_golomb(gb) + 26U + qp_bd_offset;
776  pps->chroma_qp_index_offset[0] = get_se_golomb(gb);
777  if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {
779  goto fail;
780  }
781 
782  pps->deblocking_filter_parameters_present = get_bits1(gb);
783  pps->constrained_intra_pred = get_bits1(gb);
784  pps->redundant_pic_cnt_present = get_bits1(gb);
785 
786  pps->transform_8x8_mode = 0;
787  memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
788  sizeof(pps->scaling_matrix4));
789  memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
790  sizeof(pps->scaling_matrix8));
791 
792  bits_left = bit_length - get_bits_count(gb);
793  if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
794  pps->transform_8x8_mode = get_bits1(gb);
795  pps->pic_scaling_matrix_present_flag = get_bits1(gb);
797  pps->pic_scaling_matrix_present_flag,
798  &pps->pic_scaling_matrix_present_mask,
799  pps->scaling_matrix4, pps->scaling_matrix8);
800  if (ret < 0)
801  goto fail;
802  // second_chroma_qp_index_offset
803  pps->chroma_qp_index_offset[1] = get_se_golomb(gb);
804  if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {
806  goto fail;
807  }
808  } else {
809  pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
810  }
811 
812  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
813  sps->bit_depth_luma);
814  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
815  sps->bit_depth_luma);
816 
818 
819  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
820  pps->chroma_qp_diff = 1;
821 
822  if (avctx->debug & FF_DEBUG_PICT_INFO) {
823  av_log(avctx, AV_LOG_DEBUG,
824  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
825  pps_id, pps->sps_id,
826  pps->cabac ? "CABAC" : "CAVLC",
827  pps->slice_group_count,
828  pps->ref_count[0], pps->ref_count[1],
829  pps->weighted_pred ? "weighted" : "",
830  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
831  pps->deblocking_filter_parameters_present ? "LPAR" : "",
832  pps->constrained_intra_pred ? "CONSTR" : "",
833  pps->redundant_pic_cnt_present ? "REDU" : "",
834  pps->transform_8x8_mode ? "8x8DCT" : "");
835  }
836 
837  remove_pps(ps, pps_id);
838  ps->pps_list[pps_id] = pps;
839 
840  return 0;
841 
842 fail:
844  return ret;
845 }
H264ParamSets::sps_list
const SPS * sps_list[MAX_SPS_COUNT]
RefStruct references.
Definition: h264_ps.h:145
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
H264ParamSets::sps
const SPS * sps
ordinary pointer, no RefStruct reference
Definition: h264_ps.h:150
av_clip
#define av_clip
Definition: common.h:100
show_bits1
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:408
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_h264_ps_uninit
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:270
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
ff_h264_chroma_qp
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
Definition: h264data.c:203
ff_refstruct_alloc_ext
static void * ff_refstruct_alloc_ext(size_t size, unsigned flags, void *opaque, void(*free_cb)(FFRefStructOpaque opaque, void *obj))
A wrapper around ff_refstruct_alloc_ext_c() for the common case of a non-const qualified opaque.
Definition: refstruct.h:94
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
mask
int mask
Definition: mediacodecdec_common.c:154
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:111
H264ParamSets::pps_list
const PPS * pps_list[MAX_PPS_COUNT]
RefStruct references.
Definition: h264_ps.h:146
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
level_idc
int level_idc
Definition: h264_levels.c:29
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
init_dequant_tables
static void init_dequant_tables(PPS *pps, const SPS *sps)
Definition: h264_ps.c:647
FFRefStructOpaque
RefStruct is an API for creating reference-counted objects with minimal overhead.
Definition: refstruct.h:58
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1407
AV_CODEC_FLAG2_IGNORE_CROP
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:375
hsub
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:74
ff_h264_decode_picture_parameter_set
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:696
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
golomb.h
exp golomb vlc stuff
remove_pps
static void remove_pps(H264ParamSets *s, int id)
Definition: h264_ps.c:87
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
fail
#define fail()
Definition: checkasm.h:193
GetBitContext
Definition: get_bits.h:108
refstruct.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_refstruct_ref_c
const void * ff_refstruct_ref_c(const void *obj)
Analog of ff_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
s
#define s(width, name)
Definition: cbs_vp9.c:198
H264ParamSets::overread_warning_printed
int overread_warning_printed[2]
Definition: h264_ps.h:152
h264data.h
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
if
if(ret)
Definition: filter_design.txt:179
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
NULL
#define NULL
Definition: coverity.c:32
bits_left
#define bits_left
Definition: bitstream.h:114
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
profile_idc
int profile_idc
Definition: h264_levels.c:53
more_rbsp_data_in_pps
static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
Definition: h264_ps.c:675
ff_h264_dequant8_coeff_init_scan
const uint8_t ff_h264_dequant8_coeff_init_scan[16]
Definition: h264data.c:161
SPS
Sequence parameter set.
Definition: h264_ps.h:44
decode_scaling_list
static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size, const uint8_t *jvt_list, const uint8_t *fallback_list, uint16_t *mask, int pos)
Definition: h264_ps.c:201
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
PPS
Picture parameter set.
Definition: h264_ps.h:110
mathops.h
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
level_max_dpb_mbs
static const int level_max_dpb_mbs[][2]
Definition: h264_ps.c:68
h264_ps.h
index
int index
Definition: gxfenc.c:90
decode_hrd_parameters
static int decode_hrd_parameters(GetBitContext *gb, void *logctx, SPS *sps)
Definition: h264_ps.c:106
pps_free
static void pps_free(FFRefStructOpaque unused, void *obj)
Definition: h264_ps.c:689
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:515
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
ff_h264_dequant8_coeff_init
const uint8_t ff_h264_dequant8_coeff_init[6][6]
Definition: h264data.c:165
height
#define height
Definition: dsp.h:85
shift
static int shift(int a, int b)
Definition: bonk.c:261
size
int size
Definition: twinvq_data.h:10344
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
remove_sps
static void remove_sps(H264ParamSets *s, int id)
Definition: h264_ps.c:92
init_dequant8_coeff_table
static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
Definition: h264_ps.c:594
MAX_LOG2_MAX_FRAME_NUM
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
ff_h264_quant_rem6
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
decode_vui_parameters
static int decode_vui_parameters(GetBitContext *gb, void *logctx, SPS *sps)
Definition: h264_ps.c:133
MIN_LOG2_MAX_FRAME_NUM
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:39
default_scaling4
static const uint8_t default_scaling4[2][16]
Definition: h264_ps.c:41
ff_h264_decode_seq_parameter_set
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:284
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
decode_scaling_matrices
static int decode_scaling_matrices(GetBitContext *gb, const SPS *sps, const PPS *pps, int is_sps, int present_flag, uint16_t *mask, uint8_t(*scaling_matrix4)[16], uint8_t(*scaling_matrix8)[64])
Definition: h264_ps.c:231
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:643
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:109
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ret
ret
Definition: filter_design.txt:187
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
h2645_vui.h
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
ff_h2645_decode_common_vui_params
void ff_h2645_decode_common_vui_params(GetBitContext *gb, H2645VUI *vui, void *logctx)
Definition: h2645_vui.c:37
default_scaling8
static const uint8_t default_scaling8[2][64]
Definition: h264_ps.c:48
pos
unsigned int pos
Definition: spdifenc.c:414
build_qp_table
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:666
U
#define U(x)
Definition: vpx_arith.h:37
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AVCodecContext
main external API structure.
Definition: avcodec.h:451
ff_h264_dequant4_coeff_init
const uint8_t ff_h264_dequant4_coeff_init[6][3]
Definition: h264data.c:152
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
H264ParamSets
Definition: h264_ps.h:144
pps
uint64_t pps
Definition: dovi_rpuenc.c:35
MAX_SPS_COUNT
#define MAX_SPS_COUNT
Definition: h264_ps.h:37
ff_h264_quant_div6
const uint8_t ff_h264_quant_div6[QP_MAX_NUM+1]
Definition: h264data.c:182
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1406
av_log_once
void av_log_once(void *avcl, int initial_level, int subsequent_level, int *state, const char *fmt,...)
Definition: log.c:422
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
init_dequant4_coeff_table
static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
Definition: h264_ps.c:621
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:476
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
H264ParamSets::pps
const PPS * pps
RefStruct reference.
Definition: h264_ps.h:149
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
width
#define width
Definition: dsp.h:85
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120