2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
24 * H.264 / AVC / MPEG4 part10 parameter set decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
30 #include "libavutil/imgutils.h"
37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
38 #define MIN_LOG2_MAX_FRAME_NUM 4
40 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
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)
53 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
54 { CHROMA_QP_TABLE_END(8) },
56 CHROMA_QP_TABLE_END(9) },
59 CHROMA_QP_TABLE_END(10) },
63 CHROMA_QP_TABLE_END(11) },
68 CHROMA_QP_TABLE_END(12) },
74 CHROMA_QP_TABLE_END(13) },
81 CHROMA_QP_TABLE_END(14) },
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 }
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 }
110 /* maximum number of MBs in the DPB for a given level */
111 static const int level_max_dpb_mbs[][2] = {
130 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
133 cpb_count = get_ue_golomb_31(&h->gb) + 1;
135 if (cpb_count > 32U) {
136 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
137 return AVERROR_INVALIDDATA;
140 get_bits(&h->gb, 4); /* bit_rate_scale */
141 get_bits(&h->gb, 4); /* cpb_size_scale */
142 for (i = 0; i < cpb_count; i++) {
143 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
144 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
145 get_bits1(&h->gb); /* cbr_flag */
147 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
148 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
149 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
150 sps->time_offset_length = get_bits(&h->gb, 5);
151 sps->cpb_cnt = cpb_count;
155 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
157 int aspect_ratio_info_present_flag;
158 unsigned int aspect_ratio_idc;
160 aspect_ratio_info_present_flag = get_bits1(&h->gb);
162 if (aspect_ratio_info_present_flag) {
163 aspect_ratio_idc = get_bits(&h->gb, 8);
164 if (aspect_ratio_idc == EXTENDED_SAR) {
165 sps->sar.num = get_bits(&h->gb, 16);
166 sps->sar.den = get_bits(&h->gb, 16);
167 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
168 sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
170 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
171 return AVERROR_INVALIDDATA;
178 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
179 get_bits1(&h->gb); /* overscan_appropriate_flag */
181 sps->video_signal_type_present_flag = get_bits1(&h->gb);
182 if (sps->video_signal_type_present_flag) {
183 get_bits(&h->gb, 3); /* video_format */
184 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
186 sps->colour_description_present_flag = get_bits1(&h->gb);
187 if (sps->colour_description_present_flag) {
188 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
189 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
190 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
191 if (sps->color_primaries >= AVCOL_PRI_NB)
192 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
193 if (sps->color_trc >= AVCOL_TRC_NB)
194 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
195 if (sps->colorspace >= AVCOL_SPC_NB)
196 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
200 /* chroma_location_info_present_flag */
201 if (get_bits1(&h->gb)) {
202 /* chroma_sample_location_type_top_field */
203 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
204 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
207 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
208 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
212 sps->timing_info_present_flag = get_bits1(&h->gb);
213 if (sps->timing_info_present_flag) {
214 unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
215 unsigned time_scale = get_bits_long(&h->gb, 32);
216 if (!num_units_in_tick || !time_scale) {
217 av_log(h->avctx, AV_LOG_ERROR,
218 "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
219 time_scale, num_units_in_tick);
220 sps->timing_info_present_flag = 0;
222 sps->num_units_in_tick = num_units_in_tick;
223 sps->time_scale = time_scale;
225 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
228 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
229 if (sps->nal_hrd_parameters_present_flag)
230 if (decode_hrd_parameters(h, sps) < 0)
231 return AVERROR_INVALIDDATA;
232 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
233 if (sps->vcl_hrd_parameters_present_flag)
234 if (decode_hrd_parameters(h, sps) < 0)
235 return AVERROR_INVALIDDATA;
236 if (sps->nal_hrd_parameters_present_flag ||
237 sps->vcl_hrd_parameters_present_flag)
238 get_bits1(&h->gb); /* low_delay_hrd_flag */
239 sps->pic_struct_present_flag = get_bits1(&h->gb);
240 if (!get_bits_left(&h->gb))
242 sps->bitstream_restriction_flag = get_bits1(&h->gb);
243 if (sps->bitstream_restriction_flag) {
244 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
245 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
246 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
247 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
248 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
249 sps->num_reorder_frames = get_ue_golomb(&h->gb);
250 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
252 if (get_bits_left(&h->gb) < 0) {
253 sps->num_reorder_frames = 0;
254 sps->bitstream_restriction_flag = 0;
257 if (sps->num_reorder_frames > 16U
258 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
259 av_log(h->avctx, AV_LOG_ERROR,
260 "Clipping illegal num_reorder_frames %d\n",
261 sps->num_reorder_frames);
262 sps->num_reorder_frames = 16;
263 return AVERROR_INVALIDDATA;
270 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
271 const uint8_t *jvt_list,
272 const uint8_t *fallback_list)
274 int i, last = 8, next = 8;
275 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
276 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
277 memcpy(factors, fallback_list, size * sizeof(uint8_t));
279 for (i = 0; i < size; i++) {
281 next = (last + get_se_golomb(&h->gb)) & 0xff;
282 if (!i && !next) { /* matrix not written, we use the preset one */
283 memcpy(factors, jvt_list, size * sizeof(uint8_t));
286 last = factors[scan[i]] = next ? next : last;
290 static void decode_scaling_matrices(H264Context *h, SPS *sps,
291 PPS *pps, int is_sps,
292 uint8_t(*scaling_matrix4)[16],
293 uint8_t(*scaling_matrix8)[64])
295 int fallback_sps = !is_sps && sps->scaling_matrix_present;
296 const uint8_t *fallback[4] = {
297 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
298 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
299 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
300 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
302 if (get_bits1(&h->gb)) {
303 sps->scaling_matrix_present |= is_sps;
304 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
305 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
306 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
307 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
308 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
309 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
310 if (is_sps || pps->transform_8x8_mode) {
311 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
312 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
313 if (sps->chroma_format_idc == 3) {
314 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
315 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
316 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
317 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
323 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
325 int profile_idc, level_idc, constraint_set_flags = 0;
327 int i, log2_max_frame_num_minus4;
330 sps = av_mallocz(sizeof(SPS));
332 return AVERROR(ENOMEM);
334 sps->data_size = h->gb.buffer_end - h->gb.buffer;
335 if (sps->data_size > sizeof(sps->data)) {
336 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
337 sps->data_size = sizeof(sps->data);
339 memcpy(sps->data, h->gb.buffer, sps->data_size);
341 profile_idc = get_bits(&h->gb, 8);
342 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
343 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
344 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
345 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
346 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
347 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
348 skip_bits(&h->gb, 2); // reserved_zero_2bits
349 level_idc = get_bits(&h->gb, 8);
350 sps_id = get_ue_golomb_31(&h->gb);
352 if (sps_id >= MAX_SPS_COUNT) {
353 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
357 sps->sps_id = sps_id;
358 sps->time_offset_length = 24;
359 sps->profile_idc = profile_idc;
360 sps->constraint_set_flags = constraint_set_flags;
361 sps->level_idc = level_idc;
362 sps->full_range = -1;
364 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
365 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
366 sps->scaling_matrix_present = 0;
367 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
369 if (sps->profile_idc == 100 || // High profile
370 sps->profile_idc == 110 || // High10 profile
371 sps->profile_idc == 122 || // High422 profile
372 sps->profile_idc == 244 || // High444 Predictive profile
373 sps->profile_idc == 44 || // Cavlc444 profile
374 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
375 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
376 sps->profile_idc == 118 || // Stereo High profile (MVC)
377 sps->profile_idc == 128 || // Multiview High profile (MVC)
378 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
379 sps->profile_idc == 144) { // old High444 profile
380 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
381 if (sps->chroma_format_idc > 3U) {
382 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
383 sps->chroma_format_idc);
385 } else if (sps->chroma_format_idc == 3) {
386 sps->residual_color_transform_flag = get_bits1(&h->gb);
387 if (sps->residual_color_transform_flag) {
388 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
392 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
393 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
394 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
395 avpriv_request_sample(h->avctx,
396 "Different chroma and luma bit depth");
399 if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
400 sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
401 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
402 sps->bit_depth_luma, sps->bit_depth_chroma);
405 sps->transform_bypass = get_bits1(&h->gb);
406 decode_scaling_matrices(h, sps, NULL, 1,
407 sps->scaling_matrix4, sps->scaling_matrix8);
409 sps->chroma_format_idc = 1;
410 sps->bit_depth_luma = 8;
411 sps->bit_depth_chroma = 8;
414 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
415 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
416 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
417 av_log(h->avctx, AV_LOG_ERROR,
418 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
419 log2_max_frame_num_minus4);
422 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
424 sps->poc_type = get_ue_golomb_31(&h->gb);
426 if (sps->poc_type == 0) { // FIXME #define
427 unsigned t = get_ue_golomb(&h->gb);
429 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
432 sps->log2_max_poc_lsb = t + 4;
433 } else if (sps->poc_type == 1) { // FIXME #define
434 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
435 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
436 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
437 sps->poc_cycle_length = get_ue_golomb(&h->gb);
439 if ((unsigned)sps->poc_cycle_length >=
440 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
441 av_log(h->avctx, AV_LOG_ERROR,
442 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
446 for (i = 0; i < sps->poc_cycle_length; i++)
447 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
448 } else if (sps->poc_type != 2) {
449 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
453 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
454 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
455 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
456 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
457 sps->ref_frame_count > 16U) {
458 av_log(h->avctx, AV_LOG_ERROR,
459 "too many reference frames %d\n", sps->ref_frame_count);
462 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
463 sps->mb_width = get_ue_golomb(&h->gb) + 1;
464 sps->mb_height = get_ue_golomb(&h->gb) + 1;
465 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
466 (unsigned)sps->mb_height >= INT_MAX / 16 ||
467 av_image_check_size(16 * sps->mb_width,
468 16 * sps->mb_height, 0, h->avctx)) {
469 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
473 sps->frame_mbs_only_flag = get_bits1(&h->gb);
474 if (!sps->frame_mbs_only_flag)
475 sps->mb_aff = get_bits1(&h->gb);
479 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
481 #ifndef ALLOW_INTERLACE
483 av_log(h->avctx, AV_LOG_ERROR,
484 "MBAFF support not included; enable it at compile-time.\n");
486 sps->crop = get_bits1(&h->gb);
488 unsigned int crop_left = get_ue_golomb(&h->gb);
489 unsigned int crop_right = get_ue_golomb(&h->gb);
490 unsigned int crop_top = get_ue_golomb(&h->gb);
491 unsigned int crop_bottom = get_ue_golomb(&h->gb);
492 int width = 16 * sps->mb_width;
493 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
495 if (h->avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
496 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
497 "values are l:%d r:%d t:%d b:%d\n",
498 crop_left, crop_right, crop_top, crop_bottom);
503 sps->crop_bottom = 0;
505 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
506 int hsub = (sps->chroma_format_idc == 1 ||
507 sps->chroma_format_idc == 2) ? 1 : 0;
508 int step_x = 1 << hsub;
509 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
511 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
512 !(h->avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
513 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
514 av_log(h->avctx, AV_LOG_WARNING,
515 "Reducing left cropping to %d "
516 "chroma samples to preserve alignment.\n",
520 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
521 crop_right > (unsigned)INT_MAX / 4 / step_x ||
522 crop_top > (unsigned)INT_MAX / 4 / step_y ||
523 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
524 (crop_left + crop_right ) * step_x >= width ||
525 (crop_top + crop_bottom) * step_y >= height
527 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
531 sps->crop_left = crop_left * step_x;
532 sps->crop_right = crop_right * step_x;
533 sps->crop_top = crop_top * step_y;
534 sps->crop_bottom = crop_bottom * step_y;
544 sps->vui_parameters_present_flag = get_bits1(&h->gb);
545 if (sps->vui_parameters_present_flag) {
546 int ret = decode_vui_parameters(h, sps);
551 if (get_bits_left(&h->gb) < 0) {
552 av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
553 "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
554 if (!ignore_truncation)
558 /* if the maximum delay is not stored in the SPS, derive it based on the
560 if (!sps->bitstream_restriction_flag) {
561 sps->num_reorder_frames = MAX_DELAYED_PIC_COUNT - 1;
562 for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
563 if (level_max_dpb_mbs[i][0] == sps->level_idc) {
564 sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
565 sps->num_reorder_frames);
574 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
575 static const char csp[4][5] = { "Gray", "420", "422", "444" };
576 av_log(h->avctx, AV_LOG_DEBUG,
577 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",
578 sps_id, sps->profile_idc, sps->level_idc,
580 sps->ref_frame_count,
581 sps->mb_width, sps->mb_height,
582 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
583 sps->direct_8x8_inference_flag ? "8B8" : "",
584 sps->crop_left, sps->crop_right,
585 sps->crop_top, sps->crop_bottom,
586 sps->vui_parameters_present_flag ? "VUI" : "",
587 csp[sps->chroma_format_idc],
588 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
589 sps->timing_info_present_flag ? sps->time_scale : 0,
591 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
596 av_free(h->sps_buffers[sps_id]);
597 h->sps_buffers[sps_id] = sps;
603 return AVERROR_INVALIDDATA;
606 static void build_qp_table(PPS *pps, int t, int index, const int depth)
609 const int max_qp = 51 + 6 * (depth - 8);
610 for (i = 0; i < max_qp + 1; i++)
611 pps->chroma_qp_table[t][i] =
612 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
615 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
617 const SPS *sps = h->sps_buffers[pps->sps_id];
618 int profile_idc = sps->profile_idc;
620 if ((profile_idc == 66 || profile_idc == 77 ||
621 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
622 av_log(h->avctx, AV_LOG_VERBOSE,
623 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
630 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
633 unsigned int pps_id = get_ue_golomb(&h->gb);
639 if (pps_id >= MAX_PPS_COUNT) {
640 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
641 return AVERROR_INVALIDDATA;
644 pps = av_mallocz(sizeof(PPS));
646 return AVERROR(ENOMEM);
647 pps->data_size = h->gb.buffer_end - h->gb.buffer;
648 if (pps->data_size > sizeof(pps->data)) {
649 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
650 pps->data_size = sizeof(pps->data);
652 memcpy(pps->data, h->gb.buffer, pps->data_size);
653 pps->sps_id = get_ue_golomb_31(&h->gb);
654 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
655 !h->sps_buffers[pps->sps_id]) {
656 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
657 ret = AVERROR_INVALIDDATA;
660 sps = h->sps_buffers[pps->sps_id];
661 if (sps->bit_depth_luma > 14) {
662 av_log(h->avctx, AV_LOG_ERROR,
663 "Invalid luma bit depth=%d\n",
664 sps->bit_depth_luma);
665 ret = AVERROR_INVALIDDATA;
667 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
668 av_log(h->avctx, AV_LOG_ERROR,
669 "Unimplemented luma bit depth=%d\n",
670 sps->bit_depth_luma);
671 ret = AVERROR_PATCHWELCOME;
675 pps->cabac = get_bits1(&h->gb);
676 pps->pic_order_present = get_bits1(&h->gb);
677 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
678 if (pps->slice_group_count > 1) {
679 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
680 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
681 switch (pps->mb_slice_group_map_type) {
684 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
685 | run_length[i] |1 |ue(v) |
690 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
691 | top_left_mb[i] |1 |ue(v) |
692 | bottom_right_mb[i] |1 |ue(v) |
700 | slice_group_change_direction_flag |1 |u(1) |
701 | slice_group_change_rate_minus1 |1 |ue(v) |
706 | slice_group_id_cnt_minus1 |1 |ue(v) |
707 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
708 | slice_group_id[i] |1 |u(v) |
713 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
714 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
715 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
716 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
717 ret = AVERROR_INVALIDDATA;
721 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
723 pps->weighted_pred = get_bits1(&h->gb);
724 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
725 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
726 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
727 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
728 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
729 pps->constrained_intra_pred = get_bits1(&h->gb);
730 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
732 pps->transform_8x8_mode = 0;
733 // contents of sps/pps can change even if id doesn't, so reinit
734 h->dequant_coeff_pps = -1;
735 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
736 sizeof(pps->scaling_matrix4));
737 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
738 sizeof(pps->scaling_matrix8));
740 bits_left = bit_length - get_bits_count(&h->gb);
741 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
742 pps->transform_8x8_mode = get_bits1(&h->gb);
743 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
744 pps->scaling_matrix4, pps->scaling_matrix8);
745 // second_chroma_qp_index_offset
746 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
748 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
751 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
752 sps->bit_depth_luma);
753 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
754 sps->bit_depth_luma);
755 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
756 pps->chroma_qp_diff = 1;
758 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
759 av_log(h->avctx, AV_LOG_DEBUG,
760 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
762 pps->cabac ? "CABAC" : "CAVLC",
763 pps->slice_group_count,
764 pps->ref_count[0], pps->ref_count[1],
765 pps->weighted_pred ? "weighted" : "",
766 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
767 pps->deblocking_filter_parameters_present ? "LPAR" : "",
768 pps->constrained_intra_pred ? "CONSTR" : "",
769 pps->redundant_pic_cnt_present ? "REDU" : "",
770 pps->transform_8x8_mode ? "8x8DCT" : "");
773 av_free(h->pps_buffers[pps_id]);
774 h->pps_buffers[pps_id] = pps;