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>
28 #include "libavutil/imgutils.h"
32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
35 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
36 #define MIN_LOG2_MAX_FRAME_NUM 4
38 static const AVRational pixel_aspect[17] = {
58 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
60 #define CHROMA_QP_TABLE_END(d) \
61 QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
62 QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
63 QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
64 QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
65 QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
66 QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
67 QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
68 QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
69 QP(39, d), QP(39, d), QP(39, d), QP(39, d)
71 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
72 { CHROMA_QP_TABLE_END(8) },
74 CHROMA_QP_TABLE_END(9) },
77 CHROMA_QP_TABLE_END(10) },
81 CHROMA_QP_TABLE_END(11) },
86 CHROMA_QP_TABLE_END(12) },
92 CHROMA_QP_TABLE_END(13) },
99 CHROMA_QP_TABLE_END(14) },
102 static const uint8_t default_scaling4[2][16] = {
103 { 6, 13, 20, 28, 13, 20, 28, 32,
104 20, 28, 32, 37, 28, 32, 37, 42 },
105 { 10, 14, 20, 24, 14, 20, 24, 27,
106 20, 24, 27, 30, 24, 27, 30, 34 }
109 static const uint8_t default_scaling8[2][64] = {
110 { 6, 10, 13, 16, 18, 23, 25, 27,
111 10, 11, 16, 18, 23, 25, 27, 29,
112 13, 16, 18, 23, 25, 27, 29, 31,
113 16, 18, 23, 25, 27, 29, 31, 33,
114 18, 23, 25, 27, 29, 31, 33, 36,
115 23, 25, 27, 29, 31, 33, 36, 38,
116 25, 27, 29, 31, 33, 36, 38, 40,
117 27, 29, 31, 33, 36, 38, 40, 42 },
118 { 9, 13, 15, 17, 19, 21, 22, 24,
119 13, 13, 17, 19, 21, 22, 24, 25,
120 15, 17, 19, 21, 22, 24, 25, 27,
121 17, 19, 21, 22, 24, 25, 27, 28,
122 19, 21, 22, 24, 25, 27, 28, 30,
123 21, 22, 24, 25, 27, 28, 30, 32,
124 22, 24, 25, 27, 28, 30, 32, 33,
125 24, 25, 27, 28, 30, 32, 33, 35 }
128 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
131 cpb_count = get_ue_golomb_31(&h->gb) + 1;
133 if (cpb_count > 32U) {
134 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
135 return AVERROR_INVALIDDATA;
138 get_bits(&h->gb, 4); /* bit_rate_scale */
139 get_bits(&h->gb, 4); /* cpb_size_scale */
140 for (i = 0; i < cpb_count; i++) {
141 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
142 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
143 get_bits1(&h->gb); /* cbr_flag */
145 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
146 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
147 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
148 sps->time_offset_length = get_bits(&h->gb, 5);
149 sps->cpb_cnt = cpb_count;
153 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
155 int aspect_ratio_info_present_flag;
156 unsigned int aspect_ratio_idc;
158 aspect_ratio_info_present_flag = get_bits1(&h->gb);
160 if (aspect_ratio_info_present_flag) {
161 aspect_ratio_idc = get_bits(&h->gb, 8);
162 if (aspect_ratio_idc == EXTENDED_SAR) {
163 sps->sar.num = get_bits(&h->gb, 16);
164 sps->sar.den = get_bits(&h->gb, 16);
165 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
166 sps->sar = pixel_aspect[aspect_ratio_idc];
168 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
169 return AVERROR_INVALIDDATA;
176 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
177 get_bits1(&h->gb); /* overscan_appropriate_flag */
179 sps->video_signal_type_present_flag = get_bits1(&h->gb);
180 if (sps->video_signal_type_present_flag) {
181 get_bits(&h->gb, 3); /* video_format */
182 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
184 sps->colour_description_present_flag = get_bits1(&h->gb);
185 if (sps->colour_description_present_flag) {
186 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
187 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
188 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
189 if (sps->color_primaries >= AVCOL_PRI_NB)
190 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
191 if (sps->color_trc >= AVCOL_TRC_NB)
192 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
193 if (sps->colorspace >= AVCOL_SPC_NB)
194 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
198 /* chroma_location_info_present_flag */
199 if (get_bits1(&h->gb)) {
200 /* chroma_sample_location_type_top_field */
201 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
202 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
205 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
206 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
210 sps->timing_info_present_flag = get_bits1(&h->gb);
211 if (sps->timing_info_present_flag) {
212 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
213 sps->time_scale = get_bits_long(&h->gb, 32);
214 if (!sps->num_units_in_tick || !sps->time_scale) {
215 av_log(h->avctx, AV_LOG_ERROR,
216 "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n",
217 sps->time_scale, sps->num_units_in_tick);
218 return AVERROR_INVALIDDATA;
220 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
223 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
224 if (sps->nal_hrd_parameters_present_flag)
225 if (decode_hrd_parameters(h, sps) < 0)
226 return AVERROR_INVALIDDATA;
227 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
228 if (sps->vcl_hrd_parameters_present_flag)
229 if (decode_hrd_parameters(h, sps) < 0)
230 return AVERROR_INVALIDDATA;
231 if (sps->nal_hrd_parameters_present_flag ||
232 sps->vcl_hrd_parameters_present_flag)
233 get_bits1(&h->gb); /* low_delay_hrd_flag */
234 sps->pic_struct_present_flag = get_bits1(&h->gb);
235 if (!get_bits_left(&h->gb))
237 sps->bitstream_restriction_flag = get_bits1(&h->gb);
238 if (sps->bitstream_restriction_flag) {
239 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
240 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
241 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
242 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
243 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
244 sps->num_reorder_frames = get_ue_golomb(&h->gb);
245 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
247 if (get_bits_left(&h->gb) < 0) {
248 sps->num_reorder_frames = 0;
249 sps->bitstream_restriction_flag = 0;
252 if (sps->num_reorder_frames > 16U
253 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
254 av_log(h->avctx, AV_LOG_ERROR,
255 "Clipping illegal num_reorder_frames %d\n",
256 sps->num_reorder_frames);
257 sps->num_reorder_frames = 16;
258 return AVERROR_INVALIDDATA;
262 if (get_bits_left(&h->gb) < 0) {
263 av_log(h->avctx, AV_LOG_ERROR,
264 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
265 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 ? 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)
326 int profile_idc, level_idc, constraint_set_flags = 0;
328 int i, log2_max_frame_num_minus4;
331 profile_idc = get_bits(&h->gb, 8);
332 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
333 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
334 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
335 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
336 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
337 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
338 skip_bits(&h->gb, 2); // reserved_zero_2bits
339 level_idc = get_bits(&h->gb, 8);
340 sps_id = get_ue_golomb_31(&h->gb);
342 if (sps_id >= MAX_SPS_COUNT) {
343 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
344 return AVERROR_INVALIDDATA;
346 sps = av_mallocz(sizeof(SPS));
348 return AVERROR(ENOMEM);
350 sps->sps_id = sps_id;
351 sps->time_offset_length = 24;
352 sps->profile_idc = profile_idc;
353 sps->constraint_set_flags = constraint_set_flags;
354 sps->level_idc = level_idc;
355 sps->full_range = -1;
357 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
358 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
359 sps->scaling_matrix_present = 0;
360 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
362 if (sps->profile_idc == 100 || // High profile
363 sps->profile_idc == 110 || // High10 profile
364 sps->profile_idc == 122 || // High422 profile
365 sps->profile_idc == 244 || // High444 Predictive profile
366 sps->profile_idc == 44 || // Cavlc444 profile
367 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
368 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
369 sps->profile_idc == 118 || // Stereo High profile (MVC)
370 sps->profile_idc == 128 || // Multiview High profile (MVC)
371 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
372 sps->profile_idc == 144) { // old High444 profile
373 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
374 if (sps->chroma_format_idc > 3U) {
375 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
376 sps->chroma_format_idc);
378 } else if (sps->chroma_format_idc == 3) {
379 sps->residual_color_transform_flag = get_bits1(&h->gb);
380 if (sps->residual_color_transform_flag) {
381 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
385 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
386 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
387 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
388 avpriv_request_sample(h->avctx,
389 "Different chroma and luma bit depth");
392 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
393 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
394 sps->bit_depth_luma, sps->bit_depth_chroma);
397 sps->transform_bypass = get_bits1(&h->gb);
398 decode_scaling_matrices(h, sps, NULL, 1,
399 sps->scaling_matrix4, sps->scaling_matrix8);
401 sps->chroma_format_idc = 1;
402 sps->bit_depth_luma = 8;
403 sps->bit_depth_chroma = 8;
406 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
407 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
408 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
409 av_log(h->avctx, AV_LOG_ERROR,
410 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
411 log2_max_frame_num_minus4);
414 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
416 sps->poc_type = get_ue_golomb_31(&h->gb);
418 if (sps->poc_type == 0) { // FIXME #define
419 unsigned t = get_ue_golomb(&h->gb);
421 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
424 sps->log2_max_poc_lsb = t + 4;
425 } else if (sps->poc_type == 1) { // FIXME #define
426 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
427 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
428 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
429 sps->poc_cycle_length = get_ue_golomb(&h->gb);
431 if ((unsigned)sps->poc_cycle_length >=
432 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
433 av_log(h->avctx, AV_LOG_ERROR,
434 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
438 for (i = 0; i < sps->poc_cycle_length; i++)
439 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
440 } else if (sps->poc_type != 2) {
441 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
445 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
446 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
447 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
448 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
449 sps->ref_frame_count > 16U) {
450 av_log(h->avctx, AV_LOG_ERROR,
451 "too many reference frames %d\n", sps->ref_frame_count);
454 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
455 sps->mb_width = get_ue_golomb(&h->gb) + 1;
456 sps->mb_height = get_ue_golomb(&h->gb) + 1;
457 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
458 (unsigned)sps->mb_height >= INT_MAX / 16 ||
459 av_image_check_size(16 * sps->mb_width,
460 16 * sps->mb_height, 0, h->avctx)) {
461 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
465 sps->frame_mbs_only_flag = get_bits1(&h->gb);
466 if (!sps->frame_mbs_only_flag)
467 sps->mb_aff = get_bits1(&h->gb);
471 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
473 #ifndef ALLOW_INTERLACE
475 av_log(h->avctx, AV_LOG_ERROR,
476 "MBAFF support not included; enable it at compile-time.\n");
478 sps->crop = get_bits1(&h->gb);
480 int crop_left = get_ue_golomb(&h->gb);
481 int crop_right = get_ue_golomb(&h->gb);
482 int crop_top = get_ue_golomb(&h->gb);
483 int crop_bottom = get_ue_golomb(&h->gb);
484 int width = 16 * sps->mb_width;
485 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
487 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
488 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
489 "values are l:%u r:%u t:%u b:%u\n",
490 crop_left, crop_right, crop_top, crop_bottom);
495 sps->crop_bottom = 0;
497 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
498 int hsub = (sps->chroma_format_idc == 1 ||
499 sps->chroma_format_idc == 2) ? 1 : 0;
500 int step_x = 1 << hsub;
501 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
503 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
504 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
505 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
506 av_log(h->avctx, AV_LOG_WARNING,
507 "Reducing left cropping to %d "
508 "chroma samples to preserve alignment.\n",
512 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
513 crop_right > (unsigned)INT_MAX / 4 / step_x ||
514 crop_top > (unsigned)INT_MAX / 4 / step_y ||
515 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
516 (crop_left + crop_right ) * step_x >= width ||
517 (crop_top + crop_bottom) * step_y >= height
519 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);
523 sps->crop_left = crop_left * step_x;
524 sps->crop_right = crop_right * step_x;
525 sps->crop_top = crop_top * step_y;
526 sps->crop_bottom = crop_bottom * step_y;
536 sps->vui_parameters_present_flag = get_bits1(&h->gb);
537 if (sps->vui_parameters_present_flag) {
538 int ret = decode_vui_parameters(h, sps);
546 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
547 static const char csp[4][5] = { "Gray", "420", "422", "444" };
548 av_log(h->avctx, AV_LOG_DEBUG,
549 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d b%d reo:%d\n",
550 sps_id, sps->profile_idc, sps->level_idc,
552 sps->ref_frame_count,
553 sps->mb_width, sps->mb_height,
554 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
555 sps->direct_8x8_inference_flag ? "8B8" : "",
556 sps->crop_left, sps->crop_right,
557 sps->crop_top, sps->crop_bottom,
558 sps->vui_parameters_present_flag ? "VUI" : "",
559 csp[sps->chroma_format_idc],
560 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
561 sps->timing_info_present_flag ? sps->time_scale : 0,
563 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
568 av_free(h->sps_buffers[sps_id]);
569 h->sps_buffers[sps_id] = sps;
578 static void build_qp_table(PPS *pps, int t, int index, const int depth)
581 const int max_qp = 51 + 6 * (depth - 8);
582 for (i = 0; i < max_qp + 1; i++)
583 pps->chroma_qp_table[t][i] =
584 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
587 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
589 const SPS *sps = h->sps_buffers[pps->sps_id];
590 int profile_idc = sps->profile_idc;
592 if ((profile_idc == 66 || profile_idc == 77 ||
593 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
594 av_log(h->avctx, AV_LOG_VERBOSE,
595 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
602 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
604 unsigned int pps_id = get_ue_golomb(&h->gb);
610 if (pps_id >= MAX_PPS_COUNT) {
611 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
612 return AVERROR_INVALIDDATA;
615 pps = av_mallocz(sizeof(PPS));
617 return AVERROR(ENOMEM);
618 pps->sps_id = get_ue_golomb_31(&h->gb);
619 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
620 h->sps_buffers[pps->sps_id] == NULL) {
621 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
624 sps = h->sps_buffers[pps->sps_id];
625 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
626 if (sps->bit_depth_luma > 14) {
627 av_log(h->avctx, AV_LOG_ERROR,
628 "Invalid luma bit depth=%d\n",
629 sps->bit_depth_luma);
631 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
632 av_log(h->avctx, AV_LOG_ERROR,
633 "Unimplemented luma bit depth=%d\n",
634 sps->bit_depth_luma);
638 pps->cabac = get_bits1(&h->gb);
639 pps->pic_order_present = get_bits1(&h->gb);
640 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
641 if (pps->slice_group_count > 1) {
642 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
643 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
644 switch (pps->mb_slice_group_map_type) {
647 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
648 | run_length[i] |1 |ue(v) |
653 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
654 | top_left_mb[i] |1 |ue(v) |
655 | bottom_right_mb[i] |1 |ue(v) |
663 | slice_group_change_direction_flag |1 |u(1) |
664 | slice_group_change_rate_minus1 |1 |ue(v) |
669 | slice_group_id_cnt_minus1 |1 |ue(v) |
670 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
671 | slice_group_id[i] |1 |u(v) |
676 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
677 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
678 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
679 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
683 pps->weighted_pred = get_bits1(&h->gb);
684 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
685 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
686 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
687 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
688 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
689 pps->constrained_intra_pred = get_bits1(&h->gb);
690 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
692 pps->transform_8x8_mode = 0;
693 // contents of sps/pps can change even if id doesn't, so reinit
694 h->dequant_coeff_pps = -1;
695 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
696 sizeof(pps->scaling_matrix4));
697 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
698 sizeof(pps->scaling_matrix8));
700 bits_left = bit_length - get_bits_count(&h->gb);
701 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
702 pps->transform_8x8_mode = get_bits1(&h->gb);
703 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
704 pps->scaling_matrix4, pps->scaling_matrix8);
705 // second_chroma_qp_index_offset
706 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
708 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
711 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
712 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
713 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
714 pps->chroma_qp_diff = 1;
716 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
717 av_log(h->avctx, AV_LOG_DEBUG,
718 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
720 pps->cabac ? "CABAC" : "CAVLC",
721 pps->slice_group_count,
722 pps->ref_count[0], pps->ref_count[1],
723 pps->weighted_pred ? "weighted" : "",
724 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
725 pps->deblocking_filter_parameters_present ? "LPAR" : "",
726 pps->constrained_intra_pred ? "CONSTR" : "",
727 pps->redundant_pic_cnt_present ? "REDU" : "",
728 pps->transform_8x8_mode ? "8x8DCT" : "");
731 av_free(h->pps_buffers[pps_id]);
732 h->pps_buffers[pps_id] = pps;