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 "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
256 return AVERROR_INVALIDDATA;
260 if (get_bits_left(&h->gb) < 0) {
261 av_log(h->avctx, AV_LOG_ERROR,
262 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
263 return AVERROR_INVALIDDATA;
269 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
270 const uint8_t *jvt_list,
271 const uint8_t *fallback_list)
273 int i, last = 8, next = 8;
274 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
275 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
276 memcpy(factors, fallback_list, size * sizeof(uint8_t));
278 for (i = 0; i < size; i++) {
280 next = (last + get_se_golomb(&h->gb)) & 0xff;
281 if (!i && !next) { /* matrix not written, we use the preset one */
282 memcpy(factors, jvt_list, size * sizeof(uint8_t));
285 last = factors[scan[i]] = next ? next : last;
289 static void decode_scaling_matrices(H264Context *h, SPS *sps,
290 PPS *pps, int is_sps,
291 uint8_t(*scaling_matrix4)[16],
292 uint8_t(*scaling_matrix8)[64])
294 int fallback_sps = !is_sps && sps->scaling_matrix_present;
295 const uint8_t *fallback[4] = {
296 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
297 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
298 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
299 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
301 if (get_bits1(&h->gb)) {
302 sps->scaling_matrix_present |= is_sps;
303 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
304 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
305 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
306 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
307 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
308 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
309 if (is_sps || pps->transform_8x8_mode) {
310 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
311 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
312 if (sps->chroma_format_idc == 3) {
313 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
314 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
315 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
316 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
322 int ff_h264_decode_seq_parameter_set(H264Context *h)
324 int profile_idc, level_idc, constraint_set_flags = 0;
326 int i, log2_max_frame_num_minus4;
329 profile_idc = get_bits(&h->gb, 8);
330 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
331 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
332 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
333 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
334 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
335 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
336 get_bits(&h->gb, 2); // reserved
337 level_idc = get_bits(&h->gb, 8);
338 sps_id = get_ue_golomb_31(&h->gb);
340 if (sps_id >= MAX_SPS_COUNT) {
341 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
342 return AVERROR_INVALIDDATA;
344 sps = av_mallocz(sizeof(SPS));
346 return AVERROR(ENOMEM);
348 sps->time_offset_length = 24;
349 sps->profile_idc = profile_idc;
350 sps->constraint_set_flags = constraint_set_flags;
351 sps->level_idc = level_idc;
352 sps->full_range = -1;
354 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
355 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
356 sps->scaling_matrix_present = 0;
357 sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
359 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
360 sps->profile_idc == 122 || sps->profile_idc == 244 ||
361 sps->profile_idc == 44 || sps->profile_idc == 83 ||
362 sps->profile_idc == 86 || sps->profile_idc == 118 ||
363 sps->profile_idc == 128 || sps->profile_idc == 144) {
364 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
365 if (sps->chroma_format_idc > 3U) {
366 av_log(h->avctx, AV_LOG_ERROR,
367 "chroma_format_idc %d is illegal\n",
368 sps->chroma_format_idc);
370 } else if (sps->chroma_format_idc == 3) {
371 sps->residual_color_transform_flag = get_bits1(&h->gb);
372 if (sps->residual_color_transform_flag) {
373 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
377 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
378 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
379 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
380 avpriv_request_sample(h->avctx,
381 "Different chroma and luma bit depth");
384 if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
385 av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
386 sps->bit_depth_luma, sps->bit_depth_chroma);
389 sps->transform_bypass = get_bits1(&h->gb);
390 decode_scaling_matrices(h, sps, NULL, 1,
391 sps->scaling_matrix4, sps->scaling_matrix8);
393 sps->chroma_format_idc = 1;
394 sps->bit_depth_luma = 8;
395 sps->bit_depth_chroma = 8;
398 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
399 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
400 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
401 av_log(h->avctx, AV_LOG_ERROR,
402 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
403 log2_max_frame_num_minus4);
406 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
408 sps->poc_type = get_ue_golomb_31(&h->gb);
410 if (sps->poc_type == 0) { // FIXME #define
411 unsigned t = get_ue_golomb(&h->gb);
413 av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
416 sps->log2_max_poc_lsb = t + 4;
417 } else if (sps->poc_type == 1) { // FIXME #define
418 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
419 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
420 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
421 sps->poc_cycle_length = get_ue_golomb(&h->gb);
423 if ((unsigned)sps->poc_cycle_length >=
424 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
425 av_log(h->avctx, AV_LOG_ERROR,
426 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
430 for (i = 0; i < sps->poc_cycle_length; i++)
431 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
432 } else if (sps->poc_type != 2) {
433 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
437 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
438 if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
439 sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
440 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
441 sps->ref_frame_count > 16U) {
442 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
445 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
446 sps->mb_width = get_ue_golomb(&h->gb) + 1;
447 sps->mb_height = get_ue_golomb(&h->gb) + 1;
448 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
449 (unsigned)sps->mb_height >= INT_MAX / 16 ||
450 av_image_check_size(16 * sps->mb_width,
451 16 * sps->mb_height, 0, h->avctx)) {
452 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
456 sps->frame_mbs_only_flag = get_bits1(&h->gb);
457 if (!sps->frame_mbs_only_flag)
458 sps->mb_aff = get_bits1(&h->gb);
462 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
464 #ifndef ALLOW_INTERLACE
466 av_log(h->avctx, AV_LOG_ERROR,
467 "MBAFF support not included; enable it at compile-time.\n");
469 sps->crop = get_bits1(&h->gb);
471 int crop_left = get_ue_golomb(&h->gb);
472 int crop_right = get_ue_golomb(&h->gb);
473 int crop_top = get_ue_golomb(&h->gb);
474 int crop_bottom = get_ue_golomb(&h->gb);
475 int width = 16 * sps->mb_width;
476 int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
478 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
479 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
480 "values are l:%u r:%u t:%u b:%u\n",
481 crop_left, crop_right, crop_top, crop_bottom);
486 sps->crop_bottom = 0;
488 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
489 int hsub = (sps->chroma_format_idc == 1 ||
490 sps->chroma_format_idc == 2) ? 1 : 0;
491 int step_x = 1 << hsub;
492 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
494 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
495 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
496 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
497 av_log(h->avctx, AV_LOG_WARNING,
498 "Reducing left cropping to %d "
499 "chroma samples to preserve alignment.\n",
503 if (crop_left > (unsigned)INT_MAX / 4 / step_x ||
504 crop_right > (unsigned)INT_MAX / 4 / step_x ||
505 crop_top > (unsigned)INT_MAX / 4 / step_y ||
506 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
507 (crop_left + crop_right ) * step_x >= width ||
508 (crop_top + crop_bottom) * step_y >= height
510 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);
514 sps->crop_left = crop_left * step_x;
515 sps->crop_right = crop_right * step_x;
516 sps->crop_top = crop_top * step_y;
517 sps->crop_bottom = crop_bottom * step_y;
527 sps->vui_parameters_present_flag = get_bits1(&h->gb);
528 if (sps->vui_parameters_present_flag) {
529 int ret = decode_vui_parameters(h, sps);
537 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
538 static const char csp[4][5] = { "Gray", "420", "422", "444" };
539 av_log(h->avctx, AV_LOG_DEBUG,
540 "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",
541 sps_id, sps->profile_idc, sps->level_idc,
543 sps->ref_frame_count,
544 sps->mb_width, sps->mb_height,
545 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
546 sps->direct_8x8_inference_flag ? "8B8" : "",
547 sps->crop_left, sps->crop_right,
548 sps->crop_top, sps->crop_bottom,
549 sps->vui_parameters_present_flag ? "VUI" : "",
550 csp[sps->chroma_format_idc],
551 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
552 sps->timing_info_present_flag ? sps->time_scale : 0,
554 h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
559 av_free(h->sps_buffers[sps_id]);
560 h->sps_buffers[sps_id] = sps;
569 static void build_qp_table(PPS *pps, int t, int index, const int depth)
572 const int max_qp = 51 + 6 * (depth - 8);
573 for (i = 0; i < max_qp + 1; i++)
574 pps->chroma_qp_table[t][i] =
575 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
578 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
580 const SPS *sps = h->sps_buffers[pps->sps_id];
581 int profile_idc = sps->profile_idc;
583 if ((profile_idc == 66 || profile_idc == 77 ||
584 profile_idc == 88) && (sps->constraint_set_flags & 7)) {
585 av_log(h->avctx, AV_LOG_VERBOSE,
586 "Current profile doesn't provide more RBSP data in PPS, skipping\n");
593 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
595 unsigned int pps_id = get_ue_golomb(&h->gb);
601 if (pps_id >= MAX_PPS_COUNT) {
602 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
603 return AVERROR_INVALIDDATA;
606 pps = av_mallocz(sizeof(PPS));
608 return AVERROR(ENOMEM);
609 pps->sps_id = get_ue_golomb_31(&h->gb);
610 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
611 h->sps_buffers[pps->sps_id] == NULL) {
612 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
615 sps = h->sps_buffers[pps->sps_id];
616 qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
617 if (sps->bit_depth_luma > 14) {
618 av_log(h->avctx, AV_LOG_ERROR,
619 "Invalid luma bit depth=%d\n",
620 sps->bit_depth_luma);
622 } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
623 av_log(h->avctx, AV_LOG_ERROR,
624 "Unimplemented luma bit depth=%d\n",
625 sps->bit_depth_luma);
629 pps->cabac = get_bits1(&h->gb);
630 pps->pic_order_present = get_bits1(&h->gb);
631 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
632 if (pps->slice_group_count > 1) {
633 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
634 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
635 switch (pps->mb_slice_group_map_type) {
638 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
639 | run_length[i] |1 |ue(v) |
644 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
645 | top_left_mb[i] |1 |ue(v) |
646 | bottom_right_mb[i] |1 |ue(v) |
654 | slice_group_change_direction_flag |1 |u(1) |
655 | slice_group_change_rate_minus1 |1 |ue(v) |
660 | slice_group_id_cnt_minus1 |1 |ue(v) |
661 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
662 | slice_group_id[i] |1 |u(v) |
667 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
668 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
669 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
670 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
674 pps->weighted_pred = get_bits1(&h->gb);
675 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
676 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
677 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
678 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
679 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
680 pps->constrained_intra_pred = get_bits1(&h->gb);
681 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
683 pps->transform_8x8_mode = 0;
684 // contents of sps/pps can change even if id doesn't, so reinit
685 h->dequant_coeff_pps = -1;
686 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
687 sizeof(pps->scaling_matrix4));
688 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
689 sizeof(pps->scaling_matrix8));
691 bits_left = bit_length - get_bits_count(&h->gb);
692 if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
693 pps->transform_8x8_mode = get_bits1(&h->gb);
694 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
695 pps->scaling_matrix4, pps->scaling_matrix8);
696 // second_chroma_qp_index_offset
697 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
699 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
702 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], sps->bit_depth_luma);
703 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], sps->bit_depth_luma);
704 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
705 pps->chroma_qp_diff = 1;
707 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
708 av_log(h->avctx, AV_LOG_DEBUG,
709 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
711 pps->cabac ? "CABAC" : "CAVLC",
712 pps->slice_group_count,
713 pps->ref_count[0], pps->ref_count[1],
714 pps->weighted_pred ? "weighted" : "",
715 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
716 pps->deblocking_filter_parameters_present ? "LPAR" : "",
717 pps->constrained_intra_pred ? "CONSTR" : "",
718 pps->redundant_pic_cnt_present ? "REDU" : "",
719 pps->transform_8x8_mode ? "8x8DCT" : "");
722 av_free(h->pps_buffers[pps_id]);
723 h->pps_buffers[pps_id] = pps;