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 sps = av_mallocz(sizeof(SPS));
312 return AVERROR(ENOMEM);
314 sps->data_size = h->gb.buffer_end - h->gb.buffer;
315 if (sps->data_size > sizeof(sps->data)) {
316 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
317 sps->data_size = sizeof(sps->data);
319 memcpy(sps->data, h->gb.buffer, sps->data_size);
321 profile_idc = get_bits(&h->gb, 8);
322 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
323 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
324 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
325 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
326 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
327 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
328 skip_bits(&h->gb, 2); // reserved_zero_2bits
329 level_idc = get_bits(&h->gb, 8);
330 sps_id = get_ue_golomb_31(&h->gb);
332 if (sps_id >= MAX_SPS_COUNT) {
333 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
337 sps->sps_id = sps_id;
338 sps->time_offset_length = 24;
339 sps->profile_idc = profile_idc;
340 sps->constraint_set_flags = constraint_set_flags;
341 sps->level_idc = level_idc;
342 sps->full_range = -1;
344 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
345 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
346 sps->scaling_matrix_present = 0;
347 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
349 if (sps->profile_idc == 100 || // High profile
350 sps->profile_idc == 110 || // High10 profile
351 sps->profile_idc == 122 || // High422 profile
352 sps->profile_idc == 244 || // High444 Predictive profile
353 sps->profile_idc == 44 || // Cavlc444 profile
354 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
355 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
356 sps->profile_idc == 118 || // Stereo High profile (MVC)
357 sps->profile_idc == 128 || // Multiview High profile (MVC)
358 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
359 sps->profile_idc == 144) { // old High444 profile
360 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
361 if (sps->chroma_format_idc > 3U) {
362 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
363 sps->chroma_format_idc);
365 } else if (sps->chroma_format_idc == 3) {
366 sps->residual_color_transform_flag = get_bits1(&h->gb);
367 if (sps->residual_color_transform_flag) {
368 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
372 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
373 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
374 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
375 avpriv_request_sample(h->avctx,
376 "Different chroma and luma bit depth");
379 if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
380 sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
381 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
382 sps->bit_depth_luma, sps->bit_depth_chroma);
385 sps->transform_bypass = get_bits1(&h->gb);
386 decode_scaling_matrices(h, sps, NULL, 1,
387 sps->scaling_matrix4, sps->scaling_matrix8);
389 sps->chroma_format_idc = 1;
390 sps->bit_depth_luma = 8;
391 sps->bit_depth_chroma = 8;
394 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
395 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
396 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
397 av_log(h->avctx, AV_LOG_ERROR,
398 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
399 log2_max_frame_num_minus4);
402 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
404 sps->poc_type = get_ue_golomb_31(&h->gb);
406 if (sps->poc_type == 0) { // FIXME #define
407 unsigned t = get_ue_golomb(&h->gb);
409 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
412 sps->log2_max_poc_lsb = t + 4;
413 } else if (sps->poc_type == 1) { // FIXME #define
414 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
415 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
416 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
417 sps->poc_cycle_length = get_ue_golomb(&h->gb);
419 if ((unsigned)sps->poc_cycle_length >=
420 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
421 av_log(h->avctx, AV_LOG_ERROR,
422 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
426 for (i = 0; i < sps->poc_cycle_length; i++)
427 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
428 } else if (sps->poc_type != 2) {
429 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
433 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
434 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
435 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
436 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
437 sps->ref_frame_count > 16U) {
438 av_log(h->avctx, AV_LOG_ERROR,
439 "too many reference frames %d\n", sps->ref_frame_count);
442 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
443 sps->mb_width = get_ue_golomb(&h->gb) + 1;
444 sps->mb_height = get_ue_golomb(&h->gb) + 1;
445 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
446 (unsigned)sps->mb_height >= INT_MAX / 16 ||
447 av_image_check_size(16 * sps->mb_width,
448 16 * sps->mb_height, 0, h->avctx)) {
449 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
453 sps->frame_mbs_only_flag = get_bits1(&h->gb);
454 if (!sps->frame_mbs_only_flag)
455 sps->mb_aff = get_bits1(&h->gb);
459 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
461 #ifndef ALLOW_INTERLACE
463 av_log(h->avctx, AV_LOG_ERROR,
464 "MBAFF support not included; enable it at compile-time.\n");
466 sps->crop = get_bits1(&h->gb);
468 unsigned int crop_left = get_ue_golomb(&h->gb);
469 unsigned int crop_right = get_ue_golomb(&h->gb);
470 unsigned int crop_top = get_ue_golomb(&h->gb);
471 unsigned int crop_bottom = get_ue_golomb(&h->gb);
472 int width = 16 * sps->mb_width;
473 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
475 if (h->avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
476 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
477 "values are l:%d r:%d t:%d b:%d\n",
478 crop_left, crop_right, crop_top, crop_bottom);
483 sps->crop_bottom = 0;
485 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
486 int hsub = (sps->chroma_format_idc == 1 ||
487 sps->chroma_format_idc == 2) ? 1 : 0;
488 int step_x = 1 << hsub;
489 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
491 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
492 !(h->avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
493 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
494 av_log(h->avctx, AV_LOG_WARNING,
495 "Reducing left cropping to %d "
496 "chroma samples to preserve alignment.\n",
500 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
501 crop_right > (unsigned)INT_MAX / 4 / step_x ||
502 crop_top > (unsigned)INT_MAX / 4 / step_y ||
503 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
504 (crop_left + crop_right ) * step_x >= width ||
505 (crop_top + crop_bottom) * step_y >= height
507 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);
511 sps->crop_left = crop_left * step_x;
512 sps->crop_right = crop_right * step_x;
513 sps->crop_top = crop_top * step_y;
514 sps->crop_bottom = crop_bottom * step_y;
524 sps->vui_parameters_present_flag = get_bits1(&h->gb);
525 if (sps->vui_parameters_present_flag) {
526 int ret = decode_vui_parameters(h, sps);
531 if (get_bits_left(&h->gb) < 0) {
532 av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
533 "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
534 if (!ignore_truncation)
541 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
542 static const char csp[4][5] = { "Gray", "420", "422", "444" };
543 av_log(h->avctx, AV_LOG_DEBUG,
544 "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",
545 sps_id, sps->profile_idc, sps->level_idc,
547 sps->ref_frame_count,
548 sps->mb_width, sps->mb_height,
549 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
550 sps->direct_8x8_inference_flag ? "8B8" : "",
551 sps->crop_left, sps->crop_right,
552 sps->crop_top, sps->crop_bottom,
553 sps->vui_parameters_present_flag ? "VUI" : "",
554 csp[sps->chroma_format_idc],
555 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
556 sps->timing_info_present_flag ? sps->time_scale : 0,
558 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
563 av_free(h->sps_buffers[sps_id]);
564 h->sps_buffers[sps_id] = sps;
570 return AVERROR_INVALIDDATA;
573 static void build_qp_table(PPS *pps, int t, int index, const int depth)
576 const int max_qp = 51 + 6 * (depth - 8);
577 for (i = 0; i < max_qp + 1; i++)
578 pps->chroma_qp_table[t][i] =
579 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
582 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
584 const SPS *sps = h->sps_buffers[pps->sps_id];
585 int profile_idc = sps->profile_idc;
587 if ((profile_idc == 66 || profile_idc == 77 ||
588 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
589 av_log(h->avctx, AV_LOG_VERBOSE,
590 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
597 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
600 unsigned int pps_id = get_ue_golomb(&h->gb);
606 if (pps_id >= MAX_PPS_COUNT) {
607 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
608 return AVERROR_INVALIDDATA;
611 pps = av_mallocz(sizeof(PPS));
613 return AVERROR(ENOMEM);
614 pps->data_size = h->gb.buffer_end - h->gb.buffer;
615 if (pps->data_size > sizeof(pps->data)) {
616 av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
617 pps->data_size = sizeof(pps->data);
619 memcpy(pps->data, h->gb.buffer, pps->data_size);
620 pps->sps_id = get_ue_golomb_31(&h->gb);
621 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
622 !h->sps_buffers[pps->sps_id]) {
623 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
624 ret = AVERROR_INVALIDDATA;
627 sps = h->sps_buffers[pps->sps_id];
628 if (sps->bit_depth_luma > 14) {
629 av_log(h->avctx, AV_LOG_ERROR,
630 "Invalid luma bit depth=%d\n",
631 sps->bit_depth_luma);
632 ret = AVERROR_INVALIDDATA;
634 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
635 av_log(h->avctx, AV_LOG_ERROR,
636 "Unimplemented luma bit depth=%d\n",
637 sps->bit_depth_luma);
638 ret = AVERROR_PATCHWELCOME;
642 pps->cabac = get_bits1(&h->gb);
643 pps->pic_order_present = get_bits1(&h->gb);
644 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
645 if (pps->slice_group_count > 1) {
646 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
647 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
648 switch (pps->mb_slice_group_map_type) {
651 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
652 | run_length[i] |1 |ue(v) |
657 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
658 | top_left_mb[i] |1 |ue(v) |
659 | bottom_right_mb[i] |1 |ue(v) |
667 | slice_group_change_direction_flag |1 |u(1) |
668 | slice_group_change_rate_minus1 |1 |ue(v) |
673 | slice_group_id_cnt_minus1 |1 |ue(v) |
674 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
675 | slice_group_id[i] |1 |u(v) |
680 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
681 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
682 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
683 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
684 ret = AVERROR_INVALIDDATA;
688 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
690 pps->weighted_pred = get_bits1(&h->gb);
691 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
692 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
693 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
694 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
695 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
696 pps->constrained_intra_pred = get_bits1(&h->gb);
697 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
699 pps->transform_8x8_mode = 0;
700 // contents of sps/pps can change even if id doesn't, so reinit
701 h->dequant_coeff_pps = -1;
702 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
703 sizeof(pps->scaling_matrix4));
704 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
705 sizeof(pps->scaling_matrix8));
707 bits_left = bit_length - get_bits_count(&h->gb);
708 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
709 pps->transform_8x8_mode = get_bits1(&h->gb);
710 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
711 pps->scaling_matrix4, pps->scaling_matrix8);
712 // second_chroma_qp_index_offset
713 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
715 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
718 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
719 sps->bit_depth_luma);
720 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
721 sps->bit_depth_luma);
722 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
723 pps->chroma_qp_diff = 1;
725 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
726 av_log(h->avctx, AV_LOG_DEBUG,
727 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
729 pps->cabac ? "CABAC" : "CAVLC",
730 pps->slice_group_count,
731 pps->ref_count[0], pps->ref_count[1],
732 pps->weighted_pred ? "weighted" : "",
733 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
734 pps->deblocking_filter_parameters_present ? "LPAR" : "",
735 pps->constrained_intra_pred ? "CONSTR" : "",
736 pps->redundant_pic_cnt_present ? "REDU" : "",
737 pps->transform_8x8_mode ? "8x8DCT" : "");
740 av_free(h->pps_buffers[pps_id]);
741 h->pps_buffers[pps_id] = pps;