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"
34 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
38 #define MIN_LOG2_MAX_FRAME_NUM 4
40 static const AVRational pixel_aspect[17] = {
60 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
62 #define CHROMA_QP_TABLE_END(d) \
63 QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
64 QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
65 QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
66 QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
67 QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
68 QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
69 QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
70 QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
71 QP(39, d), QP(39, d), QP(39, d), QP(39, d)
73 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1] = {
74 { CHROMA_QP_TABLE_END(8) },
76 CHROMA_QP_TABLE_END(9) },
79 CHROMA_QP_TABLE_END(10) },
83 CHROMA_QP_TABLE_END(11) },
88 CHROMA_QP_TABLE_END(12) },
94 CHROMA_QP_TABLE_END(13) },
101 CHROMA_QP_TABLE_END(14) },
104 static const uint8_t default_scaling4[2][16] = {
105 { 6, 13, 20, 28, 13, 20, 28, 32,
106 20, 28, 32, 37, 28, 32, 37, 42 },
107 { 10, 14, 20, 24, 14, 20, 24, 27,
108 20, 24, 27, 30, 24, 27, 30, 34 }
111 static const uint8_t default_scaling8[2][64] = {
112 { 6, 10, 13, 16, 18, 23, 25, 27,
113 10, 11, 16, 18, 23, 25, 27, 29,
114 13, 16, 18, 23, 25, 27, 29, 31,
115 16, 18, 23, 25, 27, 29, 31, 33,
116 18, 23, 25, 27, 29, 31, 33, 36,
117 23, 25, 27, 29, 31, 33, 36, 38,
118 25, 27, 29, 31, 33, 36, 38, 40,
119 27, 29, 31, 33, 36, 38, 40, 42 },
120 { 9, 13, 15, 17, 19, 21, 22, 24,
121 13, 13, 17, 19, 21, 22, 24, 25,
122 15, 17, 19, 21, 22, 24, 25, 27,
123 17, 19, 21, 22, 24, 25, 27, 28,
124 19, 21, 22, 24, 25, 27, 28, 30,
125 21, 22, 24, 25, 27, 28, 30, 32,
126 22, 24, 25, 27, 28, 30, 32, 33,
127 24, 25, 27, 28, 30, 32, 33, 35 }
130 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
133 cpb_count = get_ue_golomb_31(&h->gb) + 1;
135 if (cpb_count > 32U) {
136 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
137 return AVERROR_INVALIDDATA;
140 get_bits(&h->gb, 4); /* bit_rate_scale */
141 get_bits(&h->gb, 4); /* cpb_size_scale */
142 for (i = 0; i < cpb_count; i++) {
143 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
144 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
145 get_bits1(&h->gb); /* cbr_flag */
147 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
148 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
149 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
150 sps->time_offset_length = get_bits(&h->gb, 5);
151 sps->cpb_cnt = cpb_count;
155 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
157 int aspect_ratio_info_present_flag;
158 unsigned int aspect_ratio_idc;
160 aspect_ratio_info_present_flag = get_bits1(&h->gb);
162 if (aspect_ratio_info_present_flag) {
163 aspect_ratio_idc = get_bits(&h->gb, 8);
164 if (aspect_ratio_idc == EXTENDED_SAR) {
165 sps->sar.num = get_bits(&h->gb, 16);
166 sps->sar.den = get_bits(&h->gb, 16);
167 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
168 sps->sar = pixel_aspect[aspect_ratio_idc];
170 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
171 return AVERROR_INVALIDDATA;
178 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
179 get_bits1(&h->gb); /* overscan_appropriate_flag */
181 sps->video_signal_type_present_flag = get_bits1(&h->gb);
182 if (sps->video_signal_type_present_flag) {
183 get_bits(&h->gb, 3); /* video_format */
184 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
186 sps->colour_description_present_flag = get_bits1(&h->gb);
187 if (sps->colour_description_present_flag) {
188 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
189 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
190 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
191 if (sps->color_primaries >= AVCOL_PRI_NB)
192 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
193 if (sps->color_trc >= AVCOL_TRC_NB)
194 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
195 if (sps->colorspace >= AVCOL_SPC_NB)
196 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
200 /* chroma_location_info_present_flag */
201 if (get_bits1(&h->gb)) {
202 /* chroma_sample_location_type_top_field */
203 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
204 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
207 if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
208 av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
212 sps->timing_info_present_flag = get_bits1(&h->gb);
213 if (sps->timing_info_present_flag) {
214 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
215 sps->time_scale = get_bits_long(&h->gb, 32);
216 if (!sps->num_units_in_tick || !sps->time_scale) {
217 av_log(h->avctx, AV_LOG_ERROR,
218 "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",
219 sps->time_scale, sps->num_units_in_tick);
220 return AVERROR_INVALIDDATA;
222 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
225 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
226 if (sps->nal_hrd_parameters_present_flag)
227 if (decode_hrd_parameters(h, sps) < 0)
228 return AVERROR_INVALIDDATA;
229 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
230 if (sps->vcl_hrd_parameters_present_flag)
231 if (decode_hrd_parameters(h, sps) < 0)
232 return AVERROR_INVALIDDATA;
233 if (sps->nal_hrd_parameters_present_flag ||
234 sps->vcl_hrd_parameters_present_flag)
235 get_bits1(&h->gb); /* low_delay_hrd_flag */
236 sps->pic_struct_present_flag = get_bits1(&h->gb);
237 if (!get_bits_left(&h->gb))
239 sps->bitstream_restriction_flag = get_bits1(&h->gb);
240 if (sps->bitstream_restriction_flag) {
241 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
242 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
243 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
244 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
245 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
246 sps->num_reorder_frames = get_ue_golomb(&h->gb);
247 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
249 if (get_bits_left(&h->gb) < 0) {
250 sps->num_reorder_frames = 0;
251 sps->bitstream_restriction_flag = 0;
254 if (sps->num_reorder_frames > 16U
255 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
256 av_log(h->avctx, AV_LOG_ERROR,
257 "Clipping illegal num_reorder_frames %d\n",
258 sps->num_reorder_frames);
259 sps->num_reorder_frames = 16;
260 return AVERROR_INVALIDDATA;
264 if (get_bits_left(&h->gb) < 0) {
265 av_log(h->avctx, AV_LOG_ERROR,
266 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
267 return AVERROR_INVALIDDATA;
273 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
274 const uint8_t *jvt_list,
275 const uint8_t *fallback_list)
277 int i, last = 8, next = 8;
278 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
279 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
280 memcpy(factors, fallback_list, size * sizeof(uint8_t));
282 for (i = 0; i < size; i++) {
284 next = (last + get_se_golomb(&h->gb)) & 0xff;
285 if (!i && !next) { /* matrix not written, we use the preset one */
286 memcpy(factors, jvt_list, size * sizeof(uint8_t));
289 last = factors[scan[i]] = next ? next : last;
293 static void decode_scaling_matrices(H264Context *h, SPS *sps,
294 PPS *pps, int is_sps,
295 uint8_t(*scaling_matrix4)[16],
296 uint8_t(*scaling_matrix8)[64])
298 int fallback_sps = !is_sps && sps->scaling_matrix_present;
299 const uint8_t *fallback[4] = {
300 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
301 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
302 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
303 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
305 if (get_bits1(&h->gb)) {
306 sps->scaling_matrix_present |= is_sps;
307 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
308 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
309 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
310 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
311 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
312 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
313 if (is_sps || pps->transform_8x8_mode) {
314 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
315 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
316 if (sps->chroma_format_idc == 3) {
317 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
318 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
319 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
320 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
326 int ff_h264_decode_seq_parameter_set(H264Context *h)
328 int profile_idc, level_idc, constraint_set_flags = 0;
330 int i, log2_max_frame_num_minus4;
333 profile_idc = get_bits(&h->gb, 8);
334 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
335 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
336 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
337 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
338 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
339 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
340 skip_bits(&h->gb, 2); // reserved_zero_2bits
341 level_idc = get_bits(&h->gb, 8);
342 sps_id = get_ue_golomb_31(&h->gb);
344 if (sps_id >= MAX_SPS_COUNT) {
345 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
346 return AVERROR_INVALIDDATA;
348 sps = av_mallocz(sizeof(SPS));
350 return AVERROR(ENOMEM);
352 sps->sps_id = sps_id;
353 sps->time_offset_length = 24;
354 sps->profile_idc = profile_idc;
355 sps->constraint_set_flags = constraint_set_flags;
356 sps->level_idc = level_idc;
357 sps->full_range = -1;
359 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
360 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
361 sps->scaling_matrix_present = 0;
362 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
364 if (sps->profile_idc == 100 || // High profile
365 sps->profile_idc == 110 || // High10 profile
366 sps->profile_idc == 122 || // High422 profile
367 sps->profile_idc == 244 || // High444 Predictive profile
368 sps->profile_idc == 44 || // Cavlc444 profile
369 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
370 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
371 sps->profile_idc == 118 || // Stereo High profile (MVC)
372 sps->profile_idc == 128 || // Multiview High profile (MVC)
373 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
374 sps->profile_idc == 144) { // old High444 profile
375 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
376 if (sps->chroma_format_idc > 3U) {
377 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
378 sps->chroma_format_idc);
380 } else if (sps->chroma_format_idc == 3) {
381 sps->residual_color_transform_flag = get_bits1(&h->gb);
382 if (sps->residual_color_transform_flag) {
383 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
387 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
388 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
389 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
390 avpriv_request_sample(h->avctx,
391 "Different chroma and luma bit depth");
394 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
395 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
396 sps->bit_depth_luma, sps->bit_depth_chroma);
399 sps->transform_bypass = get_bits1(&h->gb);
400 decode_scaling_matrices(h, sps, NULL, 1,
401 sps->scaling_matrix4, sps->scaling_matrix8);
403 sps->chroma_format_idc = 1;
404 sps->bit_depth_luma = 8;
405 sps->bit_depth_chroma = 8;
408 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
409 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
410 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
411 av_log(h->avctx, AV_LOG_ERROR,
412 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
413 log2_max_frame_num_minus4);
416 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
418 sps->poc_type = get_ue_golomb_31(&h->gb);
420 if (sps->poc_type == 0) { // FIXME #define
421 unsigned t = get_ue_golomb(&h->gb);
423 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
426 sps->log2_max_poc_lsb = t + 4;
427 } else if (sps->poc_type == 1) { // FIXME #define
428 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
429 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
430 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
431 sps->poc_cycle_length = get_ue_golomb(&h->gb);
433 if ((unsigned)sps->poc_cycle_length >=
434 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
435 av_log(h->avctx, AV_LOG_ERROR,
436 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
440 for (i = 0; i < sps->poc_cycle_length; i++)
441 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
442 } else if (sps->poc_type != 2) {
443 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
447 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
448 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
449 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
450 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
451 sps->ref_frame_count > 16U) {
452 av_log(h->avctx, AV_LOG_ERROR,
453 "too many reference frames %d\n", sps->ref_frame_count);
456 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
457 sps->mb_width = get_ue_golomb(&h->gb) + 1;
458 sps->mb_height = get_ue_golomb(&h->gb) + 1;
459 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
460 (unsigned)sps->mb_height >= INT_MAX / 16 ||
461 av_image_check_size(16 * sps->mb_width,
462 16 * sps->mb_height, 0, h->avctx)) {
463 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
467 sps->frame_mbs_only_flag = get_bits1(&h->gb);
468 if (!sps->frame_mbs_only_flag)
469 sps->mb_aff = get_bits1(&h->gb);
473 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
475 #ifndef ALLOW_INTERLACE
477 av_log(h->avctx, AV_LOG_ERROR,
478 "MBAFF support not included; enable it at compile-time.\n");
480 sps->crop = get_bits1(&h->gb);
482 int crop_left = get_ue_golomb(&h->gb);
483 int crop_right = get_ue_golomb(&h->gb);
484 int crop_top = get_ue_golomb(&h->gb);
485 int crop_bottom = get_ue_golomb(&h->gb);
486 int width = 16 * sps->mb_width;
487 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
489 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
490 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
491 "values are l:%d r:%d t:%d b:%d\n",
492 crop_left, crop_right, crop_top, crop_bottom);
497 sps->crop_bottom = 0;
499 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
500 int hsub = (sps->chroma_format_idc == 1 ||
501 sps->chroma_format_idc == 2) ? 1 : 0;
502 int step_x = 1 << hsub;
503 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
505 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
506 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
507 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
508 av_log(h->avctx, AV_LOG_WARNING,
509 "Reducing left cropping to %d "
510 "chroma samples to preserve alignment.\n",
514 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
515 crop_right > (unsigned)INT_MAX / 4 / step_x ||
516 crop_top > (unsigned)INT_MAX / 4 / step_y ||
517 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
518 (crop_left + crop_right ) * step_x >= width ||
519 (crop_top + crop_bottom) * step_y >= height
521 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);
525 sps->crop_left = crop_left * step_x;
526 sps->crop_right = crop_right * step_x;
527 sps->crop_top = crop_top * step_y;
528 sps->crop_bottom = crop_bottom * step_y;
538 sps->vui_parameters_present_flag = get_bits1(&h->gb);
539 if (sps->vui_parameters_present_flag) {
540 int ret = decode_vui_parameters(h, sps);
548 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
549 static const char csp[4][5] = { "Gray", "420", "422", "444" };
550 av_log(h->avctx, AV_LOG_DEBUG,
551 "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",
552 sps_id, sps->profile_idc, sps->level_idc,
554 sps->ref_frame_count,
555 sps->mb_width, sps->mb_height,
556 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
557 sps->direct_8x8_inference_flag ? "8B8" : "",
558 sps->crop_left, sps->crop_right,
559 sps->crop_top, sps->crop_bottom,
560 sps->vui_parameters_present_flag ? "VUI" : "",
561 csp[sps->chroma_format_idc],
562 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
563 sps->timing_info_present_flag ? sps->time_scale : 0,
565 sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
570 av_free(h->sps_buffers[sps_id]);
571 h->sps_buffers[sps_id] = sps;
580 static void build_qp_table(PPS *pps, int t, int index, const int depth)
583 const int max_qp = 51 + 6 * (depth - 8);
584 for (i = 0; i < max_qp + 1; i++)
585 pps->chroma_qp_table[t][i] =
586 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
589 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
591 const SPS *sps = h->sps_buffers[pps->sps_id];
592 int profile_idc = sps->profile_idc;
594 if ((profile_idc == 66 || profile_idc == 77 ||
595 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
596 av_log(h->avctx, AV_LOG_VERBOSE,
597 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
604 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
606 unsigned int pps_id = get_ue_golomb(&h->gb);
612 if (pps_id >= MAX_PPS_COUNT) {
613 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
614 return AVERROR_INVALIDDATA;
617 pps = av_mallocz(sizeof(PPS));
619 return AVERROR(ENOMEM);
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] == NULL) {
623 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
626 sps = h->sps_buffers[pps->sps_id];
627 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
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);
633 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
634 av_log(h->avctx, AV_LOG_ERROR,
635 "Unimplemented luma bit depth=%d\n",
636 sps->bit_depth_luma);
640 pps->cabac = get_bits1(&h->gb);
641 pps->pic_order_present = get_bits1(&h->gb);
642 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
643 if (pps->slice_group_count > 1) {
644 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
645 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
646 switch (pps->mb_slice_group_map_type) {
649 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
650 | run_length[i] |1 |ue(v) |
655 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
656 | top_left_mb[i] |1 |ue(v) |
657 | bottom_right_mb[i] |1 |ue(v) |
665 | slice_group_change_direction_flag |1 |u(1) |
666 | slice_group_change_rate_minus1 |1 |ue(v) |
671 | slice_group_id_cnt_minus1 |1 |ue(v) |
672 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
673 | slice_group_id[i] |1 |u(v) |
678 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
679 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
680 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
681 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
685 pps->weighted_pred = get_bits1(&h->gb);
686 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
687 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
688 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
689 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
690 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
691 pps->constrained_intra_pred = get_bits1(&h->gb);
692 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
694 pps->transform_8x8_mode = 0;
695 // contents of sps/pps can change even if id doesn't, so reinit
696 h->dequant_coeff_pps = -1;
697 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
698 sizeof(pps->scaling_matrix4));
699 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
700 sizeof(pps->scaling_matrix8));
702 bits_left = bit_length - get_bits_count(&h->gb);
703 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
704 pps->transform_8x8_mode = get_bits1(&h->gb);
705 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
706 pps->scaling_matrix4, pps->scaling_matrix8);
707 // second_chroma_qp_index_offset
708 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
710 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
713 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
714 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
715 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
716 pps->chroma_qp_diff = 1;
718 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
719 av_log(h->avctx, AV_LOG_DEBUG,
720 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
722 pps->cabac ? "CABAC" : "CAVLC",
723 pps->slice_group_count,
724 pps->ref_count[0], pps->ref_count[1],
725 pps->weighted_pred ? "weighted" : "",
726 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
727 pps->deblocking_filter_parameters_present ? "LPAR" : "",
728 pps->constrained_intra_pred ? "CONSTR" : "",
729 pps->redundant_pic_cnt_present ? "REDU" : "",
730 pps->transform_8x8_mode ? "8x8DCT" : "");
733 av_free(h->pps_buffers[pps_id]);
734 h->pps_buffers[pps_id] = pps;