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 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
111 {
112  int cpb_count, i;
113  cpb_count = get_ue_golomb_31(&h->gb) + 1;
114 
115  if (cpb_count > 32U) {
116  av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
117  return AVERROR_INVALIDDATA;
118  }
119 
120  get_bits(&h->gb, 4); /* bit_rate_scale */
121  get_bits(&h->gb, 4); /* cpb_size_scale */
122  for (i = 0; i < cpb_count; i++) {
123  get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
124  get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
125  get_bits1(&h->gb); /* cbr_flag */
126  }
127  sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
128  sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
129  sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
130  sps->time_offset_length = get_bits(&h->gb, 5);
131  sps->cpb_cnt = cpb_count;
132  return 0;
133 }
134 
135 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
136 {
137  int aspect_ratio_info_present_flag;
138  unsigned int aspect_ratio_idc;
139 
140  aspect_ratio_info_present_flag = get_bits1(&h->gb);
141 
142  if (aspect_ratio_info_present_flag) {
143  aspect_ratio_idc = get_bits(&h->gb, 8);
144  if (aspect_ratio_idc == EXTENDED_SAR) {
145  sps->sar.num = get_bits(&h->gb, 16);
146  sps->sar.den = get_bits(&h->gb, 16);
147  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
148  sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
149  } else {
150  av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
151  return AVERROR_INVALIDDATA;
152  }
153  } else {
154  sps->sar.num =
155  sps->sar.den = 0;
156  }
157 
158  if (get_bits1(&h->gb)) /* overscan_info_present_flag */
159  get_bits1(&h->gb); /* overscan_appropriate_flag */
160 
163  get_bits(&h->gb, 3); /* video_format */
164  sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
165 
168  sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
169  sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
170  sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
171  if (sps->color_primaries >= AVCOL_PRI_NB)
173  if (sps->color_trc >= AVCOL_TRC_NB)
175  if (sps->colorspace >= AVCOL_SPC_NB)
177  }
178  }
179 
180  /* chroma_location_info_present_flag */
181  if (get_bits1(&h->gb)) {
182  /* chroma_sample_location_type_top_field */
184  get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
185  }
186 
187  if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
188  av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
189  return 0;
190  }
191 
193  if (sps->timing_info_present_flag) {
194  unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
195  unsigned time_scale = get_bits_long(&h->gb, 32);
196  if (!num_units_in_tick || !time_scale) {
198  "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
199  time_scale, num_units_in_tick);
200  sps->timing_info_present_flag = 0;
201  } else {
202  sps->num_units_in_tick = num_units_in_tick;
203  sps->time_scale = time_scale;
204  }
205  sps->fixed_frame_rate_flag = get_bits1(&h->gb);
206  }
207 
210  if (decode_hrd_parameters(h, sps) < 0)
211  return AVERROR_INVALIDDATA;
214  if (decode_hrd_parameters(h, sps) < 0)
215  return AVERROR_INVALIDDATA;
218  get_bits1(&h->gb); /* low_delay_hrd_flag */
220  if (!get_bits_left(&h->gb))
221  return 0;
223  if (sps->bitstream_restriction_flag) {
224  get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
225  get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
226  get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
227  get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
228  get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
229  sps->num_reorder_frames = get_ue_golomb(&h->gb);
230  get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
231 
232  if (get_bits_left(&h->gb) < 0) {
233  sps->num_reorder_frames = 0;
235  }
236 
237  if (sps->num_reorder_frames > 16U
238  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
240  "Clipping illegal num_reorder_frames %d\n",
241  sps->num_reorder_frames);
242  sps->num_reorder_frames = 16;
243  return AVERROR_INVALIDDATA;
244  }
245  }
246 
247  return 0;
248 }
249 
250 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
251  const uint8_t *jvt_list,
252  const uint8_t *fallback_list)
253 {
254  int i, last = 8, next = 8;
255  const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
256  if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
257  memcpy(factors, fallback_list, size * sizeof(uint8_t));
258  else
259  for (i = 0; i < size; i++) {
260  if (next)
261  next = (last + get_se_golomb(&h->gb)) & 0xff;
262  if (!i && !next) { /* matrix not written, we use the preset one */
263  memcpy(factors, jvt_list, size * sizeof(uint8_t));
264  break;
265  }
266  last = factors[scan[i]] = next ? next : last;
267  }
268 }
269 
271  PPS *pps, int is_sps,
272  uint8_t(*scaling_matrix4)[16],
273  uint8_t(*scaling_matrix8)[64])
274 {
275  int fallback_sps = !is_sps && sps->scaling_matrix_present;
276  const uint8_t *fallback[4] = {
277  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
278  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
279  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
280  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
281  };
282  if (get_bits1(&h->gb)) {
283  sps->scaling_matrix_present |= is_sps;
284  decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
285  decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
286  decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
287  decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
288  decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
289  decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
290  if (is_sps || pps->transform_8x8_mode) {
291  decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
292  decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
293  if (sps->chroma_format_idc == 3) {
294  decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
295  decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
296  decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
297  decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
298  }
299  }
300  }
301 }
302 
303 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
304 {
305  int profile_idc, level_idc, constraint_set_flags = 0;
306  unsigned int sps_id;
307  int i, log2_max_frame_num_minus4;
308  SPS *sps;
309 
310  profile_idc = get_bits(&h->gb, 8);
311  constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
312  constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
313  constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
314  constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
315  constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
316  constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
317  skip_bits(&h->gb, 2); // reserved_zero_2bits
318  level_idc = get_bits(&h->gb, 8);
319  sps_id = get_ue_golomb_31(&h->gb);
320 
321  if (sps_id >= MAX_SPS_COUNT) {
322  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
323  return AVERROR_INVALIDDATA;
324  }
325  sps = av_mallocz(sizeof(SPS));
326  if (!sps)
327  return AVERROR(ENOMEM);
328 
329  sps->sps_id = sps_id;
330  sps->time_offset_length = 24;
331  sps->profile_idc = profile_idc;
332  sps->constraint_set_flags = constraint_set_flags;
333  sps->level_idc = level_idc;
334  sps->full_range = -1;
335 
336  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
337  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
338  sps->scaling_matrix_present = 0;
339  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
340 
341  if (sps->profile_idc == 100 || // High profile
342  sps->profile_idc == 110 || // High10 profile
343  sps->profile_idc == 122 || // High422 profile
344  sps->profile_idc == 244 || // High444 Predictive profile
345  sps->profile_idc == 44 || // Cavlc444 profile
346  sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
347  sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
348  sps->profile_idc == 118 || // Stereo High profile (MVC)
349  sps->profile_idc == 128 || // Multiview High profile (MVC)
350  sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
351  sps->profile_idc == 144) { // old High444 profile
353  if (sps->chroma_format_idc > 3U) {
354  avpriv_request_sample(h->avctx, "chroma_format_idc %u",
355  sps->chroma_format_idc);
356  goto fail;
357  } else if (sps->chroma_format_idc == 3) {
360  av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
361  goto fail;
362  }
363  }
364  sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
365  sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
366  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
368  "Different chroma and luma bit depth");
369  goto fail;
370  }
371  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
372  sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
373  av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
374  sps->bit_depth_luma, sps->bit_depth_chroma);
375  goto fail;
376  }
377  sps->transform_bypass = get_bits1(&h->gb);
378  decode_scaling_matrices(h, sps, NULL, 1,
379  sps->scaling_matrix4, sps->scaling_matrix8);
380  } else {
381  sps->chroma_format_idc = 1;
382  sps->bit_depth_luma = 8;
383  sps->bit_depth_chroma = 8;
384  }
385 
386  log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
387  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
388  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
390  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
391  log2_max_frame_num_minus4);
392  goto fail;
393  }
394  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
395 
396  sps->poc_type = get_ue_golomb_31(&h->gb);
397 
398  if (sps->poc_type == 0) { // FIXME #define
399  unsigned t = get_ue_golomb(&h->gb);
400  if (t>12) {
401  av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
402  goto fail;
403  }
404  sps->log2_max_poc_lsb = t + 4;
405  } else if (sps->poc_type == 1) { // FIXME #define
409  sps->poc_cycle_length = get_ue_golomb(&h->gb);
410 
411  if ((unsigned)sps->poc_cycle_length >=
414  "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
415  goto fail;
416  }
417 
418  for (i = 0; i < sps->poc_cycle_length; i++)
419  sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
420  } else if (sps->poc_type != 2) {
421  av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
422  goto fail;
423  }
424 
425  sps->ref_frame_count = get_ue_golomb_31(&h->gb);
426  if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
427  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
428  if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
429  sps->ref_frame_count > 16U) {
431  "too many reference frames %d\n", sps->ref_frame_count);
432  goto fail;
433  }
435  sps->mb_width = get_ue_golomb(&h->gb) + 1;
436  sps->mb_height = get_ue_golomb(&h->gb) + 1;
437  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
438  (unsigned)sps->mb_height >= INT_MAX / 16 ||
439  av_image_check_size(16 * sps->mb_width,
440  16 * sps->mb_height, 0, h->avctx)) {
441  av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
442  goto fail;
443  }
444 
445  sps->frame_mbs_only_flag = get_bits1(&h->gb);
446  if (!sps->frame_mbs_only_flag)
447  sps->mb_aff = get_bits1(&h->gb);
448  else
449  sps->mb_aff = 0;
450 
452 
453 #ifndef ALLOW_INTERLACE
454  if (sps->mb_aff)
456  "MBAFF support not included; enable it at compile-time.\n");
457 #endif
458  sps->crop = get_bits1(&h->gb);
459  if (sps->crop) {
460  unsigned int crop_left = get_ue_golomb(&h->gb);
461  unsigned int crop_right = get_ue_golomb(&h->gb);
462  unsigned int crop_top = get_ue_golomb(&h->gb);
463  unsigned int crop_bottom = get_ue_golomb(&h->gb);
464  int width = 16 * sps->mb_width;
465  int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
466 
468  av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
469  "values are l:%d r:%d t:%d b:%d\n",
470  crop_left, crop_right, crop_top, crop_bottom);
471 
472  sps->crop_left =
473  sps->crop_right =
474  sps->crop_top =
475  sps->crop_bottom = 0;
476  } else {
477  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
478  int hsub = (sps->chroma_format_idc == 1 ||
479  sps->chroma_format_idc == 2) ? 1 : 0;
480  int step_x = 1 << hsub;
481  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
482 
483  if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
485  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
487  "Reducing left cropping to %d "
488  "chroma samples to preserve alignment.\n",
489  crop_left);
490  }
491 
492  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
493  crop_right > (unsigned)INT_MAX / 4 / step_x ||
494  crop_top > (unsigned)INT_MAX / 4 / step_y ||
495  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
496  (crop_left + crop_right ) * step_x >= width ||
497  (crop_top + crop_bottom) * step_y >= height
498  ) {
499  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);
500  goto fail;
501  }
502 
503  sps->crop_left = crop_left * step_x;
504  sps->crop_right = crop_right * step_x;
505  sps->crop_top = crop_top * step_y;
506  sps->crop_bottom = crop_bottom * step_y;
507  }
508  } else {
509  sps->crop_left =
510  sps->crop_right =
511  sps->crop_top =
512  sps->crop_bottom =
513  sps->crop = 0;
514  }
515 
517  if (sps->vui_parameters_present_flag) {
518  int ret = decode_vui_parameters(h, sps);
519  if (ret < 0)
520  goto fail;
521  }
522 
523  if (get_bits_left(&h->gb) < 0) {
524  av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
525  "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
526  if (!ignore_truncation)
527  goto fail;
528  }
529 
530  if (!sps->sar.den)
531  sps->sar.den = 1;
532 
533  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
534  static const char csp[4][5] = { "Gray", "420", "422", "444" };
536  "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",
537  sps_id, sps->profile_idc, sps->level_idc,
538  sps->poc_type,
539  sps->ref_frame_count,
540  sps->mb_width, sps->mb_height,
541  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
542  sps->direct_8x8_inference_flag ? "8B8" : "",
543  sps->crop_left, sps->crop_right,
544  sps->crop_top, sps->crop_bottom,
545  sps->vui_parameters_present_flag ? "VUI" : "",
546  csp[sps->chroma_format_idc],
548  sps->timing_info_present_flag ? sps->time_scale : 0,
549  sps->bit_depth_luma,
551  );
552  }
553  sps->new = 1;
554 
555  av_free(h->sps_buffers[sps_id]);
556  h->sps_buffers[sps_id] = sps;
557 
558  return 0;
559 
560 fail:
561  av_free(sps);
562  return AVERROR_INVALIDDATA;
563 }
564 
565 static void build_qp_table(PPS *pps, int t, int index, const int depth)
566 {
567  int i;
568  const int max_qp = 51 + 6 * (depth - 8);
569  for (i = 0; i < max_qp + 1; i++)
570  pps->chroma_qp_table[t][i] =
571  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
572 }
573 
575 {
576  const SPS *sps = h->sps_buffers[pps->sps_id];
577  int profile_idc = sps->profile_idc;
578 
579  if ((profile_idc == 66 || profile_idc == 77 ||
580  profile_idc == 88) && (sps->constraint_set_flags & 7)) {
582  "Current profile doesn't provide more RBSP data in PPS, skipping\n");
583  return 0;
584  }
585 
586  return 1;
587 }
588 
590 {
591  const SPS *sps;
592  unsigned int pps_id = get_ue_golomb(&h->gb);
593  PPS *pps;
594  int qp_bd_offset;
595  int bits_left;
596  int ret;
597 
598  if (pps_id >= MAX_PPS_COUNT) {
599  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
600  return AVERROR_INVALIDDATA;
601  }
602 
603  pps = av_mallocz(sizeof(PPS));
604  if (!pps)
605  return AVERROR(ENOMEM);
606  pps->sps_id = get_ue_golomb_31(&h->gb);
607  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
608  !h->sps_buffers[pps->sps_id]) {
609  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
610  ret = AVERROR_INVALIDDATA;
611  goto fail;
612  }
613  sps = h->sps_buffers[pps->sps_id];
614  if (sps->bit_depth_luma > 14) {
616  "Invalid luma bit depth=%d\n",
617  sps->bit_depth_luma);
618  ret = AVERROR_INVALIDDATA;
619  goto fail;
620  } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
622  "Unimplemented luma bit depth=%d\n",
623  sps->bit_depth_luma);
624  ret = AVERROR_PATCHWELCOME;
625  goto fail;
626  }
627 
628  pps->cabac = get_bits1(&h->gb);
629  pps->pic_order_present = get_bits1(&h->gb);
630  pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
631  if (pps->slice_group_count > 1) {
633  av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
634  switch (pps->mb_slice_group_map_type) {
635  case 0:
636 #if 0
637  | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
638  | run_length[i] |1 |ue(v) |
639 #endif
640  break;
641  case 2:
642 #if 0
643  | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
644  | top_left_mb[i] |1 |ue(v) |
645  | bottom_right_mb[i] |1 |ue(v) |
646  | } | | |
647 #endif
648  break;
649  case 3:
650  case 4:
651  case 5:
652 #if 0
653  | slice_group_change_direction_flag |1 |u(1) |
654  | slice_group_change_rate_minus1 |1 |ue(v) |
655 #endif
656  break;
657  case 6:
658 #if 0
659  | slice_group_id_cnt_minus1 |1 |ue(v) |
660  | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
661  | slice_group_id[i] |1 |u(v) |
662 #endif
663  break;
664  }
665  }
666  pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
667  pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
668  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
669  av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
670  ret = AVERROR_INVALIDDATA;
671  goto fail;
672  }
673 
674  qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
675 
676  pps->weighted_pred = get_bits1(&h->gb);
677  pps->weighted_bipred_idc = get_bits(&h->gb, 2);
678  pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
679  pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
680  pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
682  pps->constrained_intra_pred = get_bits1(&h->gb);
684 
685  pps->transform_8x8_mode = 0;
686  // contents of sps/pps can change even if id doesn't, so reinit
687  h->dequant_coeff_pps = -1;
688  memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
689  sizeof(pps->scaling_matrix4));
690  memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
691  sizeof(pps->scaling_matrix8));
692 
693  bits_left = bit_length - get_bits_count(&h->gb);
694  if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
695  pps->transform_8x8_mode = get_bits1(&h->gb);
696  decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
697  pps->scaling_matrix4, pps->scaling_matrix8);
698  // second_chroma_qp_index_offset
699  pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
700  } else {
702  }
703 
704  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
705  sps->bit_depth_luma);
706  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
707  sps->bit_depth_luma);
708  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
709  pps->chroma_qp_diff = 1;
710 
711  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
713  "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
714  pps_id, pps->sps_id,
715  pps->cabac ? "CABAC" : "CAVLC",
716  pps->slice_group_count,
717  pps->ref_count[0], pps->ref_count[1],
718  pps->weighted_pred ? "weighted" : "",
719  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
720  pps->deblocking_filter_parameters_present ? "LPAR" : "",
721  pps->constrained_intra_pred ? "CONSTR" : "",
722  pps->redundant_pic_cnt_present ? "REDU" : "",
723  pps->transform_8x8_mode ? "8x8DCT" : "");
724  }
725 
726  av_free(h->pps_buffers[pps_id]);
727  h->pps_buffers[pps_id] = pps;
728  return 0;
729 
730 fail:
731  av_free(pps);
732  return ret;
733 }
int chroma_format_idc
Definition: h264.h:178
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:324
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:37
int video_signal_type_present_flag
Definition: h264.h:203
#define NULL
Definition: coverity.c:32
float v
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
GetBitContext gb
Definition: h264.h:524
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
#define H264_MAX_PICTURE_COUNT
Definition: h264.h:46
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:245
int chroma_qp_index_offset[2]
Definition: h264.h:248
int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
Decode SPS.
Definition: h264_ps.c:303
int scaling_matrix_present
Definition: h264.h:216
uint8_t scaling_matrix4[6][16]
Definition: h264.h:217
#define MAX_PPS_COUNT
Definition: h264.h:50
Sequence parameter set.
Definition: h264.h:174
int bitstream_restriction_flag
Definition: h264.h:214
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:243
int num
numerator
Definition: rational.h:44
Picture parameter set.
Definition: h264.h:237
int frame_mbs_only_flag
Definition: h264.h:191
H264Context.
Definition: h264.h:517
int chroma_qp_diff
Definition: h264.h:256
uint32_t num_units_in_tick
Definition: h264.h:210
int profile_idc
Definition: h264.h:176
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264.h:199
int fixed_frame_rate_flag
Definition: h264.h:212
uint8_t scaling_matrix4[6][16]
Definition: h264.h:253
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264.h:249
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:204
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264.h:197
int offset_for_non_ref_pic
Definition: h264.h:184
int gaps_in_frame_num_allowed_flag
Definition: h264.h:188
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264.h:228
enum AVColorPrimaries color_primaries
Definition: h264.h:206
#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:239
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264.h:198
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264.h:179
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264.h:251
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
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:270
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2243
#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:588
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264.h:192
enum AVColorTransferCharacteristic color_trc
Definition: h264.h:207
#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 unsigned exp golomb code.
Definition: golomb.h:53
int poc_type
pic_order_cnt_type
Definition: h264.h:181
int constrained_intra_pred
constrained_intra_pred_flag
Definition: h264.h:250
int num_reorder_frames
Definition: h264.h:215
#define AVERROR(e)
Definition: error.h:43
int time_offset_length
Definition: h264.h:222
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
Not part of ABI.
Definition: pixfmt.h:476
#define EXTENDED_SAR
Definition: h264.h:101
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1596
int weighted_pred
weighted_pred_flag
Definition: h264.h:244
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:38
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264.h:229
#define FFMAX(a, b)
Definition: common.h:64
Libavcodec external API header.
#define fail()
Definition: checkasm.h:55
int delta_pic_order_always_zero_flag
Definition: h264.h:183
int new
flag to keep track if the decoder context needs re-init due to changed SPS
Definition: h264.h:231
int offset_for_top_to_bottom_field
Definition: h264.h:185
int depth
Definition: v4l.c:61
#define CHROMA_QP_TABLE_END(d)
Definition: h264_ps.c:42
int crop
frame_cropping_flag
Definition: h264.h:194
static int decode_hrd_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:110
uint8_t scaling_matrix8[6][64]
Definition: h264.h:254
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:241
int ref_frame_count
num_ref_frames
Definition: h264.h:187
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264.h:224
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264.h:186
int colour_description_present_flag
Definition: h264.h:205
AVRational sar
Definition: h264.h:202
ret
Definition: avfilter.c:974
PPS * pps_buffers[MAX_PPS_COUNT]
Definition: h264.h:639
#define MAX_SPS_COUNT
Definition: h264.h:49
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264.h:255
static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
Definition: h264_ps.c:574
int init_qp
pic_init_qp_minus26 + 26
Definition: h264.h:246
int direct_8x8_inference_flag
Definition: h264.h:193
float u
uint8_t scaling_matrix8[6][64]
Definition: h264.h:218
unsigned int sps_id
Definition: h264.h:175
#define FF_ARRAY_ELEMS(a)
int dequant_coeff_pps
reinit tables when pps changes
Definition: h264.h:641
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:240
SPS * sps_buffers[MAX_SPS_COUNT]
Definition: h264.h:638
short offset_for_ref_frame[256]
Definition: h264.h:213
int timing_info_present_flag
Definition: h264.h:209
int vcl_hrd_parameters_present_flag
Definition: h264.h:220
AVCodecContext * avctx
Definition: h264.h:519
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:2841
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264.h:226
int vui_parameters_present_flag
Definition: h264.h:201
static int decode_vui_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:135
#define QP_MAX_NUM
Definition: h264.h:108
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1533
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264.h:230
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
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:297
int index
Definition: gxfenc.c:89
Not part of ABI.
Definition: pixfmt.h:499
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:117
unsigned int sps_id
Definition: h264.h:238
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264.h:182
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
uint32_t time_scale
Definition: h264.h:211
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:252
int pic_struct_present_flag
Definition: h264.h:221
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
Decode PPS.
Definition: h264_ps.c:589
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2842
int mb_height
pic_height_in_map_units_minus1 + 1
Definition: h264.h:190
int init_qs
pic_init_qs_minus26 + 26
Definition: h264.h:247
common internal api header.
int nal_hrd_parameters_present_flag
Definition: h264.h:219
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264.h:180
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:227
#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:189
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1603
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264.h:241
int cpb_cnt
See H.264 E.1.2.
Definition: h264.h:223
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:250
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:225
#define MKTAG(a, b, c, d)
Definition: common.h:315
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264.h:200
exp golomb vlc stuff
int level_idc
Definition: h264.h:177
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:517
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:565
static int width
int mb_slice_group_map_type
Definition: h264.h:242
enum AVColorSpace colorspace
Definition: h264.h:208