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 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
113 cpb_count = get_ue_golomb_31(&h->gb) + 1;
115 if (cpb_count > 32U) {
116 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
117 return AVERROR_INVALIDDATA;
120 get_bits(&h->gb, 4); /* bit_rate_scale */
121 get_bits(&h->gb, 4); /* cpb_size_scale */
122 for (i = 0; i < cpb_count; i++) {
123 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
124 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
125 get_bits1(&h->gb); /* cbr_flag */
127 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
128 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
129 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
130 sps->time_offset_length = get_bits(&h->gb, 5);
131 sps->cpb_cnt = cpb_count;
135 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
137 int aspect_ratio_info_present_flag;
138 unsigned int aspect_ratio_idc;
140 aspect_ratio_info_present_flag = get_bits1(&h->gb);
142 if (aspect_ratio_info_present_flag) {
143 aspect_ratio_idc = get_bits(&h->gb, 8);
144 if (aspect_ratio_idc == EXTENDED_SAR) {
145 sps->sar.num = get_bits(&h->gb, 16);
146 sps->sar.den = get_bits(&h->gb, 16);
147 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
148 sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
150 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
151 return AVERROR_INVALIDDATA;
158 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
159 get_bits1(&h->gb); /* overscan_appropriate_flag */
161 sps->video_signal_type_present_flag = get_bits1(&h->gb);
162 if (sps->video_signal_type_present_flag) {
163 get_bits(&h->gb, 3); /* video_format */
164 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
166 sps->colour_description_present_flag = get_bits1(&h->gb);
167 if (sps->colour_description_present_flag) {
168 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
169 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
170 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
171 if (sps->color_primaries >= AVCOL_PRI_NB)
172 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
173 if (sps->color_trc >= AVCOL_TRC_NB)
174 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
175 if (sps->colorspace >= AVCOL_SPC_NB)
176 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
180 /* chroma_location_info_present_flag */
181 if (get_bits1(&h->gb)) {
182 /* chroma_sample_location_type_top_field */
183 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
184 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
187 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
188 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
192 sps->timing_info_present_flag = get_bits1(&h->gb);
193 if (sps->timing_info_present_flag) {
194 unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
195 unsigned time_scale = get_bits_long(&h->gb, 32);
196 if (!num_units_in_tick || !time_scale) {
197 av_log(h->avctx, AV_LOG_ERROR,
198 "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
199 time_scale, num_units_in_tick);
200 sps->timing_info_present_flag = 0;
202 sps->num_units_in_tick = num_units_in_tick;
203 sps->time_scale = time_scale;
205 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
208 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
209 if (sps->nal_hrd_parameters_present_flag)
210 if (decode_hrd_parameters(h, sps) < 0)
211 return AVERROR_INVALIDDATA;
212 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
213 if (sps->vcl_hrd_parameters_present_flag)
214 if (decode_hrd_parameters(h, sps) < 0)
215 return AVERROR_INVALIDDATA;
216 if (sps->nal_hrd_parameters_present_flag ||
217 sps->vcl_hrd_parameters_present_flag)
218 get_bits1(&h->gb); /* low_delay_hrd_flag */
219 sps->pic_struct_present_flag = get_bits1(&h->gb);
220 if (!get_bits_left(&h->gb))
222 sps->bitstream_restriction_flag = get_bits1(&h->gb);
223 if (sps->bitstream_restriction_flag) {
224 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
225 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
226 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
227 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
228 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
229 sps->num_reorder_frames = get_ue_golomb(&h->gb);
230 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
232 if (get_bits_left(&h->gb) < 0) {
233 sps->num_reorder_frames = 0;
234 sps->bitstream_restriction_flag = 0;
237 if (sps->num_reorder_frames > 16U
238 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
239 av_log(h->avctx, AV_LOG_ERROR,
240 "Clipping illegal num_reorder_frames %d\n",
241 sps->num_reorder_frames);
242 sps->num_reorder_frames = 16;
243 return AVERROR_INVALIDDATA;
250 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
251 const uint8_t *jvt_list,
252 const uint8_t *fallback_list)
254 int i, last = 8, next = 8;
255 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
256 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
257 memcpy(factors, fallback_list, size * sizeof(uint8_t));
259 for (i = 0; i < size; i++) {
261 next = (last + get_se_golomb(&h->gb)) & 0xff;
262 if (!i && !next) { /* matrix not written, we use the preset one */
263 memcpy(factors, jvt_list, size * sizeof(uint8_t));
266 last = factors[scan[i]] = next ? next : last;
270 static void decode_scaling_matrices(H264Context *h, SPS *sps,
271 PPS *pps, int is_sps,
272 uint8_t(*scaling_matrix4)[16],
273 uint8_t(*scaling_matrix8)[64])
275 int fallback_sps = !is_sps && sps->scaling_matrix_present;
276 const uint8_t *fallback[4] = {
277 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
278 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
279 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
280 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
282 if (get_bits1(&h->gb)) {
283 sps->scaling_matrix_present |= is_sps;
284 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
285 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
286 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
287 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
288 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
289 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
290 if (is_sps || pps->transform_8x8_mode) {
291 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
292 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
293 if (sps->chroma_format_idc == 3) {
294 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
295 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
296 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
297 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
303 int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
305 int profile_idc, level_idc, constraint_set_flags = 0;
307 int i, log2_max_frame_num_minus4;
310 profile_idc = get_bits(&h->gb, 8);
311 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
312 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
313 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
314 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
315 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
316 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
317 skip_bits(&h->gb, 2); // reserved_zero_2bits
318 level_idc = get_bits(&h->gb, 8);
319 sps_id = get_ue_golomb_31(&h->gb);
321 if (sps_id >= MAX_SPS_COUNT) {
322 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
323 return AVERROR_INVALIDDATA;
325 sps = av_mallocz(sizeof(SPS));
327 return AVERROR(ENOMEM);
329 sps->sps_id = sps_id;
330 sps->time_offset_length = 24;
331 sps->profile_idc = profile_idc;
332 sps->constraint_set_flags = constraint_set_flags;
333 sps->level_idc = level_idc;
334 sps->full_range = -1;
336 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
337 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
338 sps->scaling_matrix_present = 0;
339 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
341 if (sps->profile_idc == 100 || // High profile
342 sps->profile_idc == 110 || // High10 profile
343 sps->profile_idc == 122 || // High422 profile
344 sps->profile_idc == 244 || // High444 Predictive profile
345 sps->profile_idc == 44 || // Cavlc444 profile
346 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
347 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
348 sps->profile_idc == 118 || // Stereo High profile (MVC)
349 sps->profile_idc == 128 || // Multiview High profile (MVC)
350 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
351 sps->profile_idc == 144) { // old High444 profile
352 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
353 if (sps->chroma_format_idc > 3U) {
354 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
355 sps->chroma_format_idc);
357 } else if (sps->chroma_format_idc == 3) {
358 sps->residual_color_transform_flag = get_bits1(&h->gb);
359 if (sps->residual_color_transform_flag) {
360 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
364 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
365 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
366 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
367 avpriv_request_sample(h->avctx,
368 "Different chroma and luma bit depth");
371 if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
372 sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
373 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
374 sps->bit_depth_luma, sps->bit_depth_chroma);
377 sps->transform_bypass = get_bits1(&h->gb);
378 decode_scaling_matrices(h, sps, NULL, 1,
379 sps->scaling_matrix4, sps->scaling_matrix8);
381 sps->chroma_format_idc = 1;
382 sps->bit_depth_luma = 8;
383 sps->bit_depth_chroma = 8;
386 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
387 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
388 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
389 av_log(h->avctx, AV_LOG_ERROR,
390 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
391 log2_max_frame_num_minus4);
394 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
396 sps->poc_type = get_ue_golomb_31(&h->gb);
398 if (sps->poc_type == 0) { // FIXME #define
399 unsigned t = get_ue_golomb(&h->gb);
401 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
404 sps->log2_max_poc_lsb = t + 4;
405 } else if (sps->poc_type == 1) { // FIXME #define
406 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
407 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
408 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
409 sps->poc_cycle_length = get_ue_golomb(&h->gb);
411 if ((unsigned)sps->poc_cycle_length >=
412 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
413 av_log(h->avctx, AV_LOG_ERROR,
414 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
418 for (i = 0; i < sps->poc_cycle_length; i++)
419 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
420 } else if (sps->poc_type != 2) {
421 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
425 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
426 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
427 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
428 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
429 sps->ref_frame_count > 16U) {
430 av_log(h->avctx, AV_LOG_ERROR,
431 "too many reference frames %d\n", sps->ref_frame_count);
434 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
435 sps->mb_width = get_ue_golomb(&h->gb) + 1;
436 sps->mb_height = get_ue_golomb(&h->gb) + 1;
437 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
438 (unsigned)sps->mb_height >= INT_MAX / 16 ||
439 av_image_check_size(16 * sps->mb_width,
440 16 * sps->mb_height, 0, h->avctx)) {
441 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
445 sps->frame_mbs_only_flag = get_bits1(&h->gb);
446 if (!sps->frame_mbs_only_flag)
447 sps->mb_aff = get_bits1(&h->gb);
451 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
453 #ifndef ALLOW_INTERLACE
455 av_log(h->avctx, AV_LOG_ERROR,
456 "MBAFF support not included; enable it at compile-time.\n");
458 sps->crop = get_bits1(&h->gb);
460 unsigned int crop_left = get_ue_golomb(&h->gb);
461 unsigned int crop_right = get_ue_golomb(&h->gb);
462 unsigned int crop_top = get_ue_golomb(&h->gb);
463 unsigned int crop_bottom = get_ue_golomb(&h->gb);
464 int width = 16 * sps->mb_width;
465 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
467 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
468 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
469 "values are l:%d r:%d t:%d b:%d\n",
470 crop_left, crop_right, crop_top, crop_bottom);
475 sps->crop_bottom = 0;
477 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
478 int hsub = (sps->chroma_format_idc == 1 ||
479 sps->chroma_format_idc == 2) ? 1 : 0;
480 int step_x = 1 << hsub;
481 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
483 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
484 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
485 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
486 av_log(h->avctx, AV_LOG_WARNING,
487 "Reducing left cropping to %d "
488 "chroma samples to preserve alignment.\n",
492 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
493 crop_right > (unsigned)INT_MAX / 4 / step_x ||
494 crop_top > (unsigned)INT_MAX / 4 / step_y ||
495 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
496 (crop_left + crop_right ) * step_x >= width ||
497 (crop_top + crop_bottom) * step_y >= height
499 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);
503 sps->crop_left = crop_left * step_x;
504 sps->crop_right = crop_right * step_x;
505 sps->crop_top = crop_top * step_y;
506 sps->crop_bottom = crop_bottom * step_y;
516 sps->vui_parameters_present_flag = get_bits1(&h->gb);
517 if (sps->vui_parameters_present_flag) {
518 int ret = decode_vui_parameters(h, sps);
523 if (get_bits_left(&h->gb) < 0) {
524 av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
525 "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
526 if (!ignore_truncation)
533 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
534 static const char csp[4][5] = { "Gray", "420", "422", "444" };
535 av_log(h->avctx, AV_LOG_DEBUG,
536 "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",
537 sps_id, sps->profile_idc, sps->level_idc,
539 sps->ref_frame_count,
540 sps->mb_width, sps->mb_height,
541 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
542 sps->direct_8x8_inference_flag ? "8B8" : "",
543 sps->crop_left, sps->crop_right,
544 sps->crop_top, sps->crop_bottom,
545 sps->vui_parameters_present_flag ? "VUI" : "",
546 csp[sps->chroma_format_idc],
547 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
548 sps->timing_info_present_flag ? sps->time_scale : 0,
550 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
555 av_free(h->sps_buffers[sps_id]);
556 h->sps_buffers[sps_id] = sps;
562 return AVERROR_INVALIDDATA;
565 static void build_qp_table(PPS *pps, int t, int index, const int depth)
568 const int max_qp = 51 + 6 * (depth - 8);
569 for (i = 0; i < max_qp + 1; i++)
570 pps->chroma_qp_table[t][i] =
571 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
574 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
576 const SPS *sps = h->sps_buffers[pps->sps_id];
577 int profile_idc = sps->profile_idc;
579 if ((profile_idc == 66 || profile_idc == 77 ||
580 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
581 av_log(h->avctx, AV_LOG_VERBOSE,
582 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
589 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
592 unsigned int pps_id = get_ue_golomb(&h->gb);
598 if (pps_id >= MAX_PPS_COUNT) {
599 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
600 return AVERROR_INVALIDDATA;
603 pps = av_mallocz(sizeof(PPS));
605 return AVERROR(ENOMEM);
606 pps->sps_id = get_ue_golomb_31(&h->gb);
607 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
608 !h->sps_buffers[pps->sps_id]) {
609 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
610 ret = AVERROR_INVALIDDATA;
613 sps = h->sps_buffers[pps->sps_id];
614 if (sps->bit_depth_luma > 14) {
615 av_log(h->avctx, AV_LOG_ERROR,
616 "Invalid luma bit depth=%d\n",
617 sps->bit_depth_luma);
618 ret = AVERROR_INVALIDDATA;
620 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
621 av_log(h->avctx, AV_LOG_ERROR,
622 "Unimplemented luma bit depth=%d\n",
623 sps->bit_depth_luma);
624 ret = AVERROR_PATCHWELCOME;
628 pps->cabac = get_bits1(&h->gb);
629 pps->pic_order_present = get_bits1(&h->gb);
630 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
631 if (pps->slice_group_count > 1) {
632 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
633 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
634 switch (pps->mb_slice_group_map_type) {
637 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
638 | run_length[i] |1 |ue(v) |
643 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
644 | top_left_mb[i] |1 |ue(v) |
645 | bottom_right_mb[i] |1 |ue(v) |
653 | slice_group_change_direction_flag |1 |u(1) |
654 | slice_group_change_rate_minus1 |1 |ue(v) |
659 | slice_group_id_cnt_minus1 |1 |ue(v) |
660 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
661 | slice_group_id[i] |1 |u(v) |
666 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
667 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
668 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
669 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
670 ret = AVERROR_INVALIDDATA;
674 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
676 pps->weighted_pred = get_bits1(&h->gb);
677 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
678 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
679 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
680 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
681 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
682 pps->constrained_intra_pred = get_bits1(&h->gb);
683 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
685 pps->transform_8x8_mode = 0;
686 // contents of sps/pps can change even if id doesn't, so reinit
687 h->dequant_coeff_pps = -1;
688 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
689 sizeof(pps->scaling_matrix4));
690 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
691 sizeof(pps->scaling_matrix8));
693 bits_left = bit_length - get_bits_count(&h->gb);
694 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
695 pps->transform_8x8_mode = get_bits1(&h->gb);
696 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
697 pps->scaling_matrix4, pps->scaling_matrix8);
698 // second_chroma_qp_index_offset
699 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
701 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
704 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
705 sps->bit_depth_luma);
706 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
707 sps->bit_depth_luma);
708 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
709 pps->chroma_qp_diff = 1;
711 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
712 av_log(h->avctx, AV_LOG_DEBUG,
713 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
715 pps->cabac ? "CABAC" : "CAVLC",
716 pps->slice_group_count,
717 pps->ref_count[0], pps->ref_count[1],
718 pps->weighted_pred ? "weighted" : "",
719 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
720 pps->deblocking_filter_parameters_present ? "LPAR" : "",
721 pps->constrained_intra_pred ? "CONSTR" : "",
722 pps->redundant_pic_cnt_present ? "REDU" : "",
723 pps->transform_8x8_mode ? "8x8DCT" : "");
726 av_free(h->pps_buffers[pps_id]);
727 h->pps_buffers[pps_id] = pps;