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"
38 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
39 #define MIN_LOG2_MAX_FRAME_NUM 4
41 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
43 #define CHROMA_QP_TABLE_END(d) \
44 QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
45 QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
46 QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
47 QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
48 QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
49 QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
50 QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
51 QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
52 QP(39, d), QP(39, d), QP(39, d), QP(39, d)
54 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
55 { CHROMA_QP_TABLE_END(8) },
57 CHROMA_QP_TABLE_END(9) },
60 CHROMA_QP_TABLE_END(10) },
64 CHROMA_QP_TABLE_END(11) },
69 CHROMA_QP_TABLE_END(12) },
75 CHROMA_QP_TABLE_END(13) },
82 CHROMA_QP_TABLE_END(14) },
85 static const uint8_t default_scaling4[2][16] = {
86 { 6, 13, 20, 28, 13, 20, 28, 32,
87 20, 28, 32, 37, 28, 32, 37, 42 },
88 { 10, 14, 20, 24, 14, 20, 24, 27,
89 20, 24, 27, 30, 24, 27, 30, 34 }
92 static const uint8_t default_scaling8[2][64] = {
93 { 6, 10, 13, 16, 18, 23, 25, 27,
94 10, 11, 16, 18, 23, 25, 27, 29,
95 13, 16, 18, 23, 25, 27, 29, 31,
96 16, 18, 23, 25, 27, 29, 31, 33,
97 18, 23, 25, 27, 29, 31, 33, 36,
98 23, 25, 27, 29, 31, 33, 36, 38,
99 25, 27, 29, 31, 33, 36, 38, 40,
100 27, 29, 31, 33, 36, 38, 40, 42 },
101 { 9, 13, 15, 17, 19, 21, 22, 24,
102 13, 13, 17, 19, 21, 22, 24, 25,
103 15, 17, 19, 21, 22, 24, 25, 27,
104 17, 19, 21, 22, 24, 25, 27, 28,
105 19, 21, 22, 24, 25, 27, 28, 30,
106 21, 22, 24, 25, 27, 28, 30, 32,
107 22, 24, 25, 27, 28, 30, 32, 33,
108 24, 25, 27, 28, 30, 32, 33, 35 }
111 /* maximum number of MBs in the DPB for a given level */
112 static const int level_max_dpb_mbs[][2] = {
131 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
134 cpb_count = get_ue_golomb_31(&h->gb) + 1;
136 if (cpb_count > 32U) {
137 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
138 return AVERROR_INVALIDDATA;
141 get_bits(&h->gb, 4); /* bit_rate_scale */
142 get_bits(&h->gb, 4); /* cpb_size_scale */
143 for (i = 0; i < cpb_count; i++) {
144 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
145 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
146 get_bits1(&h->gb); /* cbr_flag */
148 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
149 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
150 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
151 sps->time_offset_length = get_bits(&h->gb, 5);
152 sps->cpb_cnt = cpb_count;
156 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
158 int aspect_ratio_info_present_flag;
159 unsigned int aspect_ratio_idc;
161 aspect_ratio_info_present_flag = get_bits1(&h->gb);
163 if (aspect_ratio_info_present_flag) {
164 aspect_ratio_idc = get_bits(&h->gb, 8);
165 if (aspect_ratio_idc == EXTENDED_SAR) {
166 sps->sar.num = get_bits(&h->gb, 16);
167 sps->sar.den = get_bits(&h->gb, 16);
168 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
169 sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
171 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
172 return AVERROR_INVALIDDATA;
179 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
180 get_bits1(&h->gb); /* overscan_appropriate_flag */
182 sps->video_signal_type_present_flag = get_bits1(&h->gb);
183 if (sps->video_signal_type_present_flag) {
184 get_bits(&h->gb, 3); /* video_format */
185 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
187 sps->colour_description_present_flag = get_bits1(&h->gb);
188 if (sps->colour_description_present_flag) {
189 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
190 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
191 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
192 if (sps->color_primaries >= AVCOL_PRI_NB)
193 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
194 if (sps->color_trc >= AVCOL_TRC_NB)
195 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
196 if (sps->colorspace >= AVCOL_SPC_NB)
197 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
201 /* chroma_location_info_present_flag */
202 if (get_bits1(&h->gb)) {
203 /* chroma_sample_location_type_top_field */
204 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
205 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
208 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
209 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
213 sps->timing_info_present_flag = get_bits1(&h->gb);
214 if (sps->timing_info_present_flag) {
215 unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
216 unsigned time_scale = get_bits_long(&h->gb, 32);
217 if (!num_units_in_tick || !time_scale) {
218 av_log(h->avctx, AV_LOG_ERROR,
219 "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
220 time_scale, num_units_in_tick);
221 sps->timing_info_present_flag = 0;
223 sps->num_units_in_tick = num_units_in_tick;
224 sps->time_scale = time_scale;
226 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
229 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
230 if (sps->nal_hrd_parameters_present_flag)
231 if (decode_hrd_parameters(h, sps) < 0)
232 return AVERROR_INVALIDDATA;
233 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
234 if (sps->vcl_hrd_parameters_present_flag)
235 if (decode_hrd_parameters(h, sps) < 0)
236 return AVERROR_INVALIDDATA;
237 if (sps->nal_hrd_parameters_present_flag ||
238 sps->vcl_hrd_parameters_present_flag)
239 get_bits1(&h->gb); /* low_delay_hrd_flag */
240 sps->pic_struct_present_flag = get_bits1(&h->gb);
241 if (!get_bits_left(&h->gb))
243 sps->bitstream_restriction_flag = get_bits1(&h->gb);
244 if (sps->bitstream_restriction_flag) {
245 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
246 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
247 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
248 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
249 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
250 sps->num_reorder_frames = get_ue_golomb(&h->gb);
251 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
253 if (get_bits_left(&h->gb) < 0) {
254 sps->num_reorder_frames = 0;
255 sps->bitstream_restriction_flag = 0;
258 if (sps->num_reorder_frames > 16U
259 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
260 av_log(h->avctx, AV_LOG_ERROR,
261 "Clipping illegal num_reorder_frames %d\n",
262 sps->num_reorder_frames);
263 sps->num_reorder_frames = 16;
264 return AVERROR_INVALIDDATA;
271 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
272 const uint8_t *jvt_list,
273 const uint8_t *fallback_list)
275 int i, last = 8, next = 8;
276 const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
277 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
278 memcpy(factors, fallback_list, size * sizeof(uint8_t));
280 for (i = 0; i < size; i++) {
282 next = (last + get_se_golomb(&h->gb)) & 0xff;
283 if (!i && !next) { /* matrix not written, we use the preset one */
284 memcpy(factors, jvt_list, size * sizeof(uint8_t));
287 last = factors[scan[i]] = next ? next : last;
291 static void decode_scaling_matrices(H264Context *h, SPS *sps,
292 PPS *pps, int is_sps,
293 uint8_t(*scaling_matrix4)[16],
294 uint8_t(*scaling_matrix8)[64])
296 int fallback_sps = !is_sps && sps->scaling_matrix_present;
297 const uint8_t *fallback[4] = {
298 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
299 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
300 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
301 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
303 if (get_bits1(&h->gb)) {
304 sps->scaling_matrix_present |= is_sps;
305 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
306 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
307 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
308 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
309 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
310 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
311 if (is_sps || pps->transform_8x8_mode) {
312 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
313 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
314 if (sps->chroma_format_idc == 3) {
315 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
316 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
317 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
318 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
324 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
326 int profile_idc, level_idc, constraint_set_flags = 0;
328 int i, log2_max_frame_num_minus4;
331 sps = av_mallocz(sizeof(SPS));
333 return AVERROR(ENOMEM);
335 sps->data_size = h->gb.buffer_end - h->gb.buffer;
336 if (sps->data_size > sizeof(sps->data)) {
337 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
338 sps->data_size = sizeof(sps->data);
340 memcpy(sps->data, h->gb.buffer, sps->data_size);
342 profile_idc = get_bits(&h->gb, 8);
343 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
344 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
345 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
346 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
347 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
348 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
349 skip_bits(&h->gb, 2); // reserved_zero_2bits
350 level_idc = get_bits(&h->gb, 8);
351 sps_id = get_ue_golomb_31(&h->gb);
353 if (sps_id >= MAX_SPS_COUNT) {
354 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
358 sps->sps_id = sps_id;
359 sps->time_offset_length = 24;
360 sps->profile_idc = profile_idc;
361 sps->constraint_set_flags = constraint_set_flags;
362 sps->level_idc = level_idc;
363 sps->full_range = -1;
365 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
366 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
367 sps->scaling_matrix_present = 0;
368 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
370 if (sps->profile_idc == 100 || // High profile
371 sps->profile_idc == 110 || // High10 profile
372 sps->profile_idc == 122 || // High422 profile
373 sps->profile_idc == 244 || // High444 Predictive profile
374 sps->profile_idc == 44 || // Cavlc444 profile
375 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
376 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
377 sps->profile_idc == 118 || // Stereo High profile (MVC)
378 sps->profile_idc == 128 || // Multiview High profile (MVC)
379 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
380 sps->profile_idc == 144) { // old High444 profile
381 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
382 if (sps->chroma_format_idc > 3U) {
383 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
384 sps->chroma_format_idc);
386 } else if (sps->chroma_format_idc == 3) {
387 sps->residual_color_transform_flag = get_bits1(&h->gb);
388 if (sps->residual_color_transform_flag) {
389 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
393 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
394 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
395 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
396 avpriv_request_sample(h->avctx,
397 "Different chroma and luma bit depth");
400 if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
401 sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
402 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
403 sps->bit_depth_luma, sps->bit_depth_chroma);
406 sps->transform_bypass = get_bits1(&h->gb);
407 decode_scaling_matrices(h, sps, NULL, 1,
408 sps->scaling_matrix4, sps->scaling_matrix8);
410 sps->chroma_format_idc = 1;
411 sps->bit_depth_luma = 8;
412 sps->bit_depth_chroma = 8;
415 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
416 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
417 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
418 av_log(h->avctx, AV_LOG_ERROR,
419 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
420 log2_max_frame_num_minus4);
423 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
425 sps->poc_type = get_ue_golomb_31(&h->gb);
427 if (sps->poc_type == 0) { // FIXME #define
428 unsigned t = get_ue_golomb(&h->gb);
430 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
433 sps->log2_max_poc_lsb = t + 4;
434 } else if (sps->poc_type == 1) { // FIXME #define
435 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
436 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
437 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
438 sps->poc_cycle_length = get_ue_golomb(&h->gb);
440 if ((unsigned)sps->poc_cycle_length >=
441 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
442 av_log(h->avctx, AV_LOG_ERROR,
443 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
447 for (i = 0; i < sps->poc_cycle_length; i++)
448 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
449 } else if (sps->poc_type != 2) {
450 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
454 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
455 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
456 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
457 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
458 sps->ref_frame_count > 16U) {
459 av_log(h->avctx, AV_LOG_ERROR,
460 "too many reference frames %d\n", sps->ref_frame_count);
463 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
464 sps->mb_width = get_ue_golomb(&h->gb) + 1;
465 sps->mb_height = get_ue_golomb(&h->gb) + 1;
466 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
467 (unsigned)sps->mb_height >= INT_MAX / 16 ||
468 av_image_check_size(16 * sps->mb_width,
469 16 * sps->mb_height, 0, h->avctx)) {
470 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
474 sps->frame_mbs_only_flag = get_bits1(&h->gb);
475 if (!sps->frame_mbs_only_flag)
476 sps->mb_aff = get_bits1(&h->gb);
480 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
482 #ifndef ALLOW_INTERLACE
484 av_log(h->avctx, AV_LOG_ERROR,
485 "MBAFF support not included; enable it at compile-time.\n");
487 sps->crop = get_bits1(&h->gb);
489 unsigned int crop_left = get_ue_golomb(&h->gb);
490 unsigned int crop_right = get_ue_golomb(&h->gb);
491 unsigned int crop_top = get_ue_golomb(&h->gb);
492 unsigned int crop_bottom = get_ue_golomb(&h->gb);
493 int width = 16 * sps->mb_width;
494 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
496 if (h->avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
497 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
498 "values are l:%d r:%d t:%d b:%d\n",
499 crop_left, crop_right, crop_top, crop_bottom);
504 sps->crop_bottom = 0;
506 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
507 int hsub = (sps->chroma_format_idc == 1 ||
508 sps->chroma_format_idc == 2) ? 1 : 0;
509 int step_x = 1 << hsub;
510 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
512 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
513 !(h->avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
514 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
515 av_log(h->avctx, AV_LOG_WARNING,
516 "Reducing left cropping to %d "
517 "chroma samples to preserve alignment.\n",
521 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
522 crop_right > (unsigned)INT_MAX / 4 / step_x ||
523 crop_top > (unsigned)INT_MAX / 4 / step_y ||
524 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
525 (crop_left + crop_right ) * step_x >= width ||
526 (crop_top + crop_bottom) * step_y >= height
528 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);
532 sps->crop_left = crop_left * step_x;
533 sps->crop_right = crop_right * step_x;
534 sps->crop_top = crop_top * step_y;
535 sps->crop_bottom = crop_bottom * step_y;
545 sps->vui_parameters_present_flag = get_bits1(&h->gb);
546 if (sps->vui_parameters_present_flag) {
547 int ret = decode_vui_parameters(h, sps);
552 if (get_bits_left(&h->gb) < 0) {
553 av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
554 "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
555 if (!ignore_truncation)
559 /* if the maximum delay is not stored in the SPS, derive it based on the
561 if (!sps->bitstream_restriction_flag) {
562 sps->num_reorder_frames = MAX_DELAYED_PIC_COUNT - 1;
563 for (i = 0; i < FF_ARRAY_ELEMS(level_max_dpb_mbs); i++) {
564 if (level_max_dpb_mbs[i][0] == sps->level_idc) {
565 sps->num_reorder_frames = FFMIN(level_max_dpb_mbs[i][1] / (sps->mb_width * sps->mb_height),
566 sps->num_reorder_frames);
575 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
576 static const char csp[4][5] = { "Gray", "420", "422", "444" };
577 av_log(h->avctx, AV_LOG_DEBUG,
578 "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",
579 sps_id, sps->profile_idc, sps->level_idc,
581 sps->ref_frame_count,
582 sps->mb_width, sps->mb_height,
583 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
584 sps->direct_8x8_inference_flag ? "8B8" : "",
585 sps->crop_left, sps->crop_right,
586 sps->crop_top, sps->crop_bottom,
587 sps->vui_parameters_present_flag ? "VUI" : "",
588 csp[sps->chroma_format_idc],
589 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
590 sps->timing_info_present_flag ? sps->time_scale : 0,
592 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
597 av_free(h->sps_buffers[sps_id]);
598 h->sps_buffers[sps_id] = sps;
604 return AVERROR_INVALIDDATA;
607 static void build_qp_table(PPS *pps, int t, int index, const int depth)
610 const int max_qp = 51 + 6 * (depth - 8);
611 for (i = 0; i < max_qp + 1; i++)
612 pps->chroma_qp_table[t][i] =
613 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
616 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
618 const SPS *sps = h->sps_buffers[pps->sps_id];
619 int profile_idc = sps->profile_idc;
621 if ((profile_idc == 66 || profile_idc == 77 ||
622 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
623 av_log(h->avctx, AV_LOG_VERBOSE,
624 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
631 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
634 unsigned int pps_id = get_ue_golomb(&h->gb);
640 if (pps_id >= MAX_PPS_COUNT) {
641 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
642 return AVERROR_INVALIDDATA;
645 pps = av_mallocz(sizeof(PPS));
647 return AVERROR(ENOMEM);
648 pps->data_size = h->gb.buffer_end - h->gb.buffer;
649 if (pps->data_size > sizeof(pps->data)) {
650 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
651 pps->data_size = sizeof(pps->data);
653 memcpy(pps->data, h->gb.buffer, pps->data_size);
654 pps->sps_id = get_ue_golomb_31(&h->gb);
655 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
656 !h->sps_buffers[pps->sps_id]) {
657 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
658 ret = AVERROR_INVALIDDATA;
661 sps = h->sps_buffers[pps->sps_id];
662 if (sps->bit_depth_luma > 14) {
663 av_log(h->avctx, AV_LOG_ERROR,
664 "Invalid luma bit depth=%d\n",
665 sps->bit_depth_luma);
666 ret = AVERROR_INVALIDDATA;
668 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
669 av_log(h->avctx, AV_LOG_ERROR,
670 "Unimplemented luma bit depth=%d\n",
671 sps->bit_depth_luma);
672 ret = AVERROR_PATCHWELCOME;
676 pps->cabac = get_bits1(&h->gb);
677 pps->pic_order_present = get_bits1(&h->gb);
678 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
679 if (pps->slice_group_count > 1) {
680 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
681 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
682 switch (pps->mb_slice_group_map_type) {
685 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
686 | run_length[i] |1 |ue(v) |
691 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
692 | top_left_mb[i] |1 |ue(v) |
693 | bottom_right_mb[i] |1 |ue(v) |
701 | slice_group_change_direction_flag |1 |u(1) |
702 | slice_group_change_rate_minus1 |1 |ue(v) |
707 | slice_group_id_cnt_minus1 |1 |ue(v) |
708 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
709 | slice_group_id[i] |1 |u(v) |
714 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
715 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
716 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
717 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
718 ret = AVERROR_INVALIDDATA;
722 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
724 pps->weighted_pred = get_bits1(&h->gb);
725 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
726 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
727 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
728 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
729 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
730 pps->constrained_intra_pred = get_bits1(&h->gb);
731 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
733 pps->transform_8x8_mode = 0;
734 // contents of sps/pps can change even if id doesn't, so reinit
735 h->dequant_coeff_pps = -1;
736 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
737 sizeof(pps->scaling_matrix4));
738 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
739 sizeof(pps->scaling_matrix8));
741 bits_left = bit_length - get_bits_count(&h->gb);
742 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
743 pps->transform_8x8_mode = get_bits1(&h->gb);
744 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
745 pps->scaling_matrix4, pps->scaling_matrix8);
746 // second_chroma_qp_index_offset
747 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
749 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
752 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
753 sps->bit_depth_luma);
754 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
755 sps->bit_depth_luma);
756 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
757 pps->chroma_qp_diff = 1;
759 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
760 av_log(h->avctx, AV_LOG_DEBUG,
761 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
763 pps->cabac ? "CABAC" : "CAVLC",
764 pps->slice_group_count,
765 pps->ref_count[0], pps->ref_count[1],
766 pps->weighted_pred ? "weighted" : "",
767 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
768 pps->deblocking_filter_parameters_present ? "LPAR" : "",
769 pps->constrained_intra_pred ? "CONSTR" : "",
770 pps->redundant_pic_cnt_present ? "REDU" : "",
771 pps->transform_8x8_mode ? "8x8DCT" : "");
774 av_free(h->pps_buffers[pps_id]);
775 h->pps_buffers[pps_id] = pps;