h264: print values in case of error
[libav.git] / libavcodec / h264_ps.c
1 /*
2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
5 * This file is part of Libav.
6 *
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.
11 *
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.
16 *
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
20 */
21
22 /**
23 * @file
24 * H.264 / AVC / MPEG4 part10 parameter set decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #include "libavutil/imgutils.h"
29 #include "internal.h"
30 #include "avcodec.h"
31 #include "h264.h"
32 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
33 #include "golomb.h"
34
35 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
36 #define MIN_LOG2_MAX_FRAME_NUM 4
37
38 static const AVRational pixel_aspect[17] = {
39 { 0, 1 },
40 { 1, 1 },
41 { 12, 11 },
42 { 10, 11 },
43 { 16, 11 },
44 { 40, 33 },
45 { 24, 11 },
46 { 20, 11 },
47 { 32, 11 },
48 { 80, 33 },
49 { 18, 11 },
50 { 15, 11 },
51 { 64, 33 },
52 { 160, 99 },
53 { 4, 3 },
54 { 3, 2 },
55 { 2, 1 },
56 };
57
58 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
59
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)
70
71 const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1] = {
72 { CHROMA_QP_TABLE_END(8) },
73 { 0, 1, 2, 3, 4, 5,
74 CHROMA_QP_TABLE_END(9) },
75 { 0, 1, 2, 3, 4, 5,
76 6, 7, 8, 9, 10, 11,
77 CHROMA_QP_TABLE_END(10) },
78 };
79
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 }
85 };
86
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 }
104 };
105
106 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
107 {
108 int cpb_count, i;
109 cpb_count = get_ue_golomb_31(&h->gb) + 1;
110
111 if (cpb_count > 32U) {
112 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
113 return AVERROR_INVALIDDATA;
114 }
115
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 */
122 }
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;
128 return 0;
129 }
130
131 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
132 {
133 int aspect_ratio_info_present_flag;
134 unsigned int aspect_ratio_idc;
135
136 aspect_ratio_info_present_flag = get_bits1(&h->gb);
137
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];
145 } else {
146 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
147 return AVERROR_INVALIDDATA;
148 }
149 } else {
150 sps->sar.num =
151 sps->sar.den = 0;
152 }
153
154 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
155 get_bits1(&h->gb); /* overscan_appropriate_flag */
156
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 */
161
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;
173 }
174 }
175
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 */
181 }
182
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;
192 }
193 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
194 }
195
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);
208
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*/
218
219 if (get_bits_left(&h->gb) < 0) {
220 sps->num_reorder_frames = 0;
221 sps->bitstream_restriction_flag = 0;
222 }
223
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;
231 }
232 }
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;
237 }
238
239 return 0;
240 }
241
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)
245 {
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));
250 else
251 for (i = 0; i < size; i++) {
252 if (next)
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));
256 break;
257 }
258 last = factors[scan[i]] = next ? next : last;
259 }
260 }
261
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])
266 {
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]
273 };
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
287 }
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
292 }
293 }
294 }
295 }
296
297 int ff_h264_decode_seq_parameter_set(H264Context *h)
298 {
299 int profile_idc, level_idc, constraint_set_flags = 0;
300 unsigned int sps_id;
301 int i, log2_max_frame_num_minus4;
302 SPS *sps;
303
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 get_bits(&h->gb, 4); // reserved
310 level_idc = get_bits(&h->gb, 8);
311 sps_id = get_ue_golomb_31(&h->gb);
312
313 if (sps_id >= MAX_SPS_COUNT) {
314 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
315 return AVERROR_INVALIDDATA;
316 }
317 sps = av_mallocz(sizeof(SPS));
318 if (!sps)
319 return AVERROR(ENOMEM);
320
321 sps->time_offset_length = 24;
322 sps->profile_idc = profile_idc;
323 sps->constraint_set_flags = constraint_set_flags;
324 sps->level_idc = level_idc;
325
326 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
327 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
328 sps->scaling_matrix_present = 0;
329
330 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
331 sps->profile_idc == 122 || sps->profile_idc == 244 ||
332 sps->profile_idc == 44 || sps->profile_idc == 83 ||
333 sps->profile_idc == 86 || sps->profile_idc == 118 ||
334 sps->profile_idc == 128 || sps->profile_idc == 144) {
335 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
336 if (sps->chroma_format_idc > 3) {
337 av_log(h->avctx, AV_LOG_ERROR,
338 "chroma_format_idc %u out of range\n",
339 sps->chroma_format_idc);
340 goto fail;
341 } else if (sps->chroma_format_idc == 3) {
342 sps->residual_color_transform_flag = get_bits1(&h->gb);
343 }
344 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
345 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
346 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
347 avpriv_request_sample(h->avctx,
348 "Different chroma and luma bit depth");
349 goto fail;
350 }
351 sps->transform_bypass = get_bits1(&h->gb);
352 decode_scaling_matrices(h, sps, NULL, 1,
353 sps->scaling_matrix4, sps->scaling_matrix8);
354 } else {
355 sps->chroma_format_idc = 1;
356 sps->bit_depth_luma = 8;
357 sps->bit_depth_chroma = 8;
358 }
359
360 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
361 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
362 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
363 av_log(h->avctx, AV_LOG_ERROR,
364 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
365 log2_max_frame_num_minus4);
366 goto fail;
367 }
368 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
369
370 sps->poc_type = get_ue_golomb_31(&h->gb);
371
372 if (sps->poc_type == 0) { // FIXME #define
373 sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
374 } else if (sps->poc_type == 1) { // FIXME #define
375 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
376 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
377 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
378 sps->poc_cycle_length = get_ue_golomb(&h->gb);
379
380 if ((unsigned)sps->poc_cycle_length >=
381 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
382 av_log(h->avctx, AV_LOG_ERROR,
383 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
384 goto fail;
385 }
386
387 for (i = 0; i < sps->poc_cycle_length; i++)
388 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
389 } else if (sps->poc_type != 2) {
390 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
391 goto fail;
392 }
393
394 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
395 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
396 sps->ref_frame_count >= 32U) {
397 av_log(h->avctx, AV_LOG_ERROR,
398 "too many reference frames %d\n", sps->ref_frame_count);
399 goto fail;
400 }
401 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
402 sps->mb_width = get_ue_golomb(&h->gb) + 1;
403 sps->mb_height = get_ue_golomb(&h->gb) + 1;
404 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
405 (unsigned)sps->mb_height >= INT_MAX / 16 ||
406 av_image_check_size(16 * sps->mb_width,
407 16 * sps->mb_height, 0, h->avctx)) {
408 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
409 goto fail;
410 }
411
412 sps->frame_mbs_only_flag = get_bits1(&h->gb);
413 if (!sps->frame_mbs_only_flag)
414 sps->mb_aff = get_bits1(&h->gb);
415 else
416 sps->mb_aff = 0;
417
418 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
419 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
420 av_log(h->avctx, AV_LOG_ERROR,
421 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
422 goto fail;
423 }
424
425 #ifndef ALLOW_INTERLACE
426 if (sps->mb_aff)
427 av_log(h->avctx, AV_LOG_ERROR,
428 "MBAFF support not included; enable it at compile-time.\n");
429 #endif
430 sps->crop = get_bits1(&h->gb);
431 if (sps->crop) {
432 int crop_left = get_ue_golomb(&h->gb);
433 int crop_right = get_ue_golomb(&h->gb);
434 int crop_top = get_ue_golomb(&h->gb);
435 int crop_bottom = get_ue_golomb(&h->gb);
436
437 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
438 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
439 "values are l:%u r:%u t:%u b:%u\n",
440 crop_left, crop_right, crop_top, crop_bottom);
441
442 sps->crop_left =
443 sps->crop_right =
444 sps->crop_top =
445 sps->crop_bottom = 0;
446 } else {
447 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
448 int hsub = (sps->chroma_format_idc == 1 ||
449 sps->chroma_format_idc == 2) ? 1 : 0;
450 int step_x = 1 << hsub;
451 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
452
453 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
454 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
455 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
456 av_log(h->avctx, AV_LOG_WARNING,
457 "Reducing left cropping to %d "
458 "chroma samples to preserve alignment.\n",
459 crop_left);
460 }
461
462 sps->crop_left = crop_left * step_x;
463 sps->crop_right = crop_right * step_x;
464 sps->crop_top = crop_top * step_y;
465 sps->crop_bottom = crop_bottom * step_y;
466 }
467 } else {
468 sps->crop_left =
469 sps->crop_right =
470 sps->crop_top =
471 sps->crop_bottom =
472 sps->crop = 0;
473 }
474
475 sps->vui_parameters_present_flag = get_bits1(&h->gb);
476 if (sps->vui_parameters_present_flag) {
477 int ret = decode_vui_parameters(h, sps);
478 if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
479 goto fail;
480 }
481
482 if (!sps->sar.den)
483 sps->sar.den = 1;
484
485 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
486 static const char csp[4][5] = { "Gray", "420", "422", "444" };
487 av_log(h->avctx, AV_LOG_DEBUG,
488 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
489 sps_id, sps->profile_idc, sps->level_idc,
490 sps->poc_type,
491 sps->ref_frame_count,
492 sps->mb_width, sps->mb_height,
493 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
494 sps->direct_8x8_inference_flag ? "8B8" : "",
495 sps->crop_left, sps->crop_right,
496 sps->crop_top, sps->crop_bottom,
497 sps->vui_parameters_present_flag ? "VUI" : "",
498 csp[sps->chroma_format_idc],
499 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
500 sps->timing_info_present_flag ? sps->time_scale : 0);
501 }
502 sps->new = 1;
503
504 av_free(h->sps_buffers[sps_id]);
505 h->sps_buffers[sps_id] = sps;
506 h->sps = *sps;
507 h->current_sps_id = sps_id;
508
509 return 0;
510
511 fail:
512 av_free(sps);
513 return -1;
514 }
515
516 static void build_qp_table(PPS *pps, int t, int index, const int depth)
517 {
518 int i;
519 const int max_qp = 51 + 6 * (depth - 8);
520 for (i = 0; i < max_qp + 1; i++)
521 pps->chroma_qp_table[t][i] =
522 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
523 }
524
525 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
526 {
527 unsigned int pps_id = get_ue_golomb(&h->gb);
528 PPS *pps;
529 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
530 int bits_left;
531
532 if (pps_id >= MAX_PPS_COUNT) {
533 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
534 return AVERROR_INVALIDDATA;
535 } else if (h->sps.bit_depth_luma > 10) {
536 av_log(h->avctx, AV_LOG_ERROR,
537 "Unimplemented luma bit depth=%d (max=10)\n",
538 h->sps.bit_depth_luma);
539 return AVERROR_PATCHWELCOME;
540 }
541
542 pps = av_mallocz(sizeof(PPS));
543 if (!pps)
544 return AVERROR(ENOMEM);
545 pps->sps_id = get_ue_golomb_31(&h->gb);
546 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
547 h->sps_buffers[pps->sps_id] == NULL) {
548 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
549 goto fail;
550 }
551
552 pps->cabac = get_bits1(&h->gb);
553 pps->pic_order_present = get_bits1(&h->gb);
554 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
555 if (pps->slice_group_count > 1) {
556 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
557 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
558 switch (pps->mb_slice_group_map_type) {
559 case 0:
560 #if 0
561 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
562 | run_length[i] |1 |ue(v) |
563 #endif
564 break;
565 case 2:
566 #if 0
567 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
568 | top_left_mb[i] |1 |ue(v) |
569 | bottom_right_mb[i] |1 |ue(v) |
570 | } | | |
571 #endif
572 break;
573 case 3:
574 case 4:
575 case 5:
576 #if 0
577 | slice_group_change_direction_flag |1 |u(1) |
578 | slice_group_change_rate_minus1 |1 |ue(v) |
579 #endif
580 break;
581 case 6:
582 #if 0
583 | slice_group_id_cnt_minus1 |1 |ue(v) |
584 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
585 | slice_group_id[i] |1 |u(v) |
586 #endif
587 break;
588 }
589 }
590 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
591 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
592 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
593 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
594 goto fail;
595 }
596
597 pps->weighted_pred = get_bits1(&h->gb);
598 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
599 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
600 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
601 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
602 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
603 pps->constrained_intra_pred = get_bits1(&h->gb);
604 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
605
606 pps->transform_8x8_mode = 0;
607 // contents of sps/pps can change even if id doesn't, so reinit
608 h->dequant_coeff_pps = -1;
609 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
610 sizeof(pps->scaling_matrix4));
611 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
612 sizeof(pps->scaling_matrix8));
613
614 bits_left = bit_length - get_bits_count(&h->gb);
615 if (bits_left && (bits_left > 8 ||
616 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
617 pps->transform_8x8_mode = get_bits1(&h->gb);
618 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
619 pps->scaling_matrix4, pps->scaling_matrix8);
620 // second_chroma_qp_index_offset
621 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
622 } else {
623 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
624 }
625
626 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
627 h->sps.bit_depth_luma);
628 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
629 h->sps.bit_depth_luma);
630 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
631 pps->chroma_qp_diff = 1;
632
633 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
634 av_log(h->avctx, AV_LOG_DEBUG,
635 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
636 pps_id, pps->sps_id,
637 pps->cabac ? "CABAC" : "CAVLC",
638 pps->slice_group_count,
639 pps->ref_count[0], pps->ref_count[1],
640 pps->weighted_pred ? "weighted" : "",
641 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
642 pps->deblocking_filter_parameters_present ? "LPAR" : "",
643 pps->constrained_intra_pred ? "CONSTR" : "",
644 pps->redundant_pic_cnt_present ? "REDU" : "",
645 pps->transform_8x8_mode ? "8x8DCT" : "");
646 }
647
648 av_free(h->pps_buffers[pps_id]);
649 h->pps_buffers[pps_id] = pps;
650 return 0;
651
652 fail:
653 av_free(pps);
654 return -1;
655 }