FFmpeg  2.1.1
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 "libavutil/imgutils.h"
29 #include "internal.h"
30 #include "avcodec.h"
31 #include "h264.h"
32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
33 #include "golomb.h"
34 
35 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
36 #define MIN_LOG2_MAX_FRAME_NUM 4
37 
38 static const AVRational pixel_aspect[17] = {
39  { 0, 1 },
40  { 1, 1 },
41  { 12, 11 },
42  { 10, 11 },
43  { 16, 11 },
44  { 40, 33 },
45  { 24, 11 },
46  { 20, 11 },
47  { 32, 11 },
48  { 80, 33 },
49  { 18, 11 },
50  { 15, 11 },
51  { 64, 33 },
52  { 160, 99 },
53  { 4, 3 },
54  { 3, 2 },
55  { 2, 1 },
56 };
57 
58 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
59 
60 #define CHROMA_QP_TABLE_END(d) \
61  QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
62  QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
63  QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
64  QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
65  QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
66  QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
67  QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
68  QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
69  QP(39, d), QP(39, d), QP(39, d), QP(39, d)
70 
72  { CHROMA_QP_TABLE_END(8) },
73  { 0, 1, 2, 3, 4, 5,
75  { 0, 1, 2, 3, 4, 5,
76  6, 7, 8, 9, 10, 11,
77  CHROMA_QP_TABLE_END(10) },
78  { 0, 1, 2, 3, 4, 5,
79  6, 7, 8, 9, 10, 11,
80  12,13,14,15, 16, 17,
81  CHROMA_QP_TABLE_END(11) },
82  { 0, 1, 2, 3, 4, 5,
83  6, 7, 8, 9, 10, 11,
84  12,13,14,15, 16, 17,
85  18,19,20,21, 22, 23,
86  CHROMA_QP_TABLE_END(12) },
87  { 0, 1, 2, 3, 4, 5,
88  6, 7, 8, 9, 10, 11,
89  12,13,14,15, 16, 17,
90  18,19,20,21, 22, 23,
91  24,25,26,27, 28, 29,
92  CHROMA_QP_TABLE_END(13) },
93  { 0, 1, 2, 3, 4, 5,
94  6, 7, 8, 9, 10, 11,
95  12,13,14,15, 16, 17,
96  18,19,20,21, 22, 23,
97  24,25,26,27, 28, 29,
98  30,31,32,33, 34, 35,
99  CHROMA_QP_TABLE_END(14) },
100 };
101 
102 static const uint8_t default_scaling4[2][16] = {
103  { 6, 13, 20, 28, 13, 20, 28, 32,
104  20, 28, 32, 37, 28, 32, 37, 42 },
105  { 10, 14, 20, 24, 14, 20, 24, 27,
106  20, 24, 27, 30, 24, 27, 30, 34 }
107 };
108 
109 static const uint8_t default_scaling8[2][64] = {
110  { 6, 10, 13, 16, 18, 23, 25, 27,
111  10, 11, 16, 18, 23, 25, 27, 29,
112  13, 16, 18, 23, 25, 27, 29, 31,
113  16, 18, 23, 25, 27, 29, 31, 33,
114  18, 23, 25, 27, 29, 31, 33, 36,
115  23, 25, 27, 29, 31, 33, 36, 38,
116  25, 27, 29, 31, 33, 36, 38, 40,
117  27, 29, 31, 33, 36, 38, 40, 42 },
118  { 9, 13, 15, 17, 19, 21, 22, 24,
119  13, 13, 17, 19, 21, 22, 24, 25,
120  15, 17, 19, 21, 22, 24, 25, 27,
121  17, 19, 21, 22, 24, 25, 27, 28,
122  19, 21, 22, 24, 25, 27, 28, 30,
123  21, 22, 24, 25, 27, 28, 30, 32,
124  22, 24, 25, 27, 28, 30, 32, 33,
125  24, 25, 27, 28, 30, 32, 33, 35 }
126 };
127 
128 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
129 {
130  int cpb_count, i;
131  cpb_count = get_ue_golomb_31(&h->gb) + 1;
132 
133  if (cpb_count > 32U) {
134  av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
135  return AVERROR_INVALIDDATA;
136  }
137 
138  get_bits(&h->gb, 4); /* bit_rate_scale */
139  get_bits(&h->gb, 4); /* cpb_size_scale */
140  for (i = 0; i < cpb_count; i++) {
141  get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
142  get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
143  get_bits1(&h->gb); /* cbr_flag */
144  }
145  sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
146  sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
147  sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
148  sps->time_offset_length = get_bits(&h->gb, 5);
149  sps->cpb_cnt = cpb_count;
150  return 0;
151 }
152 
153 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
154 {
155  int aspect_ratio_info_present_flag;
156  unsigned int aspect_ratio_idc;
157 
158  aspect_ratio_info_present_flag = get_bits1(&h->gb);
159 
160  if (aspect_ratio_info_present_flag) {
161  aspect_ratio_idc = get_bits(&h->gb, 8);
162  if (aspect_ratio_idc == EXTENDED_SAR) {
163  sps->sar.num = get_bits(&h->gb, 16);
164  sps->sar.den = get_bits(&h->gb, 16);
165  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
166  sps->sar = pixel_aspect[aspect_ratio_idc];
167  } else {
168  av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
169  return AVERROR_INVALIDDATA;
170  }
171  } else {
172  sps->sar.num =
173  sps->sar.den = 0;
174  }
175 
176  if (get_bits1(&h->gb)) /* overscan_info_present_flag */
177  get_bits1(&h->gb); /* overscan_appropriate_flag */
178 
181  get_bits(&h->gb, 3); /* video_format */
182  sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
183 
186  sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
187  sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
188  sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
189  if (sps->color_primaries >= AVCOL_PRI_NB)
191  if (sps->color_trc >= AVCOL_TRC_NB)
193  if (sps->colorspace >= AVCOL_SPC_NB)
195  }
196  }
197 
198  /* chroma_location_info_present_flag */
199  if (get_bits1(&h->gb)) {
200  /* chroma_sample_location_type_top_field */
202  get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
203  }
204 
205  if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
206  av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
207  return 0;
208  }
209 
211  if (sps->timing_info_present_flag) {
212  sps->num_units_in_tick = get_bits_long(&h->gb, 32);
213  sps->time_scale = get_bits_long(&h->gb, 32);
214  if (!sps->num_units_in_tick || !sps->time_scale) {
216  "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n",
217  sps->time_scale, sps->num_units_in_tick);
218  return AVERROR_INVALIDDATA;
219  }
220  sps->fixed_frame_rate_flag = get_bits1(&h->gb);
221  }
222 
225  if (decode_hrd_parameters(h, sps) < 0)
226  return AVERROR_INVALIDDATA;
229  if (decode_hrd_parameters(h, sps) < 0)
230  return AVERROR_INVALIDDATA;
233  get_bits1(&h->gb); /* low_delay_hrd_flag */
235  if (!get_bits_left(&h->gb))
236  return 0;
238  if (sps->bitstream_restriction_flag) {
239  get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
240  get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
241  get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
242  get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
243  get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
244  sps->num_reorder_frames = get_ue_golomb(&h->gb);
245  get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
246 
247  if (get_bits_left(&h->gb) < 0) {
248  sps->num_reorder_frames = 0;
250  }
251 
252  if (sps->num_reorder_frames > 16U
253  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
255  "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
256  return AVERROR_INVALIDDATA;
257  }
258  }
259 
260  if (get_bits_left(&h->gb) < 0) {
262  "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
263  return AVERROR_INVALIDDATA;
264  }
265 
266  return 0;
267 }
268 
269 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
270  const uint8_t *jvt_list,
271  const uint8_t *fallback_list)
272 {
273  int i, last = 8, next = 8;
274  const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
275  if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
276  memcpy(factors, fallback_list, size * sizeof(uint8_t));
277  else
278  for (i = 0; i < size; i++) {
279  if (next)
280  next = (last + get_se_golomb(&h->gb)) & 0xff;
281  if (!i && !next) { /* matrix not written, we use the preset one */
282  memcpy(factors, jvt_list, size * sizeof(uint8_t));
283  break;
284  }
285  last = factors[scan[i]] = next ? next : last;
286  }
287 }
288 
290  PPS *pps, int is_sps,
291  uint8_t(*scaling_matrix4)[16],
292  uint8_t(*scaling_matrix8)[64])
293 {
294  int fallback_sps = !is_sps && sps->scaling_matrix_present;
295  const uint8_t *fallback[4] = {
296  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
297  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
298  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
299  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
300  };
301  if (get_bits1(&h->gb)) {
302  sps->scaling_matrix_present |= is_sps;
303  decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
304  decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
305  decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
306  decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
307  decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
308  decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
309  if (is_sps || pps->transform_8x8_mode) {
310  decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
311  decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
312  if (sps->chroma_format_idc == 3) {
313  decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
314  decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
315  decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
316  decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
317  }
318  }
319  }
320 }
321 
323 {
324  int profile_idc, level_idc, constraint_set_flags = 0;
325  unsigned int sps_id;
326  int i, log2_max_frame_num_minus4;
327  SPS *sps;
328 
329  profile_idc = get_bits(&h->gb, 8);
330  constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
331  constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
332  constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
333  constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
334  constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
335  constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
336  get_bits(&h->gb, 2); // reserved
337  level_idc = get_bits(&h->gb, 8);
338  sps_id = get_ue_golomb_31(&h->gb);
339 
340  if (sps_id >= MAX_SPS_COUNT) {
341  av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
342  return AVERROR_INVALIDDATA;
343  }
344  sps = av_mallocz(sizeof(SPS));
345  if (!sps)
346  return AVERROR(ENOMEM);
347 
348  sps->time_offset_length = 24;
349  sps->profile_idc = profile_idc;
350  sps->constraint_set_flags = constraint_set_flags;
351  sps->level_idc = level_idc;
352  sps->full_range = -1;
353 
354  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
355  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
356  sps->scaling_matrix_present = 0;
357  sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
358 
359  if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
360  sps->profile_idc == 122 || sps->profile_idc == 244 ||
361  sps->profile_idc == 44 || sps->profile_idc == 83 ||
362  sps->profile_idc == 86 || sps->profile_idc == 118 ||
363  sps->profile_idc == 128 || sps->profile_idc == 144) {
365  if (sps->chroma_format_idc > 3U) {
367  "chroma_format_idc %d is illegal\n",
368  sps->chroma_format_idc);
369  goto fail;
370  } else if (sps->chroma_format_idc == 3) {
373  av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
374  goto fail;
375  }
376  }
377  sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
378  sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
379  if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U || sps->bit_depth_luma != sps->bit_depth_chroma) {
380  av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
381  sps->bit_depth_luma, sps->bit_depth_chroma);
382  goto fail;
383  }
384  sps->transform_bypass = get_bits1(&h->gb);
385  decode_scaling_matrices(h, sps, NULL, 1,
386  sps->scaling_matrix4, sps->scaling_matrix8);
387  } else {
388  sps->chroma_format_idc = 1;
389  sps->bit_depth_luma = 8;
390  sps->bit_depth_chroma = 8;
391  }
392 
393  log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
394  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
395  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
397  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
398  log2_max_frame_num_minus4);
399  goto fail;
400  }
401  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
402 
403  sps->poc_type = get_ue_golomb_31(&h->gb);
404 
405  if (sps->poc_type == 0) { // FIXME #define
406  unsigned t = get_ue_golomb(&h->gb);
407  if (t>12) {
408  av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
409  goto fail;
410  }
411  sps->log2_max_poc_lsb = t + 4;
412  } else if (sps->poc_type == 1) { // FIXME #define
416  sps->poc_cycle_length = get_ue_golomb(&h->gb);
417 
418  if ((unsigned)sps->poc_cycle_length >=
421  "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
422  goto fail;
423  }
424 
425  for (i = 0; i < sps->poc_cycle_length; i++)
426  sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
427  } else if (sps->poc_type != 2) {
428  av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
429  goto fail;
430  }
431 
432  sps->ref_frame_count = get_ue_golomb_31(&h->gb);
433  if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
434  sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
435  if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
436  sps->ref_frame_count > 16U) {
437  av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
438  goto fail;
439  }
441  sps->mb_width = get_ue_golomb(&h->gb) + 1;
442  sps->mb_height = get_ue_golomb(&h->gb) + 1;
443  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
444  (unsigned)sps->mb_height >= INT_MAX / 16 ||
445  av_image_check_size(16 * sps->mb_width,
446  16 * sps->mb_height, 0, h->avctx)) {
447  av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
448  goto fail;
449  }
450 
451  sps->frame_mbs_only_flag = get_bits1(&h->gb);
452  if (!sps->frame_mbs_only_flag)
453  sps->mb_aff = get_bits1(&h->gb);
454  else
455  sps->mb_aff = 0;
456 
458 
459 #ifndef ALLOW_INTERLACE
460  if (sps->mb_aff)
462  "MBAFF support not included; enable it at compile-time.\n");
463 #endif
464  sps->crop = get_bits1(&h->gb);
465  if (sps->crop) {
466  int crop_left = get_ue_golomb(&h->gb);
467  int crop_right = get_ue_golomb(&h->gb);
468  int crop_top = get_ue_golomb(&h->gb);
469  int crop_bottom = get_ue_golomb(&h->gb);
470  int width = 16 * sps->mb_width;
471  int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
472 
474  av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
475  "values are l:%u r:%u t:%u b:%u\n",
476  crop_left, crop_right, crop_top, crop_bottom);
477 
478  sps->crop_left =
479  sps->crop_right =
480  sps->crop_top =
481  sps->crop_bottom = 0;
482  } else {
483  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
484  int hsub = (sps->chroma_format_idc == 1 ||
485  sps->chroma_format_idc == 2) ? 1 : 0;
486  int step_x = 1 << hsub;
487  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
488 
489  if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
490  !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
491  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
493  "Reducing left cropping to %d "
494  "chroma samples to preserve alignment.\n",
495  crop_left);
496  }
497 
498  if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
499  crop_right > (unsigned)INT_MAX / 4 / step_x ||
500  crop_top > (unsigned)INT_MAX / 4 / step_y ||
501  crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
502  (crop_left + crop_right ) * step_x >= width ||
503  (crop_top + crop_bottom) * step_y >= height
504  ) {
505  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);
506  goto fail;
507  }
508 
509  sps->crop_left = crop_left * step_x;
510  sps->crop_right = crop_right * step_x;
511  sps->crop_top = crop_top * step_y;
512  sps->crop_bottom = crop_bottom * step_y;
513  }
514  } else {
515  sps->crop_left =
516  sps->crop_right =
517  sps->crop_top =
518  sps->crop_bottom =
519  sps->crop = 0;
520  }
521 
524  if (decode_vui_parameters(h, sps) < 0)
525  goto fail;
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:%d/%d/%d/%d %s %s %d/%d 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 (%d) 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] == NULL) {
605  av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
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:%d/%d %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:168
static unsigned int show_bits1(GetBitContext *s)
Definition: get_bits.h:319
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:35
int video_signal_type_present_flag
Definition: h264.h:193
int ff_h264_decode_seq_parameter_set(H264Context *h)
Decode SPS.
Definition: h264_ps.c:322
float v
#define MAX_PICTURE_COUNT
Definition: mpegvideo.h:66
GetBitContext gb
Definition: h264.h:294
int size
#define CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Definition: avcodec.h:691
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:255
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: avcodec.h:4153
#define CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:724
int weighted_bipred_idc
Definition: h264.h:235
int chroma_qp_index_offset[2]
Definition: h264.h:238
int scaling_matrix_present
Definition: h264.h:206
uint8_t scaling_matrix4[6][16]
Definition: h264.h:207
#define MAX_PPS_COUNT
Definition: h264.h:43
Sequence parameter set.
Definition: h264.h:165
int bitstream_restriction_flag
Definition: h264.h:204
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:233
int num
numerator
Definition: rational.h:44
Picture parameter set.
Definition: h264.h:227
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int frame_mbs_only_flag
Definition: h264.h:181
H264Context.
Definition: h264.h:286
int chroma_qp_diff
Definition: h264.h:246
uint32_t num_units_in_tick
Definition: h264.h:200
static const AVRational pixel_aspect[17]
Definition: h264_ps.c:38
Not part of ABI.
Definition: avcodec.h:629
int profile_idc
Definition: h264.h:166
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264.h:189
int fixed_frame_rate_flag
Definition: h264.h:202
uint8_t scaling_matrix4[6][16]
Definition: h264.h:243
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264.h:239
uint8_t
int full_range
Definition: h264.h:194
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264.h:187
int offset_for_non_ref_pic
Definition: h264.h:174
int gaps_in_frame_num_allowed_flag
Definition: h264.h:178
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264.h:218
enum AVColorPrimaries color_primaries
Definition: h264.h:196
int cabac
entropy_coding_mode_flag
Definition: h264.h:229
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264.h:188
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264.h:169
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:207
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264.h:241
#define AV_LOG_VERBOSE
Detailed information.
Definition: avcodec.h:4163
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:289
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1855
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:583
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:71
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264.h:182
enum AVColorTransferCharacteristic color_trc
Definition: h264.h:197
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:219
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:171
int constrained_intra_pred
constrained_intra_pred_flag
Definition: h264.h:240
int num_reorder_frames
Definition: h264.h:205
int time_offset_length
Definition: h264.h:212
Not part of ABI.
Definition: frame.h:42
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: avcodec.h:4168
#define EXTENDED_SAR
Definition: h264.h:94
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1234
int weighted_pred
weighted_pred_flag
Definition: h264.h:234
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:36
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264.h:219
Libavcodec external API header.
int delta_pic_order_always_zero_flag
Definition: h264.h:173
int new
flag to keep track if the decoder context needs re-init due to changed SPS
Definition: h264.h:221
int offset_for_top_to_bottom_field
Definition: h264.h:175
int depth
Definition: v4l.c:61
#define CHROMA_QP_TABLE_END(d)
Definition: h264_ps.c:60
int crop
frame_cropping_flag
Definition: h264.h:184
goto fail
Definition: avfilter.c:963
static int decode_hrd_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:128
uint8_t scaling_matrix8[6][64]
Definition: h264.h:244
#define FF_ARRAY_ELEMS(a)
Definition: avcodec.h:929
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:231
int ref_frame_count
num_ref_frames
Definition: h264.h:177
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264.h:214
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264.h:176
int colour_description_present_flag
Definition: h264.h:195
AVRational sar
Definition: h264.h:192
SPS sps
current sps
Definition: h264.h:386
PPS * pps_buffers[MAX_PPS_COUNT]
Definition: h264.h:522
#define MAX_SPS_COUNT
Definition: h264.h:42
uint8_t chroma_qp_table[2][QP_MAX_NUM+1]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264.h:245
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
Decode PPS.
Definition: h264_ps.c:586
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:236
int direct_8x8_inference_flag
Definition: h264.h:183
float u
uint8_t scaling_matrix8[6][64]
Definition: h264.h:208
int dequant_coeff_pps
reinit tables when pps changes
Definition: h264.h:524
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:230
SPS * sps_buffers[MAX_SPS_COUNT]
Definition: h264.h:521
short offset_for_ref_frame[256]
Definition: h264.h:203
int timing_info_present_flag
Definition: h264.h:199
static int width
Definition: utils.c:158
int vcl_hrd_parameters_present_flag
Definition: h264.h:210
AVCodecContext * avctx
Definition: h264.h:287
H264 / AVC / MPEG4 part10 codec data table
#define FFMAX(a, b)
Definition: avcodec.h:923
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:55
int debug
debug
Definition: avcodec.h:2442
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264.h:216
int vui_parameters_present_flag
Definition: h264.h:191
static int decode_vui_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:153
#define QP_MAX_NUM
Definition: h264.h:101
unsigned int codec_tag
fourcc (LSB first, so &quot;ABCD&quot; -&gt; (&#39;D&#39;&lt;&lt;24) + (&#39;C&#39;&lt;&lt;16) + (&#39;B&#39;&lt;&lt;8) + &#39;A&#39;).
Definition: avcodec.h:1172
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264.h:220
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
BYTE int const BYTE int int int height
Definition: avisynth_c.h:713
#define MKTAG(a, b, c, d)
int index
Definition: gxfenc.c:89
rational number numerator/denominator
Definition: rational.h:43
unsigned int sps_id
Definition: h264.h:228
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264.h:172
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:332
uint32_t time_scale
Definition: h264.h:201
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2443
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:242
int pic_struct_present_flag
Definition: h264.h:211
int mb_height
pic_height_in_map_units_minus1 + 1
Definition: h264.h:180
int init_qs
pic_init_qs_minus26 + 26
Definition: h264.h:237
static float t
Definition: muxing.c:123
common internal api header.
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:115
int nal_hrd_parameters_present_flag
Definition: h264.h:209
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264.h:170
static const uint8_t default_scaling4[2][16]
Definition: h264_ps.c:102
int den
denominator
Definition: rational.h:45
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:217
#define AVERROR_INVALIDDATA
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264.h:179
#define AVERROR(e)
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1241
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264.h:231
int cpb_cnt
See H.264 E.1.2.
Definition: h264.h:213
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:269
static const uint8_t default_scaling8[2][64]
Definition: h264_ps.c:109
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264.h:215
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264.h:190
exp golomb vlc stuff
int level_idc
Definition: h264.h:167
Not part of ABI.
Definition: avcodec.h:638
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:241
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:562
int mb_slice_group_map_type
Definition: h264.h:232
enum AVColorSpace colorspace
Definition: h264.h:198