FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 / MPEG4 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 "avcodec.h"
33 #include "h264.h"
34 #include "h264data.h"
35 #include "golomb.h"
36 
37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
38 #define MIN_LOG2_MAX_FRAME_NUM 4
39 
40 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
41 
42 #define CHROMA_QP_TABLE_END(d) \
43  QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
44  QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
45  QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
46  QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
47  QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
48  QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
49  QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
50  QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
51  QP(39, d), QP(39, d), QP(39, d), QP(39, d)
52 
54  { CHROMA_QP_TABLE_END(8) },
55  { 0, 1, 2, 3, 4, 5,
57  { 0, 1, 2, 3, 4, 5,
58  6, 7, 8, 9, 10, 11,
59  CHROMA_QP_TABLE_END(10) },
60  { 0, 1, 2, 3, 4, 5,
61  6, 7, 8, 9, 10, 11,
62  12,13,14,15, 16, 17,
63  CHROMA_QP_TABLE_END(11) },
64  { 0, 1, 2, 3, 4, 5,
65  6, 7, 8, 9, 10, 11,
66  12,13,14,15, 16, 17,
67  18,19,20,21, 22, 23,
68  CHROMA_QP_TABLE_END(12) },
69  { 0, 1, 2, 3, 4, 5,
70  6, 7, 8, 9, 10, 11,
71  12,13,14,15, 16, 17,
72  18,19,20,21, 22, 23,
73  24,25,26,27, 28, 29,
74  CHROMA_QP_TABLE_END(13) },
75  { 0, 1, 2, 3, 4, 5,
76  6, 7, 8, 9, 10, 11,
77  12,13,14,15, 16, 17,
78  18,19,20,21, 22, 23,
79  24,25,26,27, 28, 29,
80  30,31,32,33, 34, 35,
81  CHROMA_QP_TABLE_END(14) },
82 };
83 
84 static const uint8_t default_scaling4[2][16] = {
85  { 6, 13, 20, 28, 13, 20, 28, 32,
86  20, 28, 32, 37, 28, 32, 37, 42 },
87  { 10, 14, 20, 24, 14, 20, 24, 27,
88  20, 24, 27, 30, 24, 27, 30, 34 }
89 };
90 
91 static const uint8_t default_scaling8[2][64] = {
92  { 6, 10, 13, 16, 18, 23, 25, 27,
93  10, 11, 16, 18, 23, 25, 27, 29,
94  13, 16, 18, 23, 25, 27, 29, 31,
95  16, 18, 23, 25, 27, 29, 31, 33,
96  18, 23, 25, 27, 29, 31, 33, 36,
97  23, 25, 27, 29, 31, 33, 36, 38,
98  25, 27, 29, 31, 33, 36, 38, 40,
99  27, 29, 31, 33, 36, 38, 40, 42 },
100  { 9, 13, 15, 17, 19, 21, 22, 24,
101  13, 13, 17, 19, 21, 22, 24, 25,
102  15, 17, 19, 21, 22, 24, 25, 27,
103  17, 19, 21, 22, 24, 25, 27, 28,
104  19, 21, 22, 24, 25, 27, 28, 30,
105  21, 22, 24, 25, 27, 28, 30, 32,
106  22, 24, 25, 27, 28, 30, 32, 33,
107  24, 25, 27, 28, 30, 32, 33, 35 }
108 };
109 
110 /* maximum number of MBs in the DPB for a given level */
111 static const int level_max_dpb_mbs[][2] = {
112  { 10, 396 },
113  { 11, 900 },
114  { 12, 2376 },
115  { 13, 2376 },
116  { 20, 2376 },
117  { 21, 4752 },
118  { 22, 8100 },
119  { 30, 8100 },
120  { 31, 18000 },
121  { 32, 20480 },
122  { 40, 32768 },
123  { 41, 32768 },
124  { 42, 34816 },
125  { 50, 110400 },
126  { 51, 184320 },
127  { 52, 184320 },
128 };
129 
130 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
131 {
132  int cpb_count, i;
133  cpb_count = get_ue_golomb_31(&h->gb) + 1;
134 
135  if (cpb_count > 32U) {
136  av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
137  return AVERROR_INVALIDDATA;
138  }
139 
140  get_bits(&h->gb, 4); /* bit_rate_scale */
141  get_bits(&h->gb, 4); /* cpb_size_scale */
142  for (i = 0; i < cpb_count; i++) {
143  get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
144  get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
145  get_bits1(&h->gb); /* cbr_flag */
146  }
147  sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
148  sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
149  sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
150  sps->time_offset_length = get_bits(&h->gb, 5);
151  sps->cpb_cnt = cpb_count;
152  return 0;
153 }
154 
155 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
156 {
157  int aspect_ratio_info_present_flag;
158  unsigned int aspect_ratio_idc;
159 
160  aspect_ratio_info_present_flag = get_bits1(&h->gb);
161 
162  if (aspect_ratio_info_present_flag) {
163  aspect_ratio_idc = get_bits(&h->gb, 8);
164  if (aspect_ratio_idc == EXTENDED_SAR) {
165  sps->sar.num = get_bits(&h->gb, 16);
166  sps->sar.den = get_bits(&h->gb, 16);
167  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
168  sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
169  } else {
170  av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
171  return AVERROR_INVALIDDATA;
172  }
173  } else {
174  sps->sar.num =
175  sps->sar.den = 0;
176  }
177 
178  if (get_bits1(&h->gb)) /* overscan_info_present_flag */
179  get_bits1(&h->gb); /* overscan_appropriate_flag */
180 
183  get_bits(&h->gb, 3); /* video_format */
184  sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
185 
188  sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
189  sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
190  sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
191  if (sps->color_primaries >= AVCOL_PRI_NB)
193  if (sps->color_trc >= AVCOL_TRC_NB)
195  if (sps->colorspace >= AVCOL_SPC_NB)
197  }
198  }
199 
200  /* chroma_location_info_present_flag */
201  if (get_bits1(&h->gb)) {
202  /* chroma_sample_location_type_top_field */
204  get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
205  }
206 
207  if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
208  av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
209  return 0;
210  }
211 
213  if (sps->timing_info_present_flag) {
214  unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
215  unsigned time_scale = get_bits_long(&h->gb, 32);
216  if (!num_units_in_tick || !time_scale) {
218  "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
219  time_scale, num_units_in_tick);
220  sps->timing_info_present_flag = 0;
221  } else {
222  sps->num_units_in_tick = num_units_in_tick;
223  sps->time_scale = time_scale;
224  }
225  sps->fixed_frame_rate_flag = get_bits1(&h->gb);
226  }
227 
230  if (decode_hrd_parameters(h, sps) < 0)
231  return AVERROR_INVALIDDATA;
234  if (decode_hrd_parameters(h, sps) < 0)
235  return AVERROR_INVALIDDATA;
238  get_bits1(&h->gb); /* low_delay_hrd_flag */
240  if (!get_bits_left(&h->gb))
241  return 0;
243  if (sps->bitstream_restriction_flag) {
244  get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
245  get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
246  get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
247  get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
248  get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
249  sps->num_reorder_frames = get_ue_golomb(&h->gb);
250  get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
251 
252  if (get_bits_left(&h->gb) < 0) {
253  sps->num_reorder_frames = 0;
255  }
256 
257  if (sps->num_reorder_frames > 16U
258  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
260  "Clipping illegal num_reorder_frames %d\n",
261  sps->num_reorder_frames);
262  sps->num_reorder_frames = 16;
263  return AVERROR_INVALIDDATA;
264  }
265  }
266 
267  return 0;
268 }
269 
270 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
271  const uint8_t *jvt_list,
272  const uint8_t *fallback_list)
273 {
274  int i, last = 8, next = 8;
275  const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
276  if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
277  memcpy(factors, fallback_list, size * sizeof(uint8_t));
278  else
279  for (i = 0; i < size; i++) {
280  if (next)
281  next = (last + get_se_golomb(&h->gb)) & 0xff;
282  if (!i && !next) { /* matrix not written, we use the preset one */
283  memcpy(factors, jvt_list, size * sizeof(uint8_t));
284  break;
285  }
286  last = factors[scan[i]] = next ? next : last;
287  }
288 }
289 
291  PPS *pps, int is_sps,
292  uint8_t(*scaling_matrix4)[16],
293  uint8_t(*scaling_matrix8)[64])
294 {
295  int fallback_sps = !is_sps && sps->scaling_matrix_present;
296  const uint8_t *fallback[4] = {
297  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
298  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
299  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
300  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
301  };
302  if (get_bits1(&h->gb)) {
303  sps->scaling_matrix_present |= is_sps;
304  decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
305  decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
306  decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
307  decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
308  decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
309  decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
310  if (is_sps || pps->transform_8x8_mode) {
311  decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
312  decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
313  if (sps->chroma_format_idc == 3) {
314  decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
315  decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
316  decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
317  decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
318  }
319  }
320  }
321 }
322 
323 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
324 {
325  int profile_idc, level_idc, constraint_set_flags = 0;
326  unsigned int sps_id;
327  int i, log2_max_frame_num_minus4;
328  SPS *sps;
329 
330  sps = av_mallocz(sizeof(SPS));
331  if (!sps)
332  return AVERROR(ENOMEM);
333 
334  sps->data_size = h->gb.buffer_end - h->gb.buffer;
335  if (sps->data_size > sizeof(sps->data)) {
336  av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
337  sps->data_size = sizeof(sps->data);
338  }
339  memcpy(sps->data, h->gb.buffer, sps->data_size);
340 
341  profile_idc = get_bits(&h->gb, 8);
342  constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
343  constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
344  constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
345  constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
346  constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
347  constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
348  skip_bits(&h->gb, 2); // reserved_zero_2bits
349  level_idc = get_bits(&h->gb, 8);
350  sps_id = get_ue_golomb_31(&h->gb);
351 
352  if (sps_id >= MAX_SPS_COUNT) {
353  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
354  goto fail;
355  }
356 
357  sps->sps_id = sps_id;
358  sps->time_offset_length = 24;
359  sps->profile_idc = profile_idc;
360  sps->constraint_set_flags = constraint_set_flags;
361  sps->level_idc = level_idc;
362  sps->full_range = -1;
363 
364  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
365  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
366  sps->scaling_matrix_present = 0;
367  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
368 
369  if (sps->profile_idc == 100 || // High profile
370  sps->profile_idc == 110 || // High10 profile
371  sps->profile_idc == 122 || // High422 profile
372  sps->profile_idc == 244 || // High444 Predictive profile
373  sps->profile_idc == 44 || // Cavlc444 profile
374  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
375  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
376  sps->profile_idc == 118 || // Stereo High profile (MVC)
377  sps->profile_idc == 128 || // Multiview High profile (MVC)
378  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
379  sps->profile_idc == 144) { // old High444 profile
381  if (sps->chroma_format_idc > 3U) {
382  avpriv_request_sample(h->avctx, "chroma_format_idc %u",
383  sps->chroma_format_idc);
384  goto fail;
385  } else if (sps->chroma_format_idc == 3) {
388  av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
389  goto fail;
390  }
391  }
392  sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
393  sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
394  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
396  "Different chroma and luma bit depth");
397  goto fail;
398  }
399  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
400  sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
401  av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
402  sps->bit_depth_luma, sps->bit_depth_chroma);
403  goto fail;
404  }
405  sps->transform_bypass = get_bits1(&h->gb);
406  decode_scaling_matrices(h, sps, NULL, 1,
407  sps->scaling_matrix4, sps->scaling_matrix8);
408  } else {
409  sps->chroma_format_idc = 1;
410  sps->bit_depth_luma = 8;
411  sps->bit_depth_chroma = 8;
412  }
413 
414  log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
415  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
416  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
418  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
419  log2_max_frame_num_minus4);
420  goto fail;
421  }
422  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
423 
424  sps->poc_type = get_ue_golomb_31(&h->gb);
425 
426  if (sps->poc_type == 0) { // FIXME #define
427  unsigned t = get_ue_golomb(&h->gb);
428  if (t>12) {
429  av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
430  goto fail;
431  }
432  sps->log2_max_poc_lsb = t + 4;
433  } else if (sps->poc_type == 1) { // FIXME #define
437  sps->poc_cycle_length = get_ue_golomb(&h->gb);
438 
439  if ((unsigned)sps->poc_cycle_length >=
442  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
443  goto fail;
444  }
445 
446  for (i = 0; i < sps->poc_cycle_length; i++)
447  sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
448  } else if (sps->poc_type != 2) {
449  av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
450  goto fail;
451  }
452 
453  sps->ref_frame_count = get_ue_golomb_31(&h->gb);
454  if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
455  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
456  if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
457  sps->ref_frame_count > 16U) {
459  "too many reference frames %d\n", sps->ref_frame_count);
460  goto fail;
461  }
463  sps->mb_width = get_ue_golomb(&h->gb) + 1;
464  sps->mb_height = get_ue_golomb(&h->gb) + 1;
465  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
466  (unsigned)sps->mb_height >= INT_MAX / 16 ||
467  av_image_check_size(16 * sps->mb_width,
468  16 * sps->mb_height, 0, h->avctx)) {
469  av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
470  goto fail;
471  }
472 
473  sps->frame_mbs_only_flag = get_bits1(&h->gb);
474  if (!sps->frame_mbs_only_flag)
475  sps->mb_aff = get_bits1(&h->gb);
476  else
477  sps->mb_aff = 0;
478 
480 
481 #ifndef ALLOW_INTERLACE
482  if (sps->mb_aff)
484  "MBAFF support not included; enable it at compile-time.\n");
485 #endif
486  sps->crop = get_bits1(&h->gb);
487  if (sps->crop) {
488  unsigned int crop_left = get_ue_golomb(&h->gb);
489  unsigned int crop_right = get_ue_golomb(&h->gb);
490  unsigned int crop_top = get_ue_golomb(&h->gb);
491  unsigned int crop_bottom = get_ue_golomb(&h->gb);
492  int width = 16 * sps->mb_width;
493  int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
494 
496  av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
497  "values are l:%d r:%d t:%d b:%d\n",
498  crop_left, crop_right, crop_top, crop_bottom);
499 
500  sps->crop_left =
501  sps->crop_right =
502  sps->crop_top =
503  sps->crop_bottom = 0;
504  } else {
505  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
506  int hsub = (sps->chroma_format_idc == 1 ||
507  sps->chroma_format_idc == 2) ? 1 : 0;
508  int step_x = 1 << hsub;
509  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
510 
511  if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
513  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
515  "Reducing left cropping to %d "
516  "chroma samples to preserve alignment.\n",
517  crop_left);
518  }
519 
520  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
521  crop_right > (unsigned)INT_MAX / 4 / step_x ||
522  crop_top > (unsigned)INT_MAX / 4 / step_y ||
523  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
524  (crop_left + crop_right ) * step_x >= width ||
525  (crop_top + crop_bottom) * step_y >= height
526  ) {
527  av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
528  goto fail;
529  }
530 
531  sps->crop_left = crop_left * step_x;
532  sps->crop_right = crop_right * step_x;
533  sps->crop_top = crop_top * step_y;
534  sps->crop_bottom = crop_bottom * step_y;
535  }
536  } else {
537  sps->crop_left =
538  sps->crop_right =
539  sps->crop_top =
540  sps->crop_bottom =
541  sps->crop = 0;
542  }
543 
545  if (sps->vui_parameters_present_flag) {
546  int ret = decode_vui_parameters(h, sps);
547  if (ret < 0)
548  goto fail;
549  }
550 
551  if (get_bits_left(&h->gb) < 0) {
552  av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
553  "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
554  if (!ignore_truncation)
555  goto fail;
556  }
557 
558  /* if the maximum delay is not stored in the SPS, derive it based on the
559  * level */
560  if (!sps->bitstream_restriction_flag) {
562  for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
563  if (level_max_dpb_mbs[i][0] == sps->level_idc) {
564  sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
565  sps->num_reorder_frames);
566  break;
567  }
568  }
569  }
570 
571  if (!sps->sar.den)
572  sps->sar.den = 1;
573 
574  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
575  static const char csp[4][5] = { "Gray", "420", "422", "444" };
577  "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",
578  sps_id, sps->profile_idc, sps->level_idc,
579  sps->poc_type,
580  sps->ref_frame_count,
581  sps->mb_width, sps->mb_height,
582  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
583  sps->direct_8x8_inference_flag ? "8B8" : "",
584  sps->crop_left, sps->crop_right,
585  sps->crop_top, sps->crop_bottom,
586  sps->vui_parameters_present_flag ? "VUI" : "",
587  csp[sps->chroma_format_idc],
589  sps->timing_info_present_flag ? sps->time_scale : 0,
590  sps->bit_depth_luma,
592  );
593  }
594  sps->new = 1;
595 
596  av_free(h->sps_buffers[sps_id]);
597  h->sps_buffers[sps_id] = sps;
598 
599  return 0;
600 
601 fail:
602  av_free(sps);
603  return AVERROR_INVALIDDATA;
604 }
605 
606 static void build_qp_table(PPS *pps, int t, int index, const int depth)
607 {
608  int i;
609  const int max_qp = 51 + 6 * (depth - 8);
610  for (i = 0; i < max_qp + 1; i++)
611  pps->chroma_qp_table[t][i] =
612  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
613 }
614 
616 {
617  const SPS *sps = h->sps_buffers[pps->sps_id];
618  int profile_idc = sps->profile_idc;
619 
620  if ((profile_idc == 66 || profile_idc == 77 ||
621  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
623  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
624  return 0;
625  }
626 
627  return 1;
628 }
629 
631 {
632  const SPS *sps;
633  unsigned int pps_id = get_ue_golomb(&h->gb);
634  PPS *pps;
635  int qp_bd_offset;
636  int bits_left;
637  int ret;
638 
639  if (pps_id >= MAX_PPS_COUNT) {
640  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
641  return AVERROR_INVALIDDATA;
642  }
643 
644  pps = av_mallocz(sizeof(PPS));
645  if (!pps)
646  return AVERROR(ENOMEM);
647  pps->data_size = h->gb.buffer_end - h->gb.buffer;
648  if (pps->data_size > sizeof(pps->data)) {
649  av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
650  pps->data_size = sizeof(pps->data);
651  }
652  memcpy(pps->data, h->gb.buffer, pps->data_size);
653  pps->sps_id = get_ue_golomb_31(&h->gb);
654  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
655  !h->sps_buffers[pps->sps_id]) {
656  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
657  ret = AVERROR_INVALIDDATA;
658  goto fail;
659  }
660  sps = h->sps_buffers[pps->sps_id];
661  if (sps->bit_depth_luma > 14) {
663  "Invalid luma bit depth=%d\n",
664  sps->bit_depth_luma);
665  ret = AVERROR_INVALIDDATA;
666  goto fail;
667  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
669  "Unimplemented luma bit depth=%d\n",
670  sps->bit_depth_luma);
671  ret = AVERROR_PATCHWELCOME;
672  goto fail;
673  }
674 
675  pps->cabac = get_bits1(&h->gb);
676  pps->pic_order_present = get_bits1(&h->gb);
677  pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
678  if (pps->slice_group_count > 1) {
680  av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
681  switch (pps->mb_slice_group_map_type) {
682  case 0:
683 #if 0
684  | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
685  | run_length[i] |1 |ue(v) |
686 #endif
687  break;
688  case 2:
689 #if 0
690  | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
691  | top_left_mb[i] |1 |ue(v) |
692  | bottom_right_mb[i] |1 |ue(v) |
693  | } | | |
694 #endif
695  break;
696  case 3:
697  case 4:
698  case 5:
699 #if 0
700  | slice_group_change_direction_flag |1 |u(1) |
701  | slice_group_change_rate_minus1 |1 |ue(v) |
702 #endif
703  break;
704  case 6:
705 #if 0
706  | slice_group_id_cnt_minus1 |1 |ue(v) |
707  | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
708  | slice_group_id[i] |1 |u(v) |
709 #endif
710  break;
711  }
712  }
713  pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
714  pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
715  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
716  av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
717  ret = AVERROR_INVALIDDATA;
718  goto fail;
719  }
720 
721  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
722 
723  pps->weighted_pred = get_bits1(&h->gb);
724  pps->weighted_bipred_idc = get_bits(&h->gb, 2);
725  pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
726  pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
727  pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
729  pps->constrained_intra_pred = get_bits1(&h->gb);
731 
732  pps->transform_8x8_mode = 0;
733  // contents of sps/pps can change even if id doesn't, so reinit
734  h->dequant_coeff_pps = -1;
735  memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
736  sizeof(pps->scaling_matrix4));
737  memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
738  sizeof(pps->scaling_matrix8));
739 
740  bits_left = bit_length - get_bits_count(&h->gb);
741  if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
742  pps->transform_8x8_mode = get_bits1(&h->gb);
743  decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
744  pps->scaling_matrix4, pps->scaling_matrix8);
745  // second_chroma_qp_index_offset
746  pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
747  } else {
749  }
750 
751  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
752  sps->bit_depth_luma);
753  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
754  sps->bit_depth_luma);
755  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
756  pps->chroma_qp_diff = 1;
757 
758  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
760  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
761  pps_id, pps->sps_id,
762  pps->cabac ? "CABAC" : "CAVLC",
763  pps->slice_group_count,
764  pps->ref_count[0], pps->ref_count[1],
765  pps->weighted_pred ? "weighted" : "",
766  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
767  pps->deblocking_filter_parameters_present ? "LPAR" : "",
768  pps->constrained_intra_pred ? "CONSTR" : "",
769  pps->redundant_pic_cnt_present ? "REDU" : "",
770  pps->transform_8x8_mode ? "8x8DCT" : "");
771  }
772 
773  av_free(h->pps_buffers[pps_id]);
774  h->pps_buffers[pps_id] = pps;
775  return 0;
776 
777 fail:
778  av_free(pps);
779  return ret;
780 }
int chroma_format_idc
Definition: h264.h:179
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:332
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:37
int video_signal_type_present_flag
Definition: h264.h:204
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
GetBitContext gb
Definition: h264.h:529
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
#define H264_MAX_PICTURE_COUNT
Definition: h264.h:47
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int weighted_bipred_idc
Definition: h264.h:248
int chroma_qp_index_offset[2]
Definition: h264.h:251
int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:323
int scaling_matrix_present
Definition: h264.h:217
uint8_t scaling_matrix4[6][16]
Definition: h264.h:218
#define MAX_PPS_COUNT
Definition: h264.h:51
Sequence parameter set.
Definition: h264.h:175
int bitstream_restriction_flag
Definition: h264.h:215
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:246
int num
numerator
Definition: rational.h:44
const uint8_t * buffer
Definition: get_bits.h:55
Picture parameter set.
Definition: h264.h:240
int frame_mbs_only_flag
Definition: h264.h:192
H264Context.
Definition: h264.h:522
int chroma_qp_diff
Definition: h264.h:259
uint32_t num_units_in_tick
Definition: h264.h:211
int profile_idc
Definition: h264.h:177
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264.h:200
int fixed_frame_rate_flag
Definition: h264.h:213
uint8_t scaling_matrix4[6][16]
Definition: h264.h:256
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264.h:252
static const AVRational ff_h264_pixel_aspect[17]
Definition: h264data.h:170
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
int full_range
Definition: h264.h:205
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264.h:198
int offset_for_non_ref_pic
Definition: h264.h:185
int gaps_in_frame_num_allowed_flag
Definition: h264.h:189
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264.h:229
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2764
enum AVColorPrimaries color_primaries
Definition: h264.h:207
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:730
int cabac
entropy_coding_mode_flag
Definition: h264.h:242
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264.h:199
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264.h:180
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
static const int level_max_dpb_mbs[][2]
Definition: h264_ps.c:111
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264.h:254
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define MAX_DELAYED_PIC_COUNT
Definition: h264.h:55
ptrdiff_t size
Definition: opengl_enc.c:101
static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps, uint8_t(*scaling_matrix4)[16], uint8_t(*scaling_matrix8)[64])
Definition: h264_ps.c:290
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2269
#define av_log(a,...)
H.264 / AVC / MPEG4 part10 codec.
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:607
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264.h:193
enum AVColorTransferCharacteristic color_trc
Definition: h264.h:208
#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:825
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
int poc_type
pic_order_cnt_type
Definition: h264.h:182
int constrained_intra_pred
constrained_intra_pred_flag
Definition: h264.h:253
int num_reorder_frames
Definition: h264.h:216
#define AVERROR(e)
Definition: error.h:43
int time_offset_length
Definition: h264.h:223
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
Not part of ABI.
Definition: pixfmt.h:389
#define EXTENDED_SAR
Definition: h264.h:102
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1627
int weighted_pred
weighted_pred_flag
Definition: h264.h:247
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:38
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264.h:230
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:80
int delta_pic_order_always_zero_flag
Definition: h264.h:184
int new
flag to keep track if the decoder context needs re-init due to changed SPS
Definition: h264.h:232
int offset_for_top_to_bottom_field
Definition: h264.h:186
int depth
Definition: v4l.c:62
#define CHROMA_QP_TABLE_END(d)
Definition: h264_ps.c:42
int crop
frame_cropping_flag
Definition: h264.h:195
static int decode_hrd_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:130
uint8_t scaling_matrix8[6][64]
Definition: h264.h:257
size_t data_size
Definition: h264.h:234
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:251
int ref_frame_count
num_ref_frames
Definition: h264.h:188
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264.h:225
uint8_t data[4096]
Definition: h264.h:260
#define FFMIN(a, b)
Definition: common.h:96
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264.h:187
int colour_description_present_flag
Definition: h264.h:206
AVRational sar
Definition: h264.h:203
PPS * pps_buffers[MAX_PPS_COUNT]
Definition: h264.h:644
#define MAX_SPS_COUNT
Definition: h264.h:50
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264.h:258
static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
Definition: h264_ps.c:615
int init_qp
pic_init_qp_minus26 + 26
Definition: h264.h:249
int direct_8x8_inference_flag
Definition: h264.h:194
uint8_t scaling_matrix8[6][64]
Definition: h264.h:219
unsigned int sps_id
Definition: h264.h:176
#define FF_ARRAY_ELEMS(a)
int dequant_coeff_pps
reinit tables when pps changes
Definition: h264.h:646
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:85
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int pic_order_present
pic_order_present_flag
Definition: h264.h:243
SPS * sps_buffers[MAX_SPS_COUNT]
Definition: h264.h:643
short offset_for_ref_frame[256]
Definition: h264.h:214
int timing_info_present_flag
Definition: h264.h:210
int vcl_hrd_parameters_present_flag
Definition: h264.h:221
AVCodecContext * avctx
Definition: h264.h:524
Libavcodec external API header.
H264 / AVC / MPEG4 part10 codec data table
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:100
static const uint8_t zigzag_scan[16+1]
Definition: h264data.h:54
int debug
debug
Definition: avcodec.h:2763
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264.h:227
int vui_parameters_present_flag
Definition: h264.h:202
static int decode_vui_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:155
#define QP_MAX_NUM
Definition: h264.h:109
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1564
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264.h:231
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:312
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:305
int index
Definition: gxfenc.c:89
Not part of ABI.
Definition: pixfmt.h:414
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
unsigned int sps_id
Definition: h264.h:241
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264.h:183
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:345
uint32_t time_scale
Definition: h264.h:212
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:255
int pic_struct_present_flag
Definition: h264.h:222
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
Decode PPS.
Definition: h264_ps.c:630
int mb_height
pic_height_in_map_units_minus1 + 1
Definition: h264.h:191
int init_qs
pic_init_qs_minus26 + 26
Definition: h264.h:250
common internal api header.
uint8_t data[4096]
Definition: h264.h:233
int nal_hrd_parameters_present_flag
Definition: h264.h:220
size_t data_size
Definition: h264.h:261
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264.h:181
const uint8_t * buffer_end
Definition: get_bits.h:55
static const uint8_t default_scaling4[2][16]
Definition: h264_ps.c:84
int den
denominator
Definition: rational.h:45
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:228
#define av_free(p)
const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1]
One chroma qp table for each possible bit depth (8-14).
Definition: h264_ps.c:53
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264.h:190
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1634
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264.h:244
int cpb_cnt
See H.264 E.1.2.
Definition: h264.h:224
static void decode_scaling_list(H264Context *h, uint8_t *factors, int size, const uint8_t *jvt_list, const uint8_t *fallback_list)
Definition: h264_ps.c:270
static const uint8_t default_scaling8[2][64]
Definition: h264_ps.c:91
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264.h:226
#define MKTAG(a, b, c, d)
Definition: common.h:342
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264.h:201
exp golomb vlc stuff
int level_idc
Definition: h264.h:178
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
Not part of ABI.
Definition: pixfmt.h:432
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:606
static int width
int mb_slice_group_map_type
Definition: h264.h:245
enum AVColorSpace colorspace
Definition: h264.h:209