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, AVCodecContext *avctx,
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(avctx, 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, AVCodecContext *avctx,
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(avctx, 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  avctx->chroma_sample_location = get_ue_golomb(gb) + 1;
185  get_ue_golomb(gb); /* chroma_sample_location_type_bottom_field */
186  }
187 
188  if (show_bits1(gb) && get_bits_left(gb) < 10) {
189  av_log(avctx, AV_LOG_WARNING, "Truncated VUI\n");
190  return 0;
191  }
192 
194  if (sps->timing_info_present_flag) {
195  unsigned num_units_in_tick = get_bits_long(gb, 32);
196  unsigned time_scale = get_bits_long(gb, 32);
197  if (!num_units_in_tick || !time_scale) {
198  av_log(avctx, AV_LOG_ERROR,
199  "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
200  time_scale, num_units_in_tick);
201  sps->timing_info_present_flag = 0;
202  } else {
203  sps->num_units_in_tick = num_units_in_tick;
204  sps->time_scale = time_scale;
205  }
206  sps->fixed_frame_rate_flag = get_bits1(gb);
207  }
208 
211  if (decode_hrd_parameters(gb, avctx, sps) < 0)
212  return AVERROR_INVALIDDATA;
215  if (decode_hrd_parameters(gb, avctx, sps) < 0)
216  return AVERROR_INVALIDDATA;
219  get_bits1(gb); /* low_delay_hrd_flag */
221  if (!get_bits_left(gb))
222  return 0;
224  if (sps->bitstream_restriction_flag) {
225  get_bits1(gb); /* motion_vectors_over_pic_boundaries_flag */
226  get_ue_golomb(gb); /* max_bytes_per_pic_denom */
227  get_ue_golomb(gb); /* max_bits_per_mb_denom */
228  get_ue_golomb(gb); /* log2_max_mv_length_horizontal */
229  get_ue_golomb(gb); /* log2_max_mv_length_vertical */
231  get_ue_golomb(gb); /*max_dec_frame_buffering*/
232 
233  if (get_bits_left(gb) < 0) {
234  sps->num_reorder_frames = 0;
236  }
237 
238  if (sps->num_reorder_frames > 16U
239  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
240  av_log(avctx, AV_LOG_ERROR,
241  "Clipping illegal num_reorder_frames %d\n",
242  sps->num_reorder_frames);
243  sps->num_reorder_frames = 16;
244  return AVERROR_INVALIDDATA;
245  }
246  }
247 
248  return 0;
249 }
250 
251 static int decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
252  const uint8_t *jvt_list,
253  const uint8_t *fallback_list)
254 {
255  int i, last = 8, next = 8;
256  const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
257  if (!get_bits1(gb)) /* matrix not written, we use the predicted one */
258  memcpy(factors, fallback_list, size * sizeof(uint8_t));
259  else
260  for (i = 0; i < size; i++) {
261  if (next) {
262  int v = get_se_golomb(gb);
263  if (v < -128 || v > 127) {
264  av_log(NULL, AV_LOG_ERROR, "delta scale %d is invalid\n", v);
265  return AVERROR_INVALIDDATA;
266  }
267  next = (last + v) & 0xff;
268  }
269  if (!i && !next) { /* matrix not written, we use the preset one */
270  memcpy(factors, jvt_list, size * sizeof(uint8_t));
271  break;
272  }
273  last = factors[scan[i]] = next ? next : last;
274  }
275  return 0;
276 }
277 
278 /* returns non zero if the provided SPS scaling matrix has been filled */
280  const PPS *pps, int is_sps,
281  uint8_t(*scaling_matrix4)[16],
282  uint8_t(*scaling_matrix8)[64])
283 {
284  int fallback_sps = !is_sps && sps->scaling_matrix_present;
285  const uint8_t *fallback[4] = {
286  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
287  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
288  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
289  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
290  };
291  int ret = 0;
292  if (get_bits1(gb)) {
293  ret |= decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
294  ret |= decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
295  ret |= decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
296  ret |= decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
297  ret |= decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
298  ret |= decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
299  if (is_sps || pps->transform_8x8_mode) {
300  ret |= decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
301  ret |= decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
302  if (sps->chroma_format_idc == 3) {
303  ret |= decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
304  ret |= decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
305  ret |= decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
306  ret |= decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
307  }
308  }
309  if (!ret)
310  ret = is_sps;
311  }
312 
313  return ret;
314 }
315 
317 {
318  int i;
319 
320  for (i = 0; i < MAX_SPS_COUNT; i++)
321  av_buffer_unref(&ps->sps_list[i]);
322 
323  for (i = 0; i < MAX_PPS_COUNT; i++)
324  av_buffer_unref(&ps->pps_list[i]);
325 
326  av_buffer_unref(&ps->sps_ref);
327  av_buffer_unref(&ps->pps_ref);
328 
329  ps->pps = NULL;
330  ps->sps = NULL;
331 }
332 
334  H264ParamSets *ps, int ignore_truncation)
335 {
336  AVBufferRef *sps_buf;
337  int profile_idc, level_idc, constraint_set_flags = 0;
338  unsigned int sps_id;
339  int i, log2_max_frame_num_minus4;
340  SPS *sps;
341  int ret;
342 
343  sps_buf = av_buffer_allocz(sizeof(*sps));
344  if (!sps_buf)
345  return AVERROR(ENOMEM);
346  sps = (SPS*)sps_buf->data;
347 
348  sps->data_size = gb->buffer_end - gb->buffer;
349  if (sps->data_size > sizeof(sps->data)) {
350  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized SPS\n");
351  sps->data_size = sizeof(sps->data);
352  }
353  memcpy(sps->data, gb->buffer, sps->data_size);
354 
355  profile_idc = get_bits(gb, 8);
356  constraint_set_flags |= get_bits1(gb) << 0; // constraint_set0_flag
357  constraint_set_flags |= get_bits1(gb) << 1; // constraint_set1_flag
358  constraint_set_flags |= get_bits1(gb) << 2; // constraint_set2_flag
359  constraint_set_flags |= get_bits1(gb) << 3; // constraint_set3_flag
360  constraint_set_flags |= get_bits1(gb) << 4; // constraint_set4_flag
361  constraint_set_flags |= get_bits1(gb) << 5; // constraint_set5_flag
362  skip_bits(gb, 2); // reserved_zero_2bits
363  level_idc = get_bits(gb, 8);
364  sps_id = get_ue_golomb_31(gb);
365 
366  if (sps_id >= MAX_SPS_COUNT) {
367  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
368  goto fail;
369  }
370 
371  sps->sps_id = sps_id;
372  sps->time_offset_length = 24;
373  sps->profile_idc = profile_idc;
374  sps->constraint_set_flags = constraint_set_flags;
375  sps->level_idc = level_idc;
376  sps->full_range = -1;
377 
378  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
379  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
380  sps->scaling_matrix_present = 0;
381  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
382 
383  if (sps->profile_idc == 100 || // High profile
384  sps->profile_idc == 110 || // High10 profile
385  sps->profile_idc == 122 || // High422 profile
386  sps->profile_idc == 244 || // High444 Predictive profile
387  sps->profile_idc == 44 || // Cavlc444 profile
388  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
389  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
390  sps->profile_idc == 118 || // Stereo High profile (MVC)
391  sps->profile_idc == 128 || // Multiview High profile (MVC)
392  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
393  sps->profile_idc == 144) { // old High444 profile
395  if (sps->chroma_format_idc > 3U) {
396  avpriv_request_sample(avctx, "chroma_format_idc %u",
397  sps->chroma_format_idc);
398  goto fail;
399  } else if (sps->chroma_format_idc == 3) {
402  av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
403  goto fail;
404  }
405  }
406  sps->bit_depth_luma = get_ue_golomb(gb) + 8;
407  sps->bit_depth_chroma = get_ue_golomb(gb) + 8;
408  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
409  avpriv_request_sample(avctx,
410  "Different chroma and luma bit depth");
411  goto fail;
412  }
413  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
414  sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
415  av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
416  sps->bit_depth_luma, sps->bit_depth_chroma);
417  goto fail;
418  }
419  sps->transform_bypass = get_bits1(gb);
420  ret = decode_scaling_matrices(gb, sps, NULL, 1,
421  sps->scaling_matrix4, sps->scaling_matrix8);
422  if (ret < 0)
423  goto fail;
424  sps->scaling_matrix_present |= ret;
425  } else {
426  sps->chroma_format_idc = 1;
427  sps->bit_depth_luma = 8;
428  sps->bit_depth_chroma = 8;
429  }
430 
431  log2_max_frame_num_minus4 = get_ue_golomb(gb);
432  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
433  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
434  av_log(avctx, AV_LOG_ERROR,
435  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
436  log2_max_frame_num_minus4);
437  goto fail;
438  }
439  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
440 
441  sps->poc_type = get_ue_golomb_31(gb);
442 
443  if (sps->poc_type == 0) { // FIXME #define
444  unsigned t = get_ue_golomb(gb);
445  if (t>12) {
446  av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
447  goto fail;
448  }
449  sps->log2_max_poc_lsb = t + 4;
450  } else if (sps->poc_type == 1) { // FIXME #define
454 
455  if ( sps->offset_for_non_ref_pic == INT32_MIN
456  || sps->offset_for_top_to_bottom_field == INT32_MIN
457  ) {
458  av_log(avctx, AV_LOG_ERROR,
459  "offset_for_non_ref_pic or offset_for_top_to_bottom_field is out of range\n");
460  goto fail;
461  }
462 
463  sps->poc_cycle_length = get_ue_golomb(gb);
464 
465  if ((unsigned)sps->poc_cycle_length >=
467  av_log(avctx, AV_LOG_ERROR,
468  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
469  goto fail;
470  }
471 
472  for (i = 0; i < sps->poc_cycle_length; i++) {
474  if (sps->offset_for_ref_frame[i] == INT32_MIN) {
475  av_log(avctx, AV_LOG_ERROR,
476  "offset_for_ref_frame is out of range\n");
477  goto fail;
478  }
479  }
480  } else if (sps->poc_type != 2) {
481  av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
482  goto fail;
483  }
484 
486  if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
487  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
489  av_log(avctx, AV_LOG_ERROR,
490  "too many reference frames %d\n", sps->ref_frame_count);
491  goto fail;
492  }
494  sps->mb_width = get_ue_golomb(gb) + 1;
495  sps->mb_height = get_ue_golomb(gb) + 1;
496 
497  sps->frame_mbs_only_flag = get_bits1(gb);
498 
499  if (sps->mb_height >= INT_MAX / 2U) {
500  av_log(avctx, AV_LOG_ERROR, "height overflow\n");
501  goto fail;
502  }
503  sps->mb_height *= 2 - sps->frame_mbs_only_flag;
504 
505  if (!sps->frame_mbs_only_flag)
506  sps->mb_aff = get_bits1(gb);
507  else
508  sps->mb_aff = 0;
509 
510  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
511  (unsigned)sps->mb_height >= INT_MAX / 16 ||
512  av_image_check_size(16 * sps->mb_width,
513  16 * sps->mb_height, 0, avctx)) {
514  av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
515  goto fail;
516  }
517 
519 
520 #ifndef ALLOW_INTERLACE
521  if (sps->mb_aff)
522  av_log(avctx, AV_LOG_ERROR,
523  "MBAFF support not included; enable it at compile-time.\n");
524 #endif
525  sps->crop = get_bits1(gb);
526  if (sps->crop) {
527  unsigned int crop_left = get_ue_golomb(gb);
528  unsigned int crop_right = get_ue_golomb(gb);
529  unsigned int crop_top = get_ue_golomb(gb);
530  unsigned int crop_bottom = get_ue_golomb(gb);
531  int width = 16 * sps->mb_width;
532  int height = 16 * sps->mb_height;
533 
534  if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
535  av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
536  "values are l:%d r:%d t:%d b:%d\n",
537  crop_left, crop_right, crop_top, crop_bottom);
538 
539  sps->crop_left =
540  sps->crop_right =
541  sps->crop_top =
542  sps->crop_bottom = 0;
543  } else {
544  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
545  int hsub = (sps->chroma_format_idc == 1 ||
546  sps->chroma_format_idc == 2) ? 1 : 0;
547  int step_x = 1 << hsub;
548  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
549 
550  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
551  crop_right > (unsigned)INT_MAX / 4 / step_x ||
552  crop_top > (unsigned)INT_MAX / 4 / step_y ||
553  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
554  (crop_left + crop_right ) * step_x >= width ||
555  (crop_top + crop_bottom) * step_y >= height
556  ) {
557  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);
558  goto fail;
559  }
560 
561  sps->crop_left = crop_left * step_x;
562  sps->crop_right = crop_right * step_x;
563  sps->crop_top = crop_top * step_y;
564  sps->crop_bottom = crop_bottom * step_y;
565  }
566  } else {
567  sps->crop_left =
568  sps->crop_right =
569  sps->crop_top =
570  sps->crop_bottom =
571  sps->crop = 0;
572  }
573 
575  if (sps->vui_parameters_present_flag) {
576  int ret = decode_vui_parameters(gb, avctx, sps);
577  if (ret < 0)
578  goto fail;
579  }
580 
581  if (get_bits_left(gb) < 0) {
582  av_log(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
583  "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));
584  if (!ignore_truncation)
585  goto fail;
586  }
587 
588  /* if the maximum delay is not stored in the SPS, derive it based on the
589  * level */
590  if (!sps->bitstream_restriction_flag &&
593  for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
594  if (level_max_dpb_mbs[i][0] == sps->level_idc) {
595  sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
596  sps->num_reorder_frames);
597  break;
598  }
599  }
600  }
601 
602  if (!sps->sar.den)
603  sps->sar.den = 1;
604 
605  if (avctx->debug & FF_DEBUG_PICT_INFO) {
606  static const char csp[4][5] = { "Gray", "420", "422", "444" };
607  av_log(avctx, AV_LOG_DEBUG,
608  "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",
609  sps_id, sps->profile_idc, sps->level_idc,
610  sps->poc_type,
611  sps->ref_frame_count,
612  sps->mb_width, sps->mb_height,
613  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
614  sps->direct_8x8_inference_flag ? "8B8" : "",
615  sps->crop_left, sps->crop_right,
616  sps->crop_top, sps->crop_bottom,
617  sps->vui_parameters_present_flag ? "VUI" : "",
618  csp[sps->chroma_format_idc],
620  sps->timing_info_present_flag ? sps->time_scale : 0,
621  sps->bit_depth_luma,
623  );
624  }
625 
626  /* check if this is a repeat of an already parsed SPS, then keep the
627  * original one.
628  * otherwise drop all PPSes that depend on it */
629  if (ps->sps_list[sps_id] &&
630  !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
631  av_buffer_unref(&sps_buf);
632  } else {
633  remove_sps(ps, sps_id);
634  ps->sps_list[sps_id] = sps_buf;
635  }
636 
637  return 0;
638 
639 fail:
640  av_buffer_unref(&sps_buf);
641  return AVERROR_INVALIDDATA;
642 }
643 
644 static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
645 {
646  int i, j, q, x;
647  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
648 
649  for (i = 0; i < 6; i++) {
650  pps->dequant8_coeff[i] = pps->dequant8_buffer[i];
651  for (j = 0; j < i; j++)
652  if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],
653  64 * sizeof(uint8_t))) {
654  pps->dequant8_coeff[i] = pps->dequant8_buffer[j];
655  break;
656  }
657  if (j < i)
658  continue;
659 
660  for (q = 0; q < max_qp + 1; q++) {
661  int shift = ff_h264_quant_div6[q];
662  int idx = ff_h264_quant_rem6[q];
663  for (x = 0; x < 64; x++)
664  pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
665  ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
666  pps->scaling_matrix8[i][x]) << shift;
667  }
668  }
669 }
670 
671 static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
672 {
673  int i, j, q, x;
674  const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
675  for (i = 0; i < 6; i++) {
676  pps->dequant4_coeff[i] = pps->dequant4_buffer[i];
677  for (j = 0; j < i; j++)
678  if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],
679  16 * sizeof(uint8_t))) {
680  pps->dequant4_coeff[i] = pps->dequant4_buffer[j];
681  break;
682  }
683  if (j < i)
684  continue;
685 
686  for (q = 0; q < max_qp + 1; q++) {
687  int shift = ff_h264_quant_div6[q] + 2;
688  int idx = ff_h264_quant_rem6[q];
689  for (x = 0; x < 16; x++)
690  pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
691  ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
692  pps->scaling_matrix4[i][x]) << shift;
693  }
694  }
695 }
696 
697 static void init_dequant_tables(PPS *pps, const SPS *sps)
698 {
699  int i, x;
700  init_dequant4_coeff_table(pps, sps);
701  memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));
702 
703  if (pps->transform_8x8_mode)
704  init_dequant8_coeff_table(pps, sps);
705  if (sps->transform_bypass) {
706  for (i = 0; i < 6; i++)
707  for (x = 0; x < 16; x++)
708  pps->dequant4_coeff[i][0][x] = 1 << 6;
709  if (pps->transform_8x8_mode)
710  for (i = 0; i < 6; i++)
711  for (x = 0; x < 64; x++)
712  pps->dequant8_coeff[i][0][x] = 1 << 6;
713  }
714 }
715 
716 static void build_qp_table(PPS *pps, int t, int index, const int depth)
717 {
718  int i;
719  const int max_qp = 51 + 6 * (depth - 8);
720  for (i = 0; i < max_qp + 1; i++)
721  pps->chroma_qp_table[t][i] =
722  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
723 }
724 
725 static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
726 {
727  int profile_idc = sps->profile_idc;
728 
729  if ((profile_idc == 66 || profile_idc == 77 ||
730  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
731  av_log(logctx, AV_LOG_VERBOSE,
732  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
733  return 0;
734  }
735 
736  return 1;
737 }
738 
740  H264ParamSets *ps, int bit_length)
741 {
742  AVBufferRef *pps_buf;
743  const SPS *sps;
744  unsigned int pps_id = get_ue_golomb(gb);
745  PPS *pps;
746  int qp_bd_offset;
747  int bits_left;
748  int ret;
749 
750  if (pps_id >= MAX_PPS_COUNT) {
751  av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
752  return AVERROR_INVALIDDATA;
753  }
754 
755  pps_buf = av_buffer_allocz(sizeof(*pps));
756  if (!pps_buf)
757  return AVERROR(ENOMEM);
758  pps = (PPS*)pps_buf->data;
759 
760  pps->data_size = gb->buffer_end - gb->buffer;
761  if (pps->data_size > sizeof(pps->data)) {
762  av_log(avctx, AV_LOG_DEBUG, "Truncating likely oversized PPS "
763  "(%"SIZE_SPECIFIER" > %"SIZE_SPECIFIER")\n",
764  pps->data_size, sizeof(pps->data));
765  pps->data_size = sizeof(pps->data);
766  }
767  memcpy(pps->data, gb->buffer, pps->data_size);
768 
769  pps->sps_id = get_ue_golomb_31(gb);
770  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
771  !ps->sps_list[pps->sps_id]) {
772  av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
773  ret = AVERROR_INVALIDDATA;
774  goto fail;
775  }
776  sps = (const SPS*)ps->sps_list[pps->sps_id]->data;
777  if (sps->bit_depth_luma > 14) {
778  av_log(avctx, AV_LOG_ERROR,
779  "Invalid luma bit depth=%d\n",
780  sps->bit_depth_luma);
781  ret = AVERROR_INVALIDDATA;
782  goto fail;
783  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
785  "Unimplemented luma bit depth=%d",
786  sps->bit_depth_luma);
787  ret = AVERROR_PATCHWELCOME;
788  goto fail;
789  }
790 
791  pps->cabac = get_bits1(gb);
792  pps->pic_order_present = get_bits1(gb);
793  pps->slice_group_count = get_ue_golomb(gb) + 1;
794  if (pps->slice_group_count > 1) {
796  av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");
797  }
798  pps->ref_count[0] = get_ue_golomb(gb) + 1;
799  pps->ref_count[1] = get_ue_golomb(gb) + 1;
800  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
801  av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
802  ret = AVERROR_INVALIDDATA;
803  goto fail;
804  }
805 
806  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
807 
808  pps->weighted_pred = get_bits1(gb);
809  pps->weighted_bipred_idc = get_bits(gb, 2);
810  pps->init_qp = get_se_golomb(gb) + 26U + qp_bd_offset;
811  pps->init_qs = get_se_golomb(gb) + 26U + qp_bd_offset;
813  if (pps->chroma_qp_index_offset[0] < -12 || pps->chroma_qp_index_offset[0] > 12) {
814  ret = AVERROR_INVALIDDATA;
815  goto fail;
816  }
817 
821 
822  pps->transform_8x8_mode = 0;
823  memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
824  sizeof(pps->scaling_matrix4));
825  memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
826  sizeof(pps->scaling_matrix8));
827 
828  bits_left = bit_length - get_bits_count(gb);
829  if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
830  pps->transform_8x8_mode = get_bits1(gb);
831  ret = decode_scaling_matrices(gb, sps, pps, 0,
832  pps->scaling_matrix4, pps->scaling_matrix8);
833  if (ret < 0)
834  goto fail;
835  // second_chroma_qp_index_offset
837  if (pps->chroma_qp_index_offset[1] < -12 || pps->chroma_qp_index_offset[1] > 12) {
838  ret = AVERROR_INVALIDDATA;
839  goto fail;
840  }
841  } else {
843  }
844 
845  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
846  sps->bit_depth_luma);
847  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
848  sps->bit_depth_luma);
849 
850  init_dequant_tables(pps, sps);
851 
852  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
853  pps->chroma_qp_diff = 1;
854 
855  if (avctx->debug & FF_DEBUG_PICT_INFO) {
856  av_log(avctx, AV_LOG_DEBUG,
857  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
858  pps_id, pps->sps_id,
859  pps->cabac ? "CABAC" : "CAVLC",
860  pps->slice_group_count,
861  pps->ref_count[0], pps->ref_count[1],
862  pps->weighted_pred ? "weighted" : "",
863  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
864  pps->deblocking_filter_parameters_present ? "LPAR" : "",
865  pps->constrained_intra_pred ? "CONSTR" : "",
866  pps->redundant_pic_cnt_present ? "REDU" : "",
867  pps->transform_8x8_mode ? "8x8DCT" : "");
868  }
869 
870  remove_pps(ps, pps_id);
871  ps->pps_list[pps_id] = pps_buf;
872 
873  return 0;
874 
875 fail:
876  av_buffer_unref(&pps_buf);
877  return ret;
878 }
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:739
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 decode_hrd_parameters(GetBitContext *gb, AVCodecContext *avctx, SPS *sps)
Definition: h264_ps.c:107
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:125
#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:117
int chroma_qp_index_offset[2]
Definition: h264_ps.h:120
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:139
int scaling_matrix_present
Definition: h264_ps.h:87
uint8_t scaling_matrix4[6][16]
Definition: h264_ps.h:88
#define avpriv_request_sample(...)
Sequence parameter set.
Definition: h264_ps.h:44
int bitstream_restriction_flag
Definition: h264_ps.h:85
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264_ps.h:115
int num
Numerator.
Definition: rational.h:59
const uint8_t * buffer
Definition: get_bits.h:62
Picture parameter set.
Definition: h264_ps.h:109
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:128
uint32_t num_units_in_tick
Definition: h264_ps.h:81
int profile_idc
Definition: h264_ps.h:46
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:2915
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:83
uint8_t scaling_matrix4[6][16]
Definition: h264_ps.h:125
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264_ps.h:121
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:145
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:99
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2654
enum AVColorPrimaries color_primaries
Definition: h264_ps.h:77
int cabac
entropy_coding_mode_flag
Definition: h264_ps.h:111
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264_ps.h:69
int level_idc
Definition: h264_levels.c:25
uint32_t(*[6] dequant4_coeff)[16]
Definition: h264_ps.h:134
#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:135
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:123
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
ptrdiff_t size
Definition: opengl_enc.c:100
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2210
#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:143
#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:949
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:122
int num_reorder_frames
Definition: h264_ps.h:86
int time_offset_length
Definition: h264_ps.h:93
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:116
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:279
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:38
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264_ps.h:100
#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:2867
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:644
int crop
frame_cropping_flag
Definition: h264_ps.h:65
uint8_t scaling_matrix8[6][64]
Definition: h264_ps.h:126
size_t data_size
Definition: h264_ps.h:103
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:95
uint8_t data[4096]
Definition: h264_ps.h:129
#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:127
#define s(width, name)
Definition: cbs_vp9.c:257
int init_qp
pic_init_qp_minus26 + 26
Definition: h264_ps.h:118
int direct_8x8_inference_flag
Definition: h264_ps.h:64
uint8_t scaling_matrix8[6][64]
Definition: h264_ps.h:89
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:251
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:112
static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
Definition: h264_ps.c:725
static int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx, SPS *sps)
Definition: h264_ps.c:133
int timing_info_present_flag
Definition: h264_ps.h:80
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
int vcl_hrd_parameters_present_flag
Definition: h264_ps.h:91
Libavcodec external API header.
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:140
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:2653
main external API structure.
Definition: avcodec.h:1568
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:97
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:1593
static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
Definition: h264_ps.c:671
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264_ps.h:101
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:2633
const SPS * sps
Definition: h264_ps.h:146
unsigned int sps_id
Definition: h264_ps.h:110
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:82
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:124
#define SIZE_SPECIFIER
Definition: internal.h:262
int pic_struct_present_flag
Definition: h264_ps.h:92
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:119
common internal api header.
uint8_t data[4096]
Definition: h264_ps.h:102
AVBufferRef * pps_ref
Definition: h264_ps.h:142
int nal_hrd_parameters_present_flag
Definition: h264_ps.h:90
size_t data_size
Definition: h264_ps.h:130
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:2891
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:316
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:98
int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx, H264ParamSets *ps, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:333
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264_ps.h:59
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1655
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264_ps.h:113
int cpb_cnt
See H.264 E.1.2.
Definition: h264_ps.h:94
uint32_t dequant4_buffer[6][QP_MAX_NUM+1][16]
Definition: h264_ps.h:132
int32_t offset_for_ref_frame[256]
Definition: h264_ps.h:84
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:133
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264_ps.h:96
static void init_dequant_tables(PPS *pps, const SPS *sps)
Definition: h264_ps.c:697
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:2631
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:716
int mb_slice_group_map_type
Definition: h264_ps.h:114
enum AVColorSpace colorspace
Definition: h264_ps.h:79