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 "internal.h"
32 #include "mathops.h"
33 #include "avcodec.h"
34 #include "h264data.h"
35 #include "h264_ps.h"
36 #include "golomb.h"
37 
38 #define MIN_LOG2_MAX_FRAME_NUM 4
39 
40 #define EXTENDED_SAR 255
41 
42 static const uint8_t default_scaling4[2][16] = {
43  { 6, 13, 20, 28, 13, 20, 28, 32,
44  20, 28, 32, 37, 28, 32, 37, 42 },
45  { 10, 14, 20, 24, 14, 20, 24, 27,
46  20, 24, 27, 30, 24, 27, 30, 34 }
47 };
48 
49 static const uint8_t default_scaling8[2][64] = {
50  { 6, 10, 13, 16, 18, 23, 25, 27,
51  10, 11, 16, 18, 23, 25, 27, 29,
52  13, 16, 18, 23, 25, 27, 29, 31,
53  16, 18, 23, 25, 27, 29, 31, 33,
54  18, 23, 25, 27, 29, 31, 33, 36,
55  23, 25, 27, 29, 31, 33, 36, 38,
56  25, 27, 29, 31, 33, 36, 38, 40,
57  27, 29, 31, 33, 36, 38, 40, 42 },
58  { 9, 13, 15, 17, 19, 21, 22, 24,
59  13, 13, 17, 19, 21, 22, 24, 25,
60  15, 17, 19, 21, 22, 24, 25, 27,
61  17, 19, 21, 22, 24, 25, 27, 28,
62  19, 21, 22, 24, 25, 27, 28, 30,
63  21, 22, 24, 25, 27, 28, 30, 32,
64  22, 24, 25, 27, 28, 30, 32, 33,
65  24, 25, 27, 28, 30, 32, 33, 35 }
66 };
67 
68 /* maximum number of MBs in the DPB for a given level */
69 static const int level_max_dpb_mbs[][2] = {
70  { 10, 396 },
71  { 11, 900 },
72  { 12, 2376 },
73  { 13, 2376 },
74  { 20, 2376 },
75  { 21, 4752 },
76  { 22, 8100 },
77  { 30, 8100 },
78  { 31, 18000 },
79  { 32, 20480 },
80  { 40, 32768 },
81  { 41, 32768 },
82  { 42, 34816 },
83  { 50, 110400 },
84  { 51, 184320 },
85  { 52, 184320 },
86 };
87 
88 static void remove_pps(H264ParamSets *s, int id)
89 {
90  av_buffer_unref(&s->pps_list[id]);
91 }
92 
93 static void remove_sps(H264ParamSets *s, int id)
94 {
95 #if 0
96  int i;
97  if (s->sps_list[id]) {
98  /* drop all PPS that depend on this SPS */
99  for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
100  if (s->pps_list[i] && ((PPS*)s->pps_list[i]->data)->sps_id == id)
101  remove_pps(s, i);
102  }
103 #endif
104  av_buffer_unref(&s->sps_list[id]);
105 }
106 
107 static inline int decode_hrd_parameters(GetBitContext *gb, void *logctx,
108  SPS *sps)
109 {
110  int cpb_count, i;
111  cpb_count = get_ue_golomb_31(gb) + 1;
112 
113  if (cpb_count > 32U) {
114  av_log(logctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
115  return AVERROR_INVALIDDATA;
116  }
117 
118  get_bits(gb, 4); /* bit_rate_scale */
119  get_bits(gb, 4); /* cpb_size_scale */
120  for (i = 0; i < cpb_count; i++) {
121  get_ue_golomb_long(gb); /* bit_rate_value_minus1 */
122  get_ue_golomb_long(gb); /* cpb_size_value_minus1 */
123  get_bits1(gb); /* cbr_flag */
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  int aspect_ratio_info_present_flag;
137  unsigned int aspect_ratio_idc;
138 
139  aspect_ratio_info_present_flag = get_bits1(gb);
140 
141  if (aspect_ratio_info_present_flag) {
142  aspect_ratio_idc = get_bits(gb, 8);
143  if (aspect_ratio_idc == EXTENDED_SAR) {
144  sps->sar.num = get_bits(gb, 16);
145  sps->sar.den = get_bits(gb, 16);
146  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
147  sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
148  } else {
149  av_log(logctx, AV_LOG_ERROR, "illegal aspect ratio\n");
150  return AVERROR_INVALIDDATA;
151  }
152  } else {
153  sps->sar.num =
154  sps->sar.den = 0;
155  }
156 
157  if (get_bits1(gb)) /* overscan_info_present_flag */
158  get_bits1(gb); /* overscan_appropriate_flag */
159 
162  get_bits(gb, 3); /* video_format */
163  sps->full_range = get_bits1(gb); /* video_full_range_flag */
164 
167  sps->color_primaries = get_bits(gb, 8); /* colour_primaries */
168  sps->color_trc = get_bits(gb, 8); /* transfer_characteristics */
169  sps->colorspace = get_bits(gb, 8); /* matrix_coefficients */
170 
171  // Set invalid values to "unspecified"
176  if (!av_color_space_name(sps->colorspace))
178  }
179  }
180 
181  /* chroma_location_info_present_flag */
182  if (get_bits1(gb)) {
183  /* chroma_sample_location_type_top_field */
184  sps->chroma_location = get_ue_golomb(gb) + 1;
185  get_ue_golomb(gb); /* chroma_sample_location_type_bottom_field */
186  } else
188 
189  if (show_bits1(gb) && get_bits_left(gb) < 10) {
190  av_log(logctx, AV_LOG_WARNING, "Truncated VUI (%d)\n", get_bits_left(gb));
191  return 0;
192  }
193 
195  if (sps->timing_info_present_flag) {
196  unsigned num_units_in_tick = get_bits_long(gb, 32);
197  unsigned time_scale = get_bits_long(gb, 32);
198  if (!num_units_in_tick || !time_scale) {
199  av_log(logctx, AV_LOG_ERROR,
200  "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
201  time_scale, num_units_in_tick);
202  sps->timing_info_present_flag = 0;
203  } else {
204  sps->num_units_in_tick = num_units_in_tick;
205  sps->time_scale = time_scale;
206  }
207  sps->fixed_frame_rate_flag = get_bits1(gb);
208  }
209 
212  if (decode_hrd_parameters(gb, logctx, sps) < 0)
213  return AVERROR_INVALIDDATA;
216  if (decode_hrd_parameters(gb, logctx, sps) < 0)
217  return AVERROR_INVALIDDATA;
220  get_bits1(gb); /* low_delay_hrd_flag */
222  if (!get_bits_left(gb))
223  return 0;
225  if (sps->bitstream_restriction_flag) {
226  get_bits1(gb); /* motion_vectors_over_pic_boundaries_flag */
227  get_ue_golomb(gb); /* max_bytes_per_pic_denom */
228  get_ue_golomb(gb); /* max_bits_per_mb_denom */
229  get_ue_golomb(gb); /* log2_max_mv_length_horizontal */
230  get_ue_golomb(gb); /* log2_max_mv_length_vertical */
232  get_ue_golomb(gb); /*max_dec_frame_buffering*/
233 
234  if (get_bits_left(gb) < 0) {
235  sps->num_reorder_frames = 0;
237  }
238 
239  if (sps->num_reorder_frames > 16U
240  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
241  av_log(logctx, AV_LOG_ERROR,
242  "Clipping illegal num_reorder_frames %d\n",
243  sps->num_reorder_frames);
244  sps->num_reorder_frames = 16;
245  return AVERROR_INVALIDDATA;
246  }
247  }
248 
249  return 0;
250 }
251 
252 static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
253  const uint8_t *jvt_list,
254  const uint8_t *fallback_list)
255 {
256  int i, last = 8, next = 8;
257  const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
258  if (!get_bits1(gb)) /* matrix not written, we use the predicted one */
259  memcpy(factors, fallback_list, size * sizeof(uint8_t));
260  else
261  for (i = 0; i < size; i++) {
262  if (next) {
263  int v = get_se_golomb(gb);
264  if (v < -128 || v > 127) {
265  av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);
266  return AVERROR_INVALIDDATA;
267  }
268  next = (last + v) & 0xff;
269  }
270  if (!i && !next) { /* matrix not written, we use the preset one */
271  memcpy(factors, jvt_list, size * sizeof(uint8_t));
272  break;
273  }
274  last = factors[scan[i]] = next ? next : last;
275  }
276  return 0;
277 }
278 
279 /* returns non zero if the provided SPS scaling matrix has been filled */
281  const PPS *pps, int is_sps,
282  uint8_t(*scaling_matrix4)[16],
283  uint8_t(*scaling_matrix8)[64])
284 {
285  int fallback_sps = !is_sps && sps->scaling_matrix_present;
286  const uint8_t *fallback[4] = {
287  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
288  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
289  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
290  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
291  };
292  int ret = 0;
293  if (get_bits1(gb)) {
294  ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
295  ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
296  ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
297  ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
298  ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
299  ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
300  if (is_sps || pps->transform_8x8_mode) {
301  ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
302  ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
303  if (sps->chroma_format_idc == 3) {
304  ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
305  ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
306  ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
307  ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
308  }
309  }
310  if (!ret)
311  ret = is_sps;
312  }
313 
314  return ret;
315 }
316 
318 {
319  int i;
320 
321  for (i = 0; i < MAX_SPS_COUNT; i++)
322  av_buffer_unref(&ps->sps_list[i]);
323 
324  for (i = 0; i < MAX_PPS_COUNT; i++)
325  av_buffer_unref(&ps->pps_list[i]);
326 
327  av_buffer_unref(&ps->sps_ref);
328  av_buffer_unref(&ps->pps_ref);
329 
330  ps->pps = NULL;
331  ps->sps = NULL;
332 }
333 
335  H264ParamSets *ps, int ignore_truncation)
336 {
337  AVBufferRef *sps_buf;
338  int profile_idc, level_idc, constraint_set_flags = 0;
339  unsigned int sps_id;
340  int i, log2_max_frame_num_minus4;
341  SPS *sps;
342  int ret;
343 
344  sps_buf = av_buffer_allocz(sizeof(*sps));
345  if (!sps_buf)
346  return AVERROR(ENOMEM);
347  sps = (SPS*)sps_buf->data;
348 
349  sps->data_size = gb->buffer_end - gb->buffer;
350  if (sps->data_size > sizeof(sps->data)) {
351  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized SPS\n");
352  sps->data_size = sizeof(sps->data);
353  }
354  memcpy(sps->data, gb->buffer, sps->data_size);
355 
356  profile_idc = get_bits(gb, 8);
357  constraint_set_flags |= get_bits1(gb) << 0; // constraint_set0_flag
358  constraint_set_flags |= get_bits1(gb) << 1; // constraint_set1_flag
359  constraint_set_flags |= get_bits1(gb) << 2; // constraint_set2_flag
360  constraint_set_flags |= get_bits1(gb) << 3; // constraint_set3_flag
361  constraint_set_flags |= get_bits1(gb) << 4; // constraint_set4_flag
362  constraint_set_flags |= get_bits1(gb) << 5; // constraint_set5_flag
363  skip_bits(gb, 2); // reserved_zero_2bits
364  level_idc = get_bits(gb, 8);
365  sps_id = get_ue_golomb_31(gb);
366 
367  if (sps_id >= MAX_SPS_COUNT) {
368  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
369  goto fail;
370  }
371 
372  sps->sps_id = sps_id;
373  sps->time_offset_length = 24;
374  sps->profile_idc = profile_idc;
375  sps->constraint_set_flags = constraint_set_flags;
376  sps->level_idc = level_idc;
377  sps->full_range = -1;
378 
379  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
380  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
381  sps->scaling_matrix_present = 0;
382  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
383 
384  if (sps->profile_idc == 100 || // High profile
385  sps->profile_idc == 110 || // High10 profile
386  sps->profile_idc == 122 || // High422 profile
387  sps->profile_idc == 244 || // High444 Predictive profile
388  sps->profile_idc == 44 || // Cavlc444 profile
389  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
390  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
391  sps->profile_idc == 118 || // Stereo High profile (MVC)
392  sps->profile_idc == 128 || // Multiview High profile (MVC)
393  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
394  sps->profile_idc == 144) { // old High444 profile
396  if (sps->chroma_format_idc > 3U) {
397  avpriv_request_sample(avctx, "chroma_format_idc %u",
398  sps->chroma_format_idc);
399  goto fail;
400  } else if (sps->chroma_format_idc == 3) {
403  av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
404  goto fail;
405  }
406  }
407  sps->bit_depth_luma = get_ue_golomb(gb) + 8;
408  sps->bit_depth_chroma = get_ue_golomb(gb) + 8;
409  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
410  avpriv_request_sample(avctx,
411  "Different chroma and luma bit depth");
412  goto fail;
413  }
414  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
415  sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
416  av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
417  sps->bit_depth_luma, sps->bit_depth_chroma);
418  goto fail;
419  }
420  sps->transform_bypass = get_bits1(gb);
421  ret = decode_scaling_matrices(gb, sps, NULL, 1,
422  sps->scaling_matrix4, sps->scaling_matrix8);
423  if (ret < 0)
424  goto fail;
425  sps->scaling_matrix_present |= ret;
426  } else {
427  sps->chroma_format_idc = 1;
428  sps->bit_depth_luma = 8;
429  sps->bit_depth_chroma = 8;
430  }
431 
432  log2_max_frame_num_minus4 = get_ue_golomb(gb);
433  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
434  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
435  av_log(avctx, AV_LOG_ERROR,
436  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
437  log2_max_frame_num_minus4);
438  goto fail;
439  }
440  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
441 
442  sps->poc_type = get_ue_golomb_31(gb);
443 
444  if (sps->poc_type == 0) { // FIXME #define
445  unsigned t = get_ue_golomb(gb);
446  if (t>12) {
447  av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
448  goto fail;
449  }
450  sps->log2_max_poc_lsb = t + 4;
451  } else if (sps->poc_type == 1) { // FIXME #define
455 
456  if ( sps->offset_for_non_ref_pic == INT32_MIN
457  || sps->offset_for_top_to_bottom_field == INT32_MIN
458  ) {
459  av_log(avctx, AV_LOG_ERROR,
460  "offset_for_non_ref_pic or offset_for_top_to_bottom_field is out of range\n");
461  goto fail;
462  }
463 
464  sps->poc_cycle_length = get_ue_golomb(gb);
465 
466  if ((unsigned)sps->poc_cycle_length >=
468  av_log(avctx, AV_LOG_ERROR,
469  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
470  goto fail;
471  }
472 
473  for (i = 0; i < sps->poc_cycle_length; i++) {
475  if (sps->offset_for_ref_frame[i] == INT32_MIN) {
476  av_log(avctx, AV_LOG_ERROR,
477  "offset_for_ref_frame is out of range\n");
478  goto fail;
479  }
480  }
481  } else if (sps->poc_type != 2) {
482  av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
483  goto fail;
484  }
485 
487  if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
488  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
490  av_log(avctx, AV_LOG_ERROR,
491  "too many reference frames %d\n", sps->ref_frame_count);
492  goto fail;
493  }
495  sps->mb_width = get_ue_golomb(gb) + 1;
496  sps->mb_height = get_ue_golomb(gb) + 1;
497 
498  sps->frame_mbs_only_flag = get_bits1(gb);
499 
500  if (sps->mb_height >= INT_MAX / 2U) {
501  av_log(avctx, AV_LOG_ERROR, "height overflow\n");
502  goto fail;
503  }
504  sps->mb_height *= 2 - sps->frame_mbs_only_flag;
505 
506  if (!sps->frame_mbs_only_flag)
507  sps->mb_aff = get_bits1(gb);
508  else
509  sps->mb_aff = 0;
510 
511  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
512  (unsigned)sps->mb_height >= INT_MAX / 16 ||
513  av_image_check_size(16 * sps->mb_width,
514  16 * sps->mb_height, 0, avctx)) {
515  av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
516  goto fail;
517  }
518 
520 
521 #ifndef ALLOW_INTERLACE
522  if (sps->mb_aff)
523  av_log(avctx, AV_LOG_ERROR,
524  "MBAFF support not included; enable it at compile-time.\n");
525 #endif
526  sps->crop = get_bits1(gb);
527  if (sps->crop) {
528  unsigned int crop_left = get_ue_golomb(gb);
529  unsigned int crop_right = get_ue_golomb(gb);
530  unsigned int crop_top = get_ue_golomb(gb);
531  unsigned int crop_bottom = get_ue_golomb(gb);
532  int width = 16 * sps->mb_width;
533  int height = 16 * sps->mb_height;
534 
535  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
536  av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
537  "values are l:%d r:%d t:%d b:%d\n",
538  crop_left, crop_right, crop_top, crop_bottom);
539 
540  sps->crop_left =
541  sps->crop_right =
542  sps->crop_top =
543  sps->crop_bottom = 0;
544  } else {
545  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
546  int hsub = (sps->chroma_format_idc == 1 ||
547  sps->chroma_format_idc == 2) ? 1 : 0;
548  int step_x = 1 << hsub;
549  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
550 
551  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
552  crop_right > (unsigned)INT_MAX / 4 / step_x ||
553  crop_top > (unsigned)INT_MAX / 4 / step_y ||
554  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
555  (crop_left + crop_right ) * step_x >= width ||
556  (crop_top + crop_bottom) * step_y >= height
557  ) {
558  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);
559  goto fail;
560  }
561 
562  sps->crop_left = crop_left * step_x;
563  sps->crop_right = crop_right * step_x;
564  sps->crop_top = crop_top * step_y;
565  sps->crop_bottom = crop_bottom * step_y;
566  }
567  } else {
568  sps->crop_left =
569  sps->crop_right =
570  sps->crop_top =
571  sps->crop_bottom =
572  sps->crop = 0;
573  }
574 
576  if (sps->vui_parameters_present_flag) {
577  int ret = decode_vui_parameters(gb, avctx, sps);
578  if (ret < 0)
579  goto fail;
580  }
581 
582  if (get_bits_left(gb) < 0) {
583  av_log_once(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR, AV_LOG_DEBUG,
585  "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));
586  if (!ignore_truncation)
587  goto fail;
588  }
589 
590  /* if the maximum delay is not stored in the SPS, derive it based on the
591  * level */
592  if (!sps->bitstream_restriction_flag &&
595  for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
596  if (level_max_dpb_mbs[i][0] == sps->level_idc) {
597  sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
598  sps->num_reorder_frames);
599  break;
600  }
601  }
602  }
603 
604  if (!sps->sar.den)
605  sps->sar.den = 1;
606 
607  if (avctx->debug & FF_DEBUG_PICT_INFO) {
608  static const char csp[4][5] = { "Gray", "420", "422", "444" };
609  av_log(avctx, AV_LOG_DEBUG,
610  "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",
611  sps_id, sps->profile_idc, sps->level_idc,
612  sps->poc_type,
613  sps->ref_frame_count,
614  sps->mb_width, sps->mb_height,
615  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
616  sps->direct_8x8_inference_flag ? "8B8" : "",
617  sps->crop_left, sps->crop_right,
618  sps->crop_top, sps->crop_bottom,
619  sps->vui_parameters_present_flag ? "VUI" : "",
620  csp[sps->chroma_format_idc],
622  sps->timing_info_present_flag ? sps->time_scale : 0,
623  sps->bit_depth_luma,
625  );
626  }
627 
628  /* check if this is a repeat of an already parsed SPS, then keep the
629  * original one.
630  * otherwise drop all PPSes that depend on it */
631  if (ps->sps_list[sps_id] &&
632  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
633  av_buffer_unref(&sps_buf);
634  } else {
635  remove_sps(ps, sps_id);
636  ps->sps_list[sps_id] = sps_buf;
637  }
638 
639  return 0;
640 
641 fail:
642  av_buffer_unref(&sps_buf);
643  return AVERROR_INVALIDDATA;
644 }
645 
646 static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
647 {
648  int i, j, q, x;
649  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
650 
651  for (i = 0; i < 6; i++) {
652  pps->dequant8_coeff[i] = pps->dequant8_buffer[i];
653  for (j = 0; j < i; j++)
654  if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],
655  64 * sizeof(uint8_t))) {
656  pps->dequant8_coeff[i] = pps->dequant8_buffer[j];
657  break;
658  }
659  if (j < i)
660  continue;
661 
662  for (q = 0; q < max_qp + 1; q++) {
663  int shift = ff_h264_quant_div6[q];
664  int idx = ff_h264_quant_rem6[q];
665  for (x = 0; x < 64; x++)
666  pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
667  ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
668  pps->scaling_matrix8[i][x]) << shift;
669  }
670  }
671 }
672 
673 static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
674 {
675  int i, j, q, x;
676  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
677  for (i = 0; i < 6; i++) {
678  pps->dequant4_coeff[i] = pps->dequant4_buffer[i];
679  for (j = 0; j < i; j++)
680  if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],
681  16 * sizeof(uint8_t))) {
682  pps->dequant4_coeff[i] = pps->dequant4_buffer[j];
683  break;
684  }
685  if (j < i)
686  continue;
687 
688  for (q = 0; q < max_qp + 1; q++) {
689  int shift = ff_h264_quant_div6[q] + 2;
690  int idx = ff_h264_quant_rem6[q];
691  for (x = 0; x < 16; x++)
692  pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
693  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
694  pps->scaling_matrix4[i][x]) << shift;
695  }
696  }
697 }
698 
699 static void init_dequant_tables(PPS *pps, const SPS *sps)
700 {
701  int i, x;
702  init_dequant4_coeff_table(pps, sps);
703  memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));
704 
705  if (pps->transform_8x8_mode)
706  init_dequant8_coeff_table(pps, sps);
707  if (sps->transform_bypass) {
708  for (i = 0; i < 6; i++)
709  for (x = 0; x < 16; x++)
710  pps->dequant4_coeff[i][0][x] = 1 << 6;
711  if (pps->transform_8x8_mode)
712  for (i = 0; i < 6; i++)
713  for (x = 0; x < 64; x++)
714  pps->dequant8_coeff[i][0][x] = 1 << 6;
715  }
716 }
717 
718 static void build_qp_table(PPS *pps, int t, int index, const int depth)
719 {
720  int i;
721  const int max_qp = 51 + 6 * (depth - 8);
722  for (i = 0; i < max_qp + 1; i++)
723  pps->chroma_qp_table[t][i] =
724  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
725 }
726 
727 static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
728 {
729  int profile_idc = sps->profile_idc;
730 
731  if ((profile_idc == 66 || profile_idc == 77 ||
732  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
733  av_log(logctx, AV_LOG_VERBOSE,
734  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
735  return 0;
736  }
737 
738  return 1;
739 }
740 
742  H264ParamSets *ps, int bit_length)
743 {
744  AVBufferRef *pps_buf;
745  const SPS *sps;
746  unsigned int pps_id = get_ue_golomb(gb);
747  PPS *pps;
748  int qp_bd_offset;
749  int bits_left;
750  int ret;
751 
752  if (pps_id >= MAX_PPS_COUNT) {
753  av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
754  return AVERROR_INVALIDDATA;
755  }
756 
757  pps_buf = av_buffer_allocz(sizeof(*pps));
758  if (!pps_buf)
759  return AVERROR(ENOMEM);
760  pps = (PPS*)pps_buf->data;
761 
762  pps->data_size = gb->buffer_end - gb->buffer;
763  if (pps->data_size > sizeof(pps->data)) {
764  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized PPS "
765  "(%"SIZE_SPECIFIER" > %"SIZE_SPECIFIER")\n",
766  pps->data_size, sizeof(pps->data));
767  pps->data_size = sizeof(pps->data);
768  }
769  memcpy(pps->data, gb->buffer, pps->data_size);
770 
771  pps->sps_id = get_ue_golomb_31(gb);
772  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
773  !ps->sps_list[pps->sps_id]) {
774  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
775  ret = AVERROR_INVALIDDATA;
776  goto fail;
777  }
778  sps = (const SPS*)ps->sps_list[pps->sps_id]->data;
779  if (sps->bit_depth_luma > 14) {
780  av_log(avctx, AV_LOG_ERROR,
781  "Invalid luma bit depth=%d\n",
782  sps->bit_depth_luma);
783  ret = AVERROR_INVALIDDATA;
784  goto fail;
785  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
787  "Unimplemented luma bit depth=%d",
788  sps->bit_depth_luma);
789  ret = AVERROR_PATCHWELCOME;
790  goto fail;
791  }
792 
793  pps->cabac = get_bits1(gb);
794  pps->pic_order_present = get_bits1(gb);
795  pps->slice_group_count = get_ue_golomb(gb) + 1;
796  if (pps->slice_group_count > 1) {
798  avpriv_report_missing_feature(avctx, "FMO");
799  ret = AVERROR_PATCHWELCOME;
800  goto fail;
801  }
802  pps->ref_count[0] = get_ue_golomb(gb) + 1;
803  pps->ref_count[1] = get_ue_golomb(gb) + 1;
804  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
805  av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
806  ret = AVERROR_INVALIDDATA;
807  goto fail;
808  }
809 
810  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
811 
812  pps->weighted_pred = get_bits1(gb);
813  pps->weighted_bipred_idc = get_bits(gb, 2);
814  pps->init_qp = get_se_golomb(gb) + 26U + qp_bd_offset;
815  pps->init_qs = get_se_golomb(gb) + 26U + qp_bd_offset;
817  if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {
818  ret = AVERROR_INVALIDDATA;
819  goto fail;
820  }
821 
825 
826  pps->transform_8x8_mode = 0;
827  memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
828  sizeof(pps->scaling_matrix4));
829  memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
830  sizeof(pps->scaling_matrix8));
831 
832  bits_left = bit_length - get_bits_count(gb);
833  if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
834  pps->transform_8x8_mode = get_bits1(gb);
835  ret = decode_scaling_matrices(gb, sps, pps, 0,
836  pps->scaling_matrix4, pps->scaling_matrix8);
837  if (ret < 0)
838  goto fail;
839  // second_chroma_qp_index_offset
841  if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {
842  ret = AVERROR_INVALIDDATA;
843  goto fail;
844  }
845  } else {
847  }
848 
849  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
850  sps->bit_depth_luma);
851  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
852  sps->bit_depth_luma);
853 
854  init_dequant_tables(pps, sps);
855 
856  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
857  pps->chroma_qp_diff = 1;
858 
859  if (avctx->debug & FF_DEBUG_PICT_INFO) {
860  av_log(avctx, AV_LOG_DEBUG,
861  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
862  pps_id, pps->sps_id,
863  pps->cabac ? "CABAC" : "CAVLC",
864  pps->slice_group_count,
865  pps->ref_count[0], pps->ref_count[1],
866  pps->weighted_pred ? "weighted" : "",
867  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
868  pps->deblocking_filter_parameters_present ? "LPAR" : "",
869  pps->constrained_intra_pred ? "CONSTR" : "",
870  pps->redundant_pic_cnt_present ? "REDU" : "",
871  pps->transform_8x8_mode ? "8x8DCT" : "");
872  }
873 
874  remove_pps(ps, pps_id);
875  ps->pps_list[pps_id] = pps_buf;
876 
877  return 0;
878 
879 fail:
880  av_buffer_unref(&pps_buf);
881  return ret;
882 }
int chroma_format_idc
Definition: h264_ps.h:48
int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int bit_length)
Decode PPS.
Definition: h264_ps.c:741
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:533
int video_signal_type_present_flag
Definition: h264_ps.h:74
static void remove_pps(H264ParamSets *s, int id)
Definition: h264_ps.c:88
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int shift(int a, int b)
Definition: sonic.c:82
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:126
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:556
#define MAX_SPS_COUNT
Definition: h264_ps.h:37
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int weighted_bipred_idc
Definition: h264_ps.h:119
int chroma_qp_index_offset[2]
Definition: h264_ps.h:122
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:141
int scaling_matrix_present
Definition: h264_ps.h:89
uint8_t scaling_matrix4[6][16]
Definition: h264_ps.h:90
#define avpriv_request_sample(...)
void av_log_once(void *avcl, int initial_level, int subsequent_level, int *state, const char *fmt,...)
Definition: log.c:415
Sequence parameter set.
Definition: h264_ps.h:44
int bitstream_restriction_flag
Definition: h264_ps.h:87
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:117
int num
Numerator.
Definition: rational.h:59
const uint8_t * buffer
Definition: get_bits.h:62
Picture parameter set.
Definition: h264_ps.h:111
int frame_mbs_only_flag
Definition: h264_ps.h:62
const uint8_t ff_h264_quant_rem6[QP_MAX_NUM+1]
Definition: h264data.c:174
int chroma_qp_diff
Definition: h264_ps.h:130
uint32_t num_units_in_tick
Definition: h264_ps.h:83
int profile_idc
Definition: h264_ps.h:46
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2942
int profile_idc
Definition: h264_levels.c:52
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264_ps.h:70
int fixed_frame_rate_flag
Definition: h264_ps.h:85
uint8_t scaling_matrix4[6][16]
Definition: h264_ps.h:127
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264_ps.h:123
static const AVRational ff_h264_pixel_aspect[17]
Definition: h264data.h:51
const uint8_t ff_h264_dequant4_coeff_init[6][3]
Definition: h264data.c:152
const PPS * pps
Definition: h264_ps.h:147
uint8_t
int full_range
Definition: h264_ps.h:75
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264_ps.h:68
int offset_for_non_ref_pic
Definition: h264_ps.h:54
int gaps_in_frame_num_allowed_flag
Definition: h264_ps.h:58
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264_ps.h:101
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2707
enum AVColorPrimaries color_primaries
Definition: h264_ps.h:77
int cabac
entropy_coding_mode_flag
Definition: h264_ps.h:113
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264_ps.h:69
int overread_warning_printed[2]
Definition: h264_ps.h:150
int level_idc
Definition: h264_levels.c:25
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264_ps.h:136
#define height
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264_ps.h:49
uint32_t(*[6] dequant8_coeff)[64]
Definition: h264_ps.h:137
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
static const int level_max_dpb_mbs[][2]
Definition: h264_ps.c:69
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264_ps.h:125
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
ptrdiff_t size
Definition: opengl_enc.c:100
#define av_log(a,...)
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
H.264 parameter set handling.
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264_ps.h:63
enum AVColorTransferCharacteristic color_trc
Definition: h264_ps.h:78
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AVBufferRef * sps_ref
Definition: h264_ps.h:145
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:964
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
int poc_type
pic_order_cnt_type
Definition: h264_ps.h:51
int constrained_intra_pred
constrained_intra_pred_flag
Definition: h264_ps.h:124
int num_reorder_frames
Definition: h264_ps.h:88
int time_offset_length
Definition: h264_ps.h:95
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int weighted_pred
weighted_pred_flag
Definition: h264_ps.h:118
static int decode_scaling_matrices(GetBitContext *gb, const SPS *sps, const PPS *pps, int is_sps, uint8_t(*scaling_matrix4)[16], uint8_t(*scaling_matrix8)[64])
Definition: h264_ps.c:280
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:38
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264_ps.h:102
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
int delta_pic_order_always_zero_flag
Definition: h264_ps.h:53
int offset_for_top_to_bottom_field
Definition: h264_ps.h:55
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:2894
static void remove_sps(H264ParamSets *s, int id)
Definition: h264_ps.c:93
static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
Definition: h264_ps.c:646
int crop
frame_cropping_flag
Definition: h264_ps.h:65
uint8_t scaling_matrix8[6][64]
Definition: h264_ps.h:128
size_t data_size
Definition: h264_ps.h:105
static int decode_vui_parameters(GetBitContext *gb, void *logctx, SPS *sps)
Definition: h264_ps.c:133
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:282
int ref_frame_count
num_ref_frames
Definition: h264_ps.h:57
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:97
uint8_t data[4096]
Definition: h264_ps.h:131
#define FFMIN(a, b)
Definition: common.h:96
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264_ps.h:56
int colour_description_present_flag
Definition: h264_ps.h:76
AVRational sar
Definition: h264_ps.h:73
#define width
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264_ps.h:129
#define s(width, name)
Definition: cbs_vp9.c:257
int init_qp
pic_init_qp_minus26 + 26
Definition: h264_ps.h:120
enum AVChromaLocation chroma_location
Definition: h264_ps.h:80
int direct_8x8_inference_flag
Definition: h264_ps.h:64
uint8_t scaling_matrix8[6][64]
Definition: h264_ps.h:91
static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size, const uint8_t *jvt_list, const uint8_t *fallback_list)
Definition: h264_ps.c:252
unsigned int sps_id
Definition: h264_ps.h:45
#define FF_ARRAY_ELEMS(a)
if(ret)
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:105
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int pic_order_present
pic_order_present_flag
Definition: h264_ps.h:114
static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
Definition: h264_ps.c:727
int timing_info_present_flag
Definition: h264_ps.h:82
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
int vcl_hrd_parameters_present_flag
Definition: h264_ps.h:93
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:142
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
int debug
debug
Definition: avcodec.h:2706
main external API structure.
Definition: avcodec.h:1621
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
Definition: h264data.c:203
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264_ps.h:99
uint8_t * data
The data buffer.
Definition: buffer.h:89
int vui_parameters_present_flag
Definition: h264_ps.h:72
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1646
static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
Definition: h264_ps.c:673
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:84
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264_ps.h:103
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
const uint8_t ff_h264_quant_div6[QP_MAX_NUM+1]
Definition: h264data.c:182
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
int index
Definition: gxfenc.c:89
#define EXTENDED_SAR
Definition: h264_ps.c:40
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:2686
const SPS * sps
Definition: h264_ps.h:148
static int decode_hrd_parameters(GetBitContext *gb, void *logctx, SPS *sps)
Definition: h264_ps.c:107
unsigned int sps_id
Definition: h264_ps.h:112
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:52
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
int size
Size of data in bytes.
Definition: buffer.h:93
uint32_t time_scale
Definition: h264_ps.h:84
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264_ps.h:126
#define SIZE_SPECIFIER
Definition: internal.h:262
int pic_struct_present_flag
Definition: h264_ps.h:94
const uint8_t ff_h264_dequant8_coeff_init[6][6]
Definition: h264data.c:165
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:39
A reference to a data buffer.
Definition: buffer.h:81
int mb_height
Definition: h264_ps.h:61
int init_qs
pic_init_qs_minus26 + 26
Definition: h264_ps.h:121
common internal api header.
uint8_t data[4096]
Definition: h264_ps.h:104
AVBufferRef * pps_ref
Definition: h264_ps.h:144
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:92
size_t data_size
Definition: h264_ps.h:132
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2918
const uint8_t * buffer_end
Definition: get_bits.h:62
static const uint8_t default_scaling4[2][16]
Definition: h264_ps.c:42
int den
Denominator.
Definition: rational.h:60
void ff_h264_ps_uninit(H264ParamSets *ps)
Uninit H264 param sets structure.
Definition: h264_ps.c:317
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:100
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:334
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264_ps.h:59
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1708
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264_ps.h:115
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:96
uint32_t dequant4_buffer[6][QP_MAX_NUM+1][16]
Definition: h264_ps.h:134
int32_t offset_for_ref_frame[256]
Definition: h264_ps.h:86
static const uint8_t default_scaling8[2][64]
Definition: h264_ps.c:49
uint32_t dequant8_buffer[6][QP_MAX_NUM+1][64]
Definition: h264_ps.h:135
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:98
static void init_dequant_tables(PPS *pps, const SPS *sps)
Definition: h264_ps.c:699
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264_ps.h:71
exp golomb vlc stuff
enum AVCodecID id
int level_idc
Definition: h264_ps.h:47
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2684
static void hsub(htype *dst, const htype *src, int bins)
Definition: vf_median.c:75
const uint8_t ff_h264_dequant8_coeff_init_scan[16]
Definition: h264data.c:161
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:718
int mb_slice_group_map_type
Definition: h264_ps.h:116
enum AVColorSpace colorspace
Definition: h264_ps.h:79