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