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 Libav.
7 * Libav 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 * Libav 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 Libav; 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[3][QP_MAX_NUM + 1] = {
72 { CHROMA_QP_TABLE_END(8) },
74 CHROMA_QP_TABLE_END(9) },
77 CHROMA_QP_TABLE_END(10) },
80 static const uint8_t default_scaling4[2][16] = {
81 { 6, 13, 20, 28, 13, 20, 28, 32,
82 20, 28, 32, 37, 28, 32, 37, 42 },
83 { 10, 14, 20, 24, 14, 20, 24, 27,
84 20, 24, 27, 30, 24, 27, 30, 34 }
87 static const uint8_t default_scaling8[2][64] = {
88 { 6, 10, 13, 16, 18, 23, 25, 27,
89 10, 11, 16, 18, 23, 25, 27, 29,
90 13, 16, 18, 23, 25, 27, 29, 31,
91 16, 18, 23, 25, 27, 29, 31, 33,
92 18, 23, 25, 27, 29, 31, 33, 36,
93 23, 25, 27, 29, 31, 33, 36, 38,
94 25, 27, 29, 31, 33, 36, 38, 40,
95 27, 29, 31, 33, 36, 38, 40, 42 },
96 { 9, 13, 15, 17, 19, 21, 22, 24,
97 13, 13, 17, 19, 21, 22, 24, 25,
98 15, 17, 19, 21, 22, 24, 25, 27,
99 17, 19, 21, 22, 24, 25, 27, 28,
100 19, 21, 22, 24, 25, 27, 28, 30,
101 21, 22, 24, 25, 27, 28, 30, 32,
102 22, 24, 25, 27, 28, 30, 32, 33,
103 24, 25, 27, 28, 30, 32, 33, 35 }
106 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
109 cpb_count = get_ue_golomb_31(&h->gb) + 1;
111 if (cpb_count > 32U) {
112 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
113 return AVERROR_INVALIDDATA;
116 get_bits(&h->gb, 4); /* bit_rate_scale */
117 get_bits(&h->gb, 4); /* cpb_size_scale */
118 for (i = 0; i < cpb_count; i++) {
119 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
120 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
121 get_bits1(&h->gb); /* cbr_flag */
123 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
124 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
125 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
126 sps->time_offset_length = get_bits(&h->gb, 5);
127 sps->cpb_cnt = cpb_count;
131 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
133 int aspect_ratio_info_present_flag;
134 unsigned int aspect_ratio_idc;
136 aspect_ratio_info_present_flag = get_bits1(&h->gb);
138 if (aspect_ratio_info_present_flag) {
139 aspect_ratio_idc = get_bits(&h->gb, 8);
140 if (aspect_ratio_idc == EXTENDED_SAR) {
141 sps->sar.num = get_bits(&h->gb, 16);
142 sps->sar.den = get_bits(&h->gb, 16);
143 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
144 sps->sar = pixel_aspect[aspect_ratio_idc];
146 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
147 return AVERROR_INVALIDDATA;
154 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
155 get_bits1(&h->gb); /* overscan_appropriate_flag */
157 sps->video_signal_type_present_flag = get_bits1(&h->gb);
158 if (sps->video_signal_type_present_flag) {
159 get_bits(&h->gb, 3); /* video_format */
160 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
162 sps->colour_description_present_flag = get_bits1(&h->gb);
163 if (sps->colour_description_present_flag) {
164 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
165 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
166 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
167 if (sps->color_primaries >= AVCOL_PRI_NB)
168 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
169 if (sps->color_trc >= AVCOL_TRC_NB)
170 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
171 if (sps->colorspace >= AVCOL_SPC_NB)
172 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
176 /* chroma_location_info_present_flag */
177 if (get_bits1(&h->gb)) {
178 /* chroma_sample_location_type_top_field */
179 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
180 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
183 sps->timing_info_present_flag = get_bits1(&h->gb);
184 if (sps->timing_info_present_flag) {
185 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
186 sps->time_scale = get_bits_long(&h->gb, 32);
187 if (!sps->num_units_in_tick || !sps->time_scale) {
188 av_log(h->avctx, AV_LOG_ERROR,
189 "time_scale/num_units_in_tick invalid or unsupported (%d/%d)\n",
190 sps->time_scale, sps->num_units_in_tick);
191 return AVERROR_INVALIDDATA;
193 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
196 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
197 if (sps->nal_hrd_parameters_present_flag)
198 if (decode_hrd_parameters(h, sps) < 0)
199 return AVERROR_INVALIDDATA;
200 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
201 if (sps->vcl_hrd_parameters_present_flag)
202 if (decode_hrd_parameters(h, sps) < 0)
203 return AVERROR_INVALIDDATA;
204 if (sps->nal_hrd_parameters_present_flag ||
205 sps->vcl_hrd_parameters_present_flag)
206 get_bits1(&h->gb); /* low_delay_hrd_flag */
207 sps->pic_struct_present_flag = get_bits1(&h->gb);
209 sps->bitstream_restriction_flag = get_bits1(&h->gb);
210 if (sps->bitstream_restriction_flag) {
211 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
212 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
213 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
214 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
215 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
216 sps->num_reorder_frames = get_ue_golomb(&h->gb);
217 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
219 if (get_bits_left(&h->gb) < 0) {
220 sps->num_reorder_frames = 0;
221 sps->bitstream_restriction_flag = 0;
224 if (sps->num_reorder_frames > 16U
225 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
226 av_log(h->avctx, AV_LOG_ERROR,
227 "Clipping illegal num_reorder_frames %d\n",
228 sps->num_reorder_frames);
229 sps->num_reorder_frames = 16;
230 return AVERROR_INVALIDDATA;
233 if (get_bits_left(&h->gb) < 0) {
234 av_log(h->avctx, AV_LOG_ERROR,
235 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
236 return AVERROR_INVALIDDATA;
242 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
243 const uint8_t *jvt_list,
244 const uint8_t *fallback_list)
246 int i, last = 8, next = 8;
247 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
248 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
249 memcpy(factors, fallback_list, size * sizeof(uint8_t));
251 for (i = 0; i < size; i++) {
253 next = (last + get_se_golomb(&h->gb)) & 0xff;
254 if (!i && !next) { /* matrix not written, we use the preset one */
255 memcpy(factors, jvt_list, size * sizeof(uint8_t));
258 last = factors[scan[i]] = next ? next : last;
262 static void decode_scaling_matrices(H264Context *h, SPS *sps,
263 PPS *pps, int is_sps,
264 uint8_t(*scaling_matrix4)[16],
265 uint8_t(*scaling_matrix8)[64])
267 int fallback_sps = !is_sps && sps->scaling_matrix_present;
268 const uint8_t *fallback[4] = {
269 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
270 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
271 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
272 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
274 if (get_bits1(&h->gb)) {
275 sps->scaling_matrix_present |= is_sps;
276 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
277 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
278 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
279 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
280 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
281 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
282 if (is_sps || pps->transform_8x8_mode) {
283 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
284 if (sps->chroma_format_idc == 3) {
285 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
286 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
288 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
289 if (sps->chroma_format_idc == 3) {
290 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
291 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
297 int ff_h264_decode_seq_parameter_set(H264Context *h)
299 int profile_idc, level_idc, constraint_set_flags = 0;
301 int i, log2_max_frame_num_minus4;
304 profile_idc = get_bits(&h->gb, 8);
305 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
306 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
307 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
308 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
309 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
310 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
311 skip_bits(&h->gb, 2); // reserved_zero_2bits
312 level_idc = get_bits(&h->gb, 8);
313 sps_id = get_ue_golomb_31(&h->gb);
315 if (sps_id >= MAX_SPS_COUNT) {
316 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
317 return AVERROR_INVALIDDATA;
319 sps = av_mallocz(sizeof(SPS));
321 return AVERROR(ENOMEM);
323 sps->sps_id = sps_id;
324 sps->time_offset_length = 24;
325 sps->profile_idc = profile_idc;
326 sps->constraint_set_flags = constraint_set_flags;
327 sps->level_idc = level_idc;
329 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
330 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
331 sps->scaling_matrix_present = 0;
333 if (sps->profile_idc == 100 || // High profile
334 sps->profile_idc == 110 || // High10 profile
335 sps->profile_idc == 122 || // High422 profile
336 sps->profile_idc == 244 || // High444 Predictive profile
337 sps->profile_idc == 44 || // Cavlc444 profile
338 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
339 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
340 sps->profile_idc == 118 || // Stereo High profile (MVC)
341 sps->profile_idc == 128 || // Multiview High profile (MVC)
342 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
343 sps->profile_idc == 144) { // old High444 profile
344 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
345 if (sps->chroma_format_idc > 3) {
346 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
347 sps->chroma_format_idc);
349 } else if (sps->chroma_format_idc == 3) {
350 sps->residual_color_transform_flag = get_bits1(&h->gb);
352 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
353 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
354 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
355 avpriv_request_sample(h->avctx,
356 "Different chroma and luma bit depth");
359 sps->transform_bypass = get_bits1(&h->gb);
360 decode_scaling_matrices(h, sps, NULL, 1,
361 sps->scaling_matrix4, sps->scaling_matrix8);
363 sps->chroma_format_idc = 1;
364 sps->bit_depth_luma = 8;
365 sps->bit_depth_chroma = 8;
368 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
369 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
370 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
371 av_log(h->avctx, AV_LOG_ERROR,
372 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
373 log2_max_frame_num_minus4);
376 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
378 sps->poc_type = get_ue_golomb_31(&h->gb);
380 if (sps->poc_type == 0) { // FIXME #define
381 sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
382 } else if (sps->poc_type == 1) { // FIXME #define
383 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
384 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
385 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
386 sps->poc_cycle_length = get_ue_golomb(&h->gb);
388 if ((unsigned)sps->poc_cycle_length >=
389 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
390 av_log(h->avctx, AV_LOG_ERROR,
391 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
395 for (i = 0; i < sps->poc_cycle_length; i++)
396 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
397 } else if (sps->poc_type != 2) {
398 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
402 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
403 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
404 sps->ref_frame_count >= 32U) {
405 av_log(h->avctx, AV_LOG_ERROR,
406 "too many reference frames %d\n", sps->ref_frame_count);
409 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
410 sps->mb_width = get_ue_golomb(&h->gb) + 1;
411 sps->mb_height = get_ue_golomb(&h->gb) + 1;
412 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
413 (unsigned)sps->mb_height >= INT_MAX / 16 ||
414 av_image_check_size(16 * sps->mb_width,
415 16 * sps->mb_height, 0, h->avctx)) {
416 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
420 sps->frame_mbs_only_flag = get_bits1(&h->gb);
421 if (!sps->frame_mbs_only_flag)
422 sps->mb_aff = get_bits1(&h->gb);
426 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
427 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
428 av_log(h->avctx, AV_LOG_ERROR,
429 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
433 #ifndef ALLOW_INTERLACE
435 av_log(h->avctx, AV_LOG_ERROR,
436 "MBAFF support not included; enable it at compile-time.\n");
438 sps->crop = get_bits1(&h->gb);
440 int crop_left = get_ue_golomb(&h->gb);
441 int crop_right = get_ue_golomb(&h->gb);
442 int crop_top = get_ue_golomb(&h->gb);
443 int crop_bottom = get_ue_golomb(&h->gb);
445 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
446 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
447 "values are l:%u r:%u t:%u b:%u\n",
448 crop_left, crop_right, crop_top, crop_bottom);
453 sps->crop_bottom = 0;
455 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
456 int hsub = (sps->chroma_format_idc == 1 ||
457 sps->chroma_format_idc == 2) ? 1 : 0;
458 int step_x = 1 << hsub;
459 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
461 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
462 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
463 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
464 av_log(h->avctx, AV_LOG_WARNING,
465 "Reducing left cropping to %d "
466 "chroma samples to preserve alignment.\n",
470 sps->crop_left = crop_left * step_x;
471 sps->crop_right = crop_right * step_x;
472 sps->crop_top = crop_top * step_y;
473 sps->crop_bottom = crop_bottom * step_y;
483 sps->vui_parameters_present_flag = get_bits1(&h->gb);
484 if (sps->vui_parameters_present_flag) {
485 int ret = decode_vui_parameters(h, sps);
486 if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
493 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
494 static const char csp[4][5] = { "Gray", "420", "422", "444" };
495 av_log(h->avctx, AV_LOG_DEBUG,
496 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
497 sps_id, sps->profile_idc, sps->level_idc,
499 sps->ref_frame_count,
500 sps->mb_width, sps->mb_height,
501 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
502 sps->direct_8x8_inference_flag ? "8B8" : "",
503 sps->crop_left, sps->crop_right,
504 sps->crop_top, sps->crop_bottom,
505 sps->vui_parameters_present_flag ? "VUI" : "",
506 csp[sps->chroma_format_idc],
507 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
508 sps->timing_info_present_flag ? sps->time_scale : 0);
512 av_free(h->sps_buffers[sps_id]);
513 h->sps_buffers[sps_id] = sps;
523 static void build_qp_table(PPS *pps, int t, int index, const int depth)
526 const int max_qp = 51 + 6 * (depth - 8);
527 for (i = 0; i < max_qp + 1; i++)
528 pps->chroma_qp_table[t][i] =
529 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
532 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
534 unsigned int pps_id = get_ue_golomb(&h->gb);
536 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
539 if (pps_id >= MAX_PPS_COUNT) {
540 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
541 return AVERROR_INVALIDDATA;
542 } else if (h->sps.bit_depth_luma > 10) {
543 av_log(h->avctx, AV_LOG_ERROR,
544 "Unimplemented luma bit depth=%d (max=10)\n",
545 h->sps.bit_depth_luma);
546 return AVERROR_PATCHWELCOME;
549 pps = av_mallocz(sizeof(PPS));
551 return AVERROR(ENOMEM);
552 pps->sps_id = get_ue_golomb_31(&h->gb);
553 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
554 h->sps_buffers[pps->sps_id] == NULL) {
555 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
559 pps->cabac = get_bits1(&h->gb);
560 pps->pic_order_present = get_bits1(&h->gb);
561 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
562 if (pps->slice_group_count > 1) {
563 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
564 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
565 switch (pps->mb_slice_group_map_type) {
568 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
569 | run_length[i] |1 |ue(v) |
574 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
575 | top_left_mb[i] |1 |ue(v) |
576 | bottom_right_mb[i] |1 |ue(v) |
584 | slice_group_change_direction_flag |1 |u(1) |
585 | slice_group_change_rate_minus1 |1 |ue(v) |
590 | slice_group_id_cnt_minus1 |1 |ue(v) |
591 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
592 | slice_group_id[i] |1 |u(v) |
597 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
598 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
599 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
600 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
604 pps->weighted_pred = get_bits1(&h->gb);
605 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
606 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
607 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
608 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
609 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
610 pps->constrained_intra_pred = get_bits1(&h->gb);
611 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
613 pps->transform_8x8_mode = 0;
614 // contents of sps/pps can change even if id doesn't, so reinit
615 h->dequant_coeff_pps = -1;
616 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
617 sizeof(pps->scaling_matrix4));
618 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
619 sizeof(pps->scaling_matrix8));
621 bits_left = bit_length - get_bits_count(&h->gb);
622 if (bits_left && (bits_left > 8 ||
623 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
624 pps->transform_8x8_mode = get_bits1(&h->gb);
625 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
626 pps->scaling_matrix4, pps->scaling_matrix8);
627 // second_chroma_qp_index_offset
628 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
630 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
633 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
634 h->sps.bit_depth_luma);
635 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
636 h->sps.bit_depth_luma);
637 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
638 pps->chroma_qp_diff = 1;
640 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
641 av_log(h->avctx, AV_LOG_DEBUG,
642 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
644 pps->cabac ? "CABAC" : "CAVLC",
645 pps->slice_group_count,
646 pps->ref_count[0], pps->ref_count[1],
647 pps->weighted_pred ? "weighted" : "",
648 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
649 pps->deblocking_filter_parameters_present ? "LPAR" : "",
650 pps->constrained_intra_pred ? "CONSTR" : "",
651 pps->redundant_pic_cnt_present ? "REDU" : "",
652 pps->transform_8x8_mode ? "8x8DCT" : "");
655 av_free(h->pps_buffers[pps_id]);
656 h->pps_buffers[pps_id] = pps;