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 "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
228 return AVERROR_INVALIDDATA;
231 if (get_bits_left(&h->gb) < 0) {
232 av_log(h->avctx, AV_LOG_ERROR,
233 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
234 return AVERROR_INVALIDDATA;
240 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
241 const uint8_t *jvt_list,
242 const uint8_t *fallback_list)
244 int i, last = 8, next = 8;
245 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
246 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
247 memcpy(factors, fallback_list, size * sizeof(uint8_t));
249 for (i = 0; i < size; i++) {
251 next = (last + get_se_golomb(&h->gb)) & 0xff;
252 if (!i && !next) { /* matrix not written, we use the preset one */
253 memcpy(factors, jvt_list, size * sizeof(uint8_t));
256 last = factors[scan[i]] = next ? next : last;
260 static void decode_scaling_matrices(H264Context *h, SPS *sps,
261 PPS *pps, int is_sps,
262 uint8_t(*scaling_matrix4)[16],
263 uint8_t(*scaling_matrix8)[64])
265 int fallback_sps = !is_sps && sps->scaling_matrix_present;
266 const uint8_t *fallback[4] = {
267 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
268 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
269 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
270 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
272 if (get_bits1(&h->gb)) {
273 sps->scaling_matrix_present |= is_sps;
274 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
275 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
276 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
277 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
278 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
279 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
280 if (is_sps || pps->transform_8x8_mode) {
281 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
282 if (sps->chroma_format_idc == 3) {
283 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
284 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
286 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
287 if (sps->chroma_format_idc == 3) {
288 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
289 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
295 int ff_h264_decode_seq_parameter_set(H264Context *h)
297 int profile_idc, level_idc, constraint_set_flags = 0;
299 int i, log2_max_frame_num_minus4;
302 profile_idc = get_bits(&h->gb, 8);
303 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
304 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
305 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
306 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
307 get_bits(&h->gb, 4); // reserved
308 level_idc = get_bits(&h->gb, 8);
309 sps_id = get_ue_golomb_31(&h->gb);
311 if (sps_id >= MAX_SPS_COUNT) {
312 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
313 return AVERROR_INVALIDDATA;
315 sps = av_mallocz(sizeof(SPS));
317 return AVERROR(ENOMEM);
319 sps->time_offset_length = 24;
320 sps->profile_idc = profile_idc;
321 sps->constraint_set_flags = constraint_set_flags;
322 sps->level_idc = level_idc;
324 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
325 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
326 sps->scaling_matrix_present = 0;
328 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
329 sps->profile_idc == 122 || sps->profile_idc == 244 ||
330 sps->profile_idc == 44 || sps->profile_idc == 83 ||
331 sps->profile_idc == 86 || sps->profile_idc == 118 ||
332 sps->profile_idc == 128 || sps->profile_idc == 144) {
333 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
334 if (sps->chroma_format_idc > 3) {
335 av_log(h->avctx, AV_LOG_ERROR,
336 "chroma_format_idc (%u) out of range\n",
337 sps->chroma_format_idc);
339 } else if (sps->chroma_format_idc == 3) {
340 sps->residual_color_transform_flag = get_bits1(&h->gb);
342 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
343 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
344 sps->transform_bypass = get_bits1(&h->gb);
345 decode_scaling_matrices(h, sps, NULL, 1,
346 sps->scaling_matrix4, sps->scaling_matrix8);
348 sps->chroma_format_idc = 1;
349 sps->bit_depth_luma = 8;
350 sps->bit_depth_chroma = 8;
353 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
354 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
355 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
356 av_log(h->avctx, AV_LOG_ERROR,
357 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
358 log2_max_frame_num_minus4);
361 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
363 sps->poc_type = get_ue_golomb_31(&h->gb);
365 if (sps->poc_type == 0) { // FIXME #define
366 sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
367 } else if (sps->poc_type == 1) { // FIXME #define
368 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
369 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
370 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
371 sps->poc_cycle_length = get_ue_golomb(&h->gb);
373 if ((unsigned)sps->poc_cycle_length >=
374 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
375 av_log(h->avctx, AV_LOG_ERROR,
376 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
380 for (i = 0; i < sps->poc_cycle_length; i++)
381 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
382 } else if (sps->poc_type != 2) {
383 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
387 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
388 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
389 sps->ref_frame_count >= 32U) {
390 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
393 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
394 sps->mb_width = get_ue_golomb(&h->gb) + 1;
395 sps->mb_height = get_ue_golomb(&h->gb) + 1;
396 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
397 (unsigned)sps->mb_height >= INT_MAX / 16 ||
398 av_image_check_size(16 * sps->mb_width,
399 16 * sps->mb_height, 0, h->avctx)) {
400 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
404 sps->frame_mbs_only_flag = get_bits1(&h->gb);
405 if (!sps->frame_mbs_only_flag)
406 sps->mb_aff = get_bits1(&h->gb);
410 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
411 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
412 av_log(h->avctx, AV_LOG_ERROR,
413 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
417 #ifndef ALLOW_INTERLACE
419 av_log(h->avctx, AV_LOG_ERROR,
420 "MBAFF support not included; enable it at compile-time.\n");
422 sps->crop = get_bits1(&h->gb);
424 int crop_left = get_ue_golomb(&h->gb);
425 int crop_right = get_ue_golomb(&h->gb);
426 int crop_top = get_ue_golomb(&h->gb);
427 int crop_bottom = get_ue_golomb(&h->gb);
429 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
430 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
431 "values are l:%u r:%u t:%u b:%u\n",
432 crop_left, crop_right, crop_top, crop_bottom);
437 sps->crop_bottom = 0;
439 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
440 int hsub = (sps->chroma_format_idc == 1 ||
441 sps->chroma_format_idc == 2) ? 1 : 0;
442 int step_x = 1 << hsub;
443 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
445 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
446 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
447 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
448 av_log(h->avctx, AV_LOG_WARNING,
449 "Reducing left cropping to %d "
450 "chroma samples to preserve alignment.\n",
454 sps->crop_left = crop_left * step_x;
455 sps->crop_right = crop_right * step_x;
456 sps->crop_top = crop_top * step_y;
457 sps->crop_bottom = crop_bottom * step_y;
467 sps->vui_parameters_present_flag = get_bits1(&h->gb);
468 if (sps->vui_parameters_present_flag)
469 if (decode_vui_parameters(h, sps) < 0)
475 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
476 static const char csp[4][5] = { "Gray", "420", "422", "444" };
477 av_log(h->avctx, AV_LOG_DEBUG,
478 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
479 sps_id, sps->profile_idc, sps->level_idc,
481 sps->ref_frame_count,
482 sps->mb_width, sps->mb_height,
483 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
484 sps->direct_8x8_inference_flag ? "8B8" : "",
485 sps->crop_left, sps->crop_right,
486 sps->crop_top, sps->crop_bottom,
487 sps->vui_parameters_present_flag ? "VUI" : "",
488 csp[sps->chroma_format_idc],
489 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
490 sps->timing_info_present_flag ? sps->time_scale : 0);
494 av_free(h->sps_buffers[sps_id]);
495 h->sps_buffers[sps_id] = sps;
497 h->current_sps_id = sps_id;
506 static void build_qp_table(PPS *pps, int t, int index, const int depth)
509 const int max_qp = 51 + 6 * (depth - 8);
510 for (i = 0; i < max_qp + 1; i++)
511 pps->chroma_qp_table[t][i] =
512 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
515 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
517 unsigned int pps_id = get_ue_golomb(&h->gb);
519 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
522 if (pps_id >= MAX_PPS_COUNT) {
523 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
524 return AVERROR_INVALIDDATA;
525 } else if (h->sps.bit_depth_luma > 10) {
526 av_log(h->avctx, AV_LOG_ERROR,
527 "Unimplemented luma bit depth=%d (max=10)\n",
528 h->sps.bit_depth_luma);
529 return AVERROR_PATCHWELCOME;
532 pps = av_mallocz(sizeof(PPS));
534 return AVERROR(ENOMEM);
535 pps->sps_id = get_ue_golomb_31(&h->gb);
536 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
537 h->sps_buffers[pps->sps_id] == NULL) {
538 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
542 pps->cabac = get_bits1(&h->gb);
543 pps->pic_order_present = get_bits1(&h->gb);
544 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
545 if (pps->slice_group_count > 1) {
546 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
547 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
548 switch (pps->mb_slice_group_map_type) {
551 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
552 | run_length[i] |1 |ue(v) |
557 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
558 | top_left_mb[i] |1 |ue(v) |
559 | bottom_right_mb[i] |1 |ue(v) |
567 | slice_group_change_direction_flag |1 |u(1) |
568 | slice_group_change_rate_minus1 |1 |ue(v) |
573 | slice_group_id_cnt_minus1 |1 |ue(v) |
574 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
575 | slice_group_id[i] |1 |u(v) |
580 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
581 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
582 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
583 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
587 pps->weighted_pred = get_bits1(&h->gb);
588 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
589 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
590 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
591 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
592 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
593 pps->constrained_intra_pred = get_bits1(&h->gb);
594 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
596 pps->transform_8x8_mode = 0;
597 // contents of sps/pps can change even if id doesn't, so reinit
598 h->dequant_coeff_pps = -1;
599 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
600 sizeof(pps->scaling_matrix4));
601 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
602 sizeof(pps->scaling_matrix8));
604 bits_left = bit_length - get_bits_count(&h->gb);
605 if (bits_left && (bits_left > 8 ||
606 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
607 pps->transform_8x8_mode = get_bits1(&h->gb);
608 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
609 pps->scaling_matrix4, pps->scaling_matrix8);
610 // second_chroma_qp_index_offset
611 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
613 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
616 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
617 h->sps.bit_depth_luma);
618 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
619 h->sps.bit_depth_luma);
620 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
621 pps->chroma_qp_diff = 1;
623 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
624 av_log(h->avctx, AV_LOG_DEBUG,
625 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
627 pps->cabac ? "CABAC" : "CAVLC",
628 pps->slice_group_count,
629 pps->ref_count[0], pps->ref_count[1],
630 pps->weighted_pred ? "weighted" : "",
631 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
632 pps->deblocking_filter_parameters_present ? "LPAR" : "",
633 pps->constrained_intra_pred ? "CONSTR" : "",
634 pps->redundant_pic_cnt_present ? "REDU" : "",
635 pps->transform_8x8_mode ? "8x8DCT" : "");
638 av_free(h->pps_buffers[pps_id]);
639 h->pps_buffers[pps_id] = pps;