Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
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 };
79 
80 static const uint8_t default_scaling4[2][16] = {
81  { 6, 13, 20, 28, 13, 20, 28, 32,
82  20, 28, 32, 37, 28, 32, 37, 42 },
83  { 10, 14, 20, 24, 14, 20, 24, 27,
84  20, 24, 27, 30, 24, 27, 30, 34 }
85 };
86 
87 static const uint8_t default_scaling8[2][64] = {
88  { 6, 10, 13, 16, 18, 23, 25, 27,
89  10, 11, 16, 18, 23, 25, 27, 29,
90  13, 16, 18, 23, 25, 27, 29, 31,
91  16, 18, 23, 25, 27, 29, 31, 33,
92  18, 23, 25, 27, 29, 31, 33, 36,
93  23, 25, 27, 29, 31, 33, 36, 38,
94  25, 27, 29, 31, 33, 36, 38, 40,
95  27, 29, 31, 33, 36, 38, 40, 42 },
96  { 9, 13, 15, 17, 19, 21, 22, 24,
97  13, 13, 17, 19, 21, 22, 24, 25,
98  15, 17, 19, 21, 22, 24, 25, 27,
99  17, 19, 21, 22, 24, 25, 27, 28,
100  19, 21, 22, 24, 25, 27, 28, 30,
101  21, 22, 24, 25, 27, 28, 30, 32,
102  22, 24, 25, 27, 28, 30, 32, 33,
103  24, 25, 27, 28, 30, 32, 33, 35 }
104 };
105 
106 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
107 {
108  int cpb_count, i;
109  cpb_count = get_ue_golomb_31(&h->gb) + 1;
110 
111  if (cpb_count > 32U) {
112  av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
113  return AVERROR_INVALIDDATA;
114  }
115 
116  get_bits(&h->gb, 4); /* bit_rate_scale */
117  get_bits(&h->gb, 4); /* cpb_size_scale */
118  for (i = 0; i < cpb_count; i++) {
119  get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
120  get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
121  get_bits1(&h->gb); /* cbr_flag */
122  }
123  sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
124  sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
125  sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
126  sps->time_offset_length = get_bits(&h->gb, 5);
127  sps->cpb_cnt = cpb_count;
128  return 0;
129 }
130 
131 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
132 {
133  int aspect_ratio_info_present_flag;
134  unsigned int aspect_ratio_idc;
135 
136  aspect_ratio_info_present_flag = get_bits1(&h->gb);
137 
138  if (aspect_ratio_info_present_flag) {
139  aspect_ratio_idc = get_bits(&h->gb, 8);
140  if (aspect_ratio_idc == EXTENDED_SAR) {
141  sps->sar.num = get_bits(&h->gb, 16);
142  sps->sar.den = get_bits(&h->gb, 16);
143  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
144  sps->sar = pixel_aspect[aspect_ratio_idc];
145  } else {
146  av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
147  return AVERROR_INVALIDDATA;
148  }
149  } else {
150  sps->sar.num =
151  sps->sar.den = 0;
152  }
153 
154  if (get_bits1(&h->gb)) /* overscan_info_present_flag */
155  get_bits1(&h->gb); /* overscan_appropriate_flag */
156 
159  get_bits(&h->gb, 3); /* video_format */
160  sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
161 
164  sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
165  sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
166  sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
167  if (sps->color_primaries >= AVCOL_PRI_NB)
169  if (sps->color_trc >= AVCOL_TRC_NB)
171  if (sps->colorspace >= AVCOL_SPC_NB)
173  }
174  }
175 
176  /* chroma_location_info_present_flag */
177  if (get_bits1(&h->gb)) {
178  /* chroma_sample_location_type_top_field */
180  get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
181  }
182 
184  if (sps->timing_info_present_flag) {
185  sps->num_units_in_tick = get_bits_long(&h->gb, 32);
186  sps->time_scale = get_bits_long(&h->gb, 32);
187  if (!sps->num_units_in_tick || !sps->time_scale) {
189  "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n",
190  sps->time_scale, sps->num_units_in_tick);
191  return AVERROR_INVALIDDATA;
192  }
193  sps->fixed_frame_rate_flag = get_bits1(&h->gb);
194  }
195 
198  if (decode_hrd_parameters(h, sps) < 0)
199  return AVERROR_INVALIDDATA;
202  if (decode_hrd_parameters(h, sps) < 0)
203  return AVERROR_INVALIDDATA;
206  get_bits1(&h->gb); /* low_delay_hrd_flag */
208 
210  if (sps->bitstream_restriction_flag) {
211  get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
212  get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
213  get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
214  get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
215  get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
216  sps->num_reorder_frames = get_ue_golomb(&h->gb);
217  get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
218 
219  if (get_bits_left(&h->gb) < 0) {
220  sps->num_reorder_frames = 0;
222  }
223 
224  if (sps->num_reorder_frames > 16U
225  /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
227  "Clipping illegal num_reorder_frames %d\n",
228  sps->num_reorder_frames);
229  sps->num_reorder_frames = 16;
230  return AVERROR_INVALIDDATA;
231  }
232  }
233  if (get_bits_left(&h->gb) < 0) {
235  "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
236  return AVERROR_INVALIDDATA;
237  }
238 
239  return 0;
240 }
241 
242 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
243  const uint8_t *jvt_list,
244  const uint8_t *fallback_list)
245 {
246  int i, last = 8, next = 8;
247  const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
248  if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
249  memcpy(factors, fallback_list, size * sizeof(uint8_t));
250  else
251  for (i = 0; i < size; i++) {
252  if (next)
253  next = (last + get_se_golomb(&h->gb)) & 0xff;
254  if (!i && !next) { /* matrix not written, we use the preset one */
255  memcpy(factors, jvt_list, size * sizeof(uint8_t));
256  break;
257  }
258  last = factors[scan[i]] = next ? next : last;
259  }
260 }
261 
263  PPS *pps, int is_sps,
264  uint8_t(*scaling_matrix4)[16],
265  uint8_t(*scaling_matrix8)[64])
266 {
267  int fallback_sps = !is_sps && sps->scaling_matrix_present;
268  const uint8_t *fallback[4] = {
269  fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
270  fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
271  fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
272  fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
273  };
274  if (get_bits1(&h->gb)) {
275  sps->scaling_matrix_present |= is_sps;
276  decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
277  decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
278  decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
279  decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
280  decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
281  decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
282  if (is_sps || pps->transform_8x8_mode) {
283  decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
284  if (sps->chroma_format_idc == 3) {
285  decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
286  decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
287  }
288  decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
289  if (sps->chroma_format_idc == 3) {
290  decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
291  decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
292  }
293  }
294  }
295 }
296 
298 {
299  int profile_idc, level_idc, constraint_set_flags = 0;
300  unsigned int sps_id;
301  int i, log2_max_frame_num_minus4;
302  SPS *sps;
303 
304  profile_idc = get_bits(&h->gb, 8);
305  constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
306  constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
307  constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
308  constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
309  get_bits(&h->gb, 4); // reserved
310  level_idc = get_bits(&h->gb, 8);
311  sps_id = get_ue_golomb_31(&h->gb);
312 
313  if (sps_id >= MAX_SPS_COUNT) {
314  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
315  return AVERROR_INVALIDDATA;
316  }
317  sps = av_mallocz(sizeof(SPS));
318  if (!sps)
319  return AVERROR(ENOMEM);
320 
321  sps->sps_id = sps_id;
322  sps->time_offset_length = 24;
323  sps->profile_idc = profile_idc;
324  sps->constraint_set_flags = constraint_set_flags;
325  sps->level_idc = level_idc;
326 
327  memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
328  memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
329  sps->scaling_matrix_present = 0;
330 
331  if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
332  sps->profile_idc == 122 || sps->profile_idc == 244 ||
333  sps->profile_idc == 44 || sps->profile_idc == 83 ||
334  sps->profile_idc == 86 || sps->profile_idc == 118 ||
335  sps->profile_idc == 128 || sps->profile_idc == 144) {
337  if (sps->chroma_format_idc > 3) {
338  avpriv_request_sample(h->avctx, "chroma_format_idc %u",
339  sps->chroma_format_idc);
340  goto fail;
341  } else if (sps->chroma_format_idc == 3) {
343  }
344  sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
345  sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
346  if (sps->bit_depth_chroma != sps->bit_depth_luma) {
348  "Different chroma and luma bit depth");
349  goto fail;
350  }
351  sps->transform_bypass = get_bits1(&h->gb);
352  decode_scaling_matrices(h, sps, NULL, 1,
353  sps->scaling_matrix4, sps->scaling_matrix8);
354  } else {
355  sps->chroma_format_idc = 1;
356  sps->bit_depth_luma = 8;
357  sps->bit_depth_chroma = 8;
358  }
359 
360  log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
361  if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
362  log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
364  "log2_max_frame_num_minus4 out of range (0-12): %d\n",
365  log2_max_frame_num_minus4);
366  goto fail;
367  }
368  sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
369 
370  sps->poc_type = get_ue_golomb_31(&h->gb);
371 
372  if (sps->poc_type == 0) { // FIXME #define
373  sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
374  } else if (sps->poc_type == 1) { // FIXME #define
378  sps->poc_cycle_length = get_ue_golomb(&h->gb);
379 
380  if ((unsigned)sps->poc_cycle_length >=
383  "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
384  goto fail;
385  }
386 
387  for (i = 0; i < sps->poc_cycle_length; i++)
388  sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
389  } else if (sps->poc_type != 2) {
390  av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
391  goto fail;
392  }
393 
394  sps->ref_frame_count = get_ue_golomb_31(&h->gb);
395  if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
396  sps->ref_frame_count >= 32U) {
398  "too many reference frames %d\n", sps->ref_frame_count);
399  goto fail;
400  }
402  sps->mb_width = get_ue_golomb(&h->gb) + 1;
403  sps->mb_height = get_ue_golomb(&h->gb) + 1;
404  if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
405  (unsigned)sps->mb_height >= INT_MAX / 16 ||
406  av_image_check_size(16 * sps->mb_width,
407  16 * sps->mb_height, 0, h->avctx)) {
408  av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
409  goto fail;
410  }
411 
412  sps->frame_mbs_only_flag = get_bits1(&h->gb);
413  if (!sps->frame_mbs_only_flag)
414  sps->mb_aff = get_bits1(&h->gb);
415  else
416  sps->mb_aff = 0;
417 
419  if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
421  "This stream was generated by a broken encoder, invalid 8x8 inference\n");
422  goto fail;
423  }
424 
425 #ifndef ALLOW_INTERLACE
426  if (sps->mb_aff)
428  "MBAFF support not included; enable it at compile-time.\n");
429 #endif
430  sps->crop = get_bits1(&h->gb);
431  if (sps->crop) {
432  int crop_left = get_ue_golomb(&h->gb);
433  int crop_right = get_ue_golomb(&h->gb);
434  int crop_top = get_ue_golomb(&h->gb);
435  int crop_bottom = get_ue_golomb(&h->gb);
436 
438  av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
439  "values are l:%u r:%u t:%u b:%u\n",
440  crop_left, crop_right, crop_top, crop_bottom);
441 
442  sps->crop_left =
443  sps->crop_right =
444  sps->crop_top =
445  sps->crop_bottom = 0;
446  } else {
447  int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
448  int hsub = (sps->chroma_format_idc == 1 ||
449  sps->chroma_format_idc == 2) ? 1 : 0;
450  int step_x = 1 << hsub;
451  int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
452 
453  if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
454  !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
455  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
457  "Reducing left cropping to %d "
458  "chroma samples to preserve alignment.\n",
459  crop_left);
460  }
461 
462  sps->crop_left = crop_left * step_x;
463  sps->crop_right = crop_right * step_x;
464  sps->crop_top = crop_top * step_y;
465  sps->crop_bottom = crop_bottom * step_y;
466  }
467  } else {
468  sps->crop_left =
469  sps->crop_right =
470  sps->crop_top =
471  sps->crop_bottom =
472  sps->crop = 0;
473  }
474 
476  if (sps->vui_parameters_present_flag) {
477  int ret = decode_vui_parameters(h, sps);
478  if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
479  goto fail;
480  }
481 
482  if (!sps->sar.den)
483  sps->sar.den = 1;
484 
485  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
486  static const char csp[4][5] = { "Gray", "420", "422", "444" };
488  "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
489  sps_id, sps->profile_idc, sps->level_idc,
490  sps->poc_type,
491  sps->ref_frame_count,
492  sps->mb_width, sps->mb_height,
493  sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
494  sps->direct_8x8_inference_flag ? "8B8" : "",
495  sps->crop_left, sps->crop_right,
496  sps->crop_top, sps->crop_bottom,
497  sps->vui_parameters_present_flag ? "VUI" : "",
498  csp[sps->chroma_format_idc],
500  sps->timing_info_present_flag ? sps->time_scale : 0);
501  }
502  sps->new = 1;
503 
504  av_free(h->sps_buffers[sps_id]);
505  h->sps_buffers[sps_id] = sps;
506  h->sps = *sps;
507 
508  return 0;
509 
510 fail:
511  av_free(sps);
512  return -1;
513 }
514 
515 static void build_qp_table(PPS *pps, int t, int index, const int depth)
516 {
517  int i;
518  const int max_qp = 51 + 6 * (depth - 8);
519  for (i = 0; i < max_qp + 1; i++)
520  pps->chroma_qp_table[t][i] =
521  ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
522 }
523 
525 {
526  unsigned int pps_id = get_ue_golomb(&h->gb);
527  PPS *pps;
528  const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
529  int bits_left;
530 
531  if (pps_id >= MAX_PPS_COUNT) {
532  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
533  return AVERROR_INVALIDDATA;
534  } else if (h->sps.bit_depth_luma > 10) {
536  "Unimplemented luma bit depth=%d (max=10)\n",
537  h->sps.bit_depth_luma);
538  return AVERROR_PATCHWELCOME;
539  }
540 
541  pps = av_mallocz(sizeof(PPS));
542  if (!pps)
543  return AVERROR(ENOMEM);
544  pps->sps_id = get_ue_golomb_31(&h->gb);
545  if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
546  h->sps_buffers[pps->sps_id] == NULL) {
547  av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
548  goto fail;
549  }
550 
551  pps->cabac = get_bits1(&h->gb);
552  pps->pic_order_present = get_bits1(&h->gb);
553  pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
554  if (pps->slice_group_count > 1) {
556  av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
557  switch (pps->mb_slice_group_map_type) {
558  case 0:
559 #if 0
560  | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
561  | run_length[i] |1 |ue(v) |
562 #endif
563  break;
564  case 2:
565 #if 0
566  | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
567  | top_left_mb[i] |1 |ue(v) |
568  | bottom_right_mb[i] |1 |ue(v) |
569  | } | | |
570 #endif
571  break;
572  case 3:
573  case 4:
574  case 5:
575 #if 0
576  | slice_group_change_direction_flag |1 |u(1) |
577  | slice_group_change_rate_minus1 |1 |ue(v) |
578 #endif
579  break;
580  case 6:
581 #if 0
582  | slice_group_id_cnt_minus1 |1 |ue(v) |
583  | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
584  | slice_group_id[i] |1 |u(v) |
585 #endif
586  break;
587  }
588  }
589  pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
590  pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
591  if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
592  av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
593  goto fail;
594  }
595 
596  pps->weighted_pred = get_bits1(&h->gb);
597  pps->weighted_bipred_idc = get_bits(&h->gb, 2);
598  pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
599  pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
600  pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
602  pps->constrained_intra_pred = get_bits1(&h->gb);
604 
605  pps->transform_8x8_mode = 0;
606  // contents of sps/pps can change even if id doesn't, so reinit
607  h->dequant_coeff_pps = -1;
608  memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
609  sizeof(pps->scaling_matrix4));
610  memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
611  sizeof(pps->scaling_matrix8));
612 
613  bits_left = bit_length - get_bits_count(&h->gb);
614  if (bits_left && (bits_left > 8 ||
615  show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
616  pps->transform_8x8_mode = get_bits1(&h->gb);
617  decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
618  pps->scaling_matrix4, pps->scaling_matrix8);
619  // second_chroma_qp_index_offset
620  pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
621  } else {
623  }
624 
625  build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
626  h->sps.bit_depth_luma);
627  build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
628  h->sps.bit_depth_luma);
629  if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
630  pps->chroma_qp_diff = 1;
631 
632  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
634  "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
635  pps_id, pps->sps_id,
636  pps->cabac ? "CABAC" : "CAVLC",
637  pps->slice_group_count,
638  pps->ref_count[0], pps->ref_count[1],
639  pps->weighted_pred ? "weighted" : "",
640  pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
641  pps->deblocking_filter_parameters_present ? "LPAR" : "",
642  pps->constrained_intra_pred ? "CONSTR" : "",
643  pps->redundant_pic_cnt_present ? "REDU" : "",
644  pps->transform_8x8_mode ? "8x8DCT" : "");
645  }
646 
647  av_free(h->pps_buffers[pps_id]);
648  h->pps_buffers[pps_id] = pps;
649  return 0;
650 
651 fail:
652  av_free(pps);
653  return -1;
654 }
int chroma_format_idc
Definition: h264.h:152
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:35
int video_signal_type_present_flag
Definition: h264.h:177
#define MAX_PICTURE_COUNT
Definition: mpegvideo.h:66
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
GetBitContext gb
Definition: h264.h:267
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:655
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:179
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
#define CODEC_FLAG2_IGNORE_CROP
Discard cropping information from SPS.
Definition: avcodec.h:694
int weighted_bipred_idc
Definition: h264.h:219
int chroma_qp_index_offset[2]
Definition: h264.h:222
int scaling_matrix_present
Definition: h264.h:190
uint8_t scaling_matrix4[6][16]
Definition: h264.h:191
#define MAX_PPS_COUNT
Definition: h264.h:43
Sequence parameter set.
Definition: h264.h:148
int bitstream_restriction_flag
Definition: h264.h:188
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264.h:217
int num
numerator
Definition: rational.h:44
Picture parameter set.
Definition: h264.h:211
int frame_mbs_only_flag
Definition: h264.h:165
#define FF_ARRAY_ELEMS(a)
H264Context.
Definition: h264.h:258
int chroma_qp_diff
Definition: h264.h:230
uint32_t num_units_in_tick
Definition: h264.h:184
static const AVRational pixel_aspect[17]
Definition: h264_ps.c:38
Not part of ABI.
Definition: avcodec.h:558
int profile_idc
Definition: h264.h:150
static const uint8_t zigzag_scan[16]
Definition: h264data.h:55
Definition: vf_drawbox.c:37
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264.h:173
int fixed_frame_rate_flag
Definition: h264.h:186
uint8_t scaling_matrix4[6][16]
Definition: h264.h:227
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264.h:223
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:178
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264.h:171
int offset_for_non_ref_pic
Definition: h264.h:158
int gaps_in_frame_num_allowed_flag
Definition: h264.h:162
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264.h:202
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2349
enum AVColorPrimaries color_primaries
Definition: h264.h:180
int cabac
entropy_coding_mode_flag
Definition: h264.h:213
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264.h:172
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264.h:153
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
uint8_t chroma_qp_table[2][64]
pre-scaled (with chroma_qp_index_offset) version of qp_table
Definition: h264.h:229
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264.h:225
static float t
Definition: output.c:52
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:262
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1761
H.264 / AVC / MPEG4 part10 codec.
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:555
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264.h:166
enum AVColorTransferCharacteristic color_trc
Definition: h264.h:181
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
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:155
int constrained_intra_pred
constrained_intra_pred_flag
Definition: h264.h:224
int num_reorder_frames
Definition: h264.h:189
#define AVERROR(e)
Definition: error.h:43
int time_offset_length
Definition: h264.h:196
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
#define EXTENDED_SAR
Definition: h264.h:91
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1142
int weighted_pred
weighted_pred_flag
Definition: h264.h:218
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
#define MIN_LOG2_MAX_FRAME_NUM
Definition: h264_ps.c:36
int residual_color_transform_flag
residual_colour_transform_flag
Definition: h264.h:203
int delta_pic_order_always_zero_flag
Definition: h264.h:157
int new
flag to keep track if the decoder context needs re-init due to changed SPS
Definition: h264.h:205
int offset_for_top_to_bottom_field
Definition: h264.h:159
#define CHROMA_QP_TABLE_END(d)
Definition: h264_ps.c:60
int crop
frame_cropping_flag
Definition: h264.h:168
static int decode_hrd_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:106
uint8_t scaling_matrix8[6][64]
Definition: h264.h:228
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:220
int ref_frame_count
num_ref_frames
Definition: h264.h:161
int initial_cpb_removal_delay_length
initial_cpb_removal_delay_length_minus1 + 1
Definition: h264.h:198
int poc_cycle_length
num_ref_frames_in_pic_order_cnt_cycle
Definition: h264.h:160
int colour_description_present_flag
Definition: h264.h:179
AVRational sar
Definition: h264.h:176
SPS sps
current sps
Definition: h264.h:357
PPS * pps_buffers[MAX_PPS_COUNT]
Definition: h264.h:489
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:254
#define MAX_SPS_COUNT
Definition: h264.h:42
int init_qp
pic_init_qp_minus26 + 26
Definition: h264.h:220
int direct_8x8_inference_flag
Definition: h264.h:167
#define AV_EF_EXPLODE
Definition: avcodec.h:2401
uint8_t scaling_matrix8[6][64]
Definition: h264.h:192
unsigned int sps_id
Definition: h264.h:149
int dequant_coeff_pps
reinit tables when pps changes
Definition: h264.h:491
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:81
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
int pic_order_present
pic_order_present_flag
Definition: h264.h:214
SPS * sps_buffers[MAX_SPS_COUNT]
Definition: h264.h:488
short offset_for_ref_frame[256]
Definition: h264.h:187
int timing_info_present_flag
Definition: h264.h:183
NULL
Definition: eval.c:55
int vcl_hrd_parameters_present_flag
Definition: h264.h:194
AVCodecContext * avctx
Definition: h264.h:259
Libavcodec external API header.
H264 / AVC / MPEG4 part10 codec data table
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:96
int debug
debug
Definition: avcodec.h:2348
int dpb_output_delay_length
dpb_output_delay_length_minus1 + 1
Definition: h264.h:200
int vui_parameters_present_flag
Definition: h264.h:175
static int decode_vui_parameters(H264Context *h, SPS *sps)
Definition: h264_ps.c:131
#define QP_MAX_NUM
Definition: h264.h:98
int ff_h264_decode_seq_parameter_set(H264Context *h)
Decode SPS.
Definition: h264_ps.c:297
int constraint_set_flags
constraint_set[0-3]_flag
Definition: h264.h:204
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
int index
Definition: gxfenc.c:72
rational number numerator/denominator
Definition: rational.h:43
unsigned int sps_id
Definition: h264.h:212
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264.h:156
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:304
uint32_t time_scale
Definition: h264.h:185
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264.h:226
int pic_struct_present_flag
Definition: h264.h:195
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
Decode PPS.
Definition: h264_ps.c:524
int mb_height
pic_height_in_map_units_minus1 + 1
Definition: h264.h:164
int init_qs
pic_init_qs_minus26 + 26
Definition: h264.h:221
common internal api header.
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:113
int nal_hrd_parameters_present_flag
Definition: h264.h:193
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264.h:154
static const uint8_t default_scaling4[2][16]
Definition: h264_ps.c:80
int den
denominator
Definition: rational.h:45
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264.h:201
const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM+1]
One chroma qp table for each supported bit depth (8, 9, 10).
Definition: h264_ps.c:71
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264.h:163
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1149
int slice_group_count
num_slice_groups_minus1 + 1
Definition: h264.h:215
int cpb_cnt
See H.264 E.1.2.
Definition: h264.h:197
Not part of ABI.
Definition: avcodec.h:590
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:242
static const uint8_t default_scaling8[2][64]
Definition: h264_ps.c:87
int cpb_removal_delay_length
cpb_removal_delay_length_minus1 + 1
Definition: h264.h:199
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264.h:174
exp golomb vlc stuff
int level_idc
Definition: h264.h:151
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:205
Not part of ABI.
Definition: avcodec.h:576
static void build_qp_table(PPS *pps, int t, int index, const int depth)
Definition: h264_ps.c:515
int mb_slice_group_map_type
Definition: h264.h:216
enum AVColorSpace colorspace
Definition: h264.h:182