h264: reject mismatching luma/chroma bit depths during sps parsing
[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 "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
228 return AVERROR_INVALIDDATA;
229 }
230 }
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;
235 }
236
237 return 0;
238 }
239
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)
243 {
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));
248 else
249 for (i = 0; i < size; i++) {
250 if (next)
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));
254 break;
255 }
256 last = factors[scan[i]] = next ? next : last;
257 }
258 }
259
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])
264 {
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]
271 };
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
285 }
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
290 }
291 }
292 }
293 }
294
295 int ff_h264_decode_seq_parameter_set(H264Context *h)
296 {
297 int profile_idc, level_idc, constraint_set_flags = 0;
298 unsigned int sps_id;
299 int i, log2_max_frame_num_minus4;
300 SPS *sps;
301
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);
310
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;
314 }
315 sps = av_mallocz(sizeof(SPS));
316 if (!sps)
317 return AVERROR(ENOMEM);
318
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;
323
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;
327
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);
338 goto fail;
339 } else if (sps->chroma_format_idc == 3) {
340 sps->residual_color_transform_flag = get_bits1(&h->gb);
341 }
342 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
343 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
344 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
345 avpriv_request_sample(h->avctx,
346 "Different chroma and luma bit depth");
347 goto fail;
348 }
349 sps->transform_bypass = get_bits1(&h->gb);
350 decode_scaling_matrices(h, sps, NULL, 1,
351 sps->scaling_matrix4, sps->scaling_matrix8);
352 } else {
353 sps->chroma_format_idc = 1;
354 sps->bit_depth_luma = 8;
355 sps->bit_depth_chroma = 8;
356 }
357
358 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
359 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
360 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
361 av_log(h->avctx, AV_LOG_ERROR,
362 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
363 log2_max_frame_num_minus4);
364 goto fail;
365 }
366 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
367
368 sps->poc_type = get_ue_golomb_31(&h->gb);
369
370 if (sps->poc_type == 0) { // FIXME #define
371 sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
372 } else if (sps->poc_type == 1) { // FIXME #define
373 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
374 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
375 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
376 sps->poc_cycle_length = get_ue_golomb(&h->gb);
377
378 if ((unsigned)sps->poc_cycle_length >=
379 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
380 av_log(h->avctx, AV_LOG_ERROR,
381 "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
382 goto fail;
383 }
384
385 for (i = 0; i < sps->poc_cycle_length; i++)
386 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
387 } else if (sps->poc_type != 2) {
388 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
389 goto fail;
390 }
391
392 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
393 if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
394 sps->ref_frame_count >= 32U) {
395 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
396 goto fail;
397 }
398 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
399 sps->mb_width = get_ue_golomb(&h->gb) + 1;
400 sps->mb_height = get_ue_golomb(&h->gb) + 1;
401 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
402 (unsigned)sps->mb_height >= INT_MAX / 16 ||
403 av_image_check_size(16 * sps->mb_width,
404 16 * sps->mb_height, 0, h->avctx)) {
405 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
406 goto fail;
407 }
408
409 sps->frame_mbs_only_flag = get_bits1(&h->gb);
410 if (!sps->frame_mbs_only_flag)
411 sps->mb_aff = get_bits1(&h->gb);
412 else
413 sps->mb_aff = 0;
414
415 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
416 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
417 av_log(h->avctx, AV_LOG_ERROR,
418 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
419 goto fail;
420 }
421
422 #ifndef ALLOW_INTERLACE
423 if (sps->mb_aff)
424 av_log(h->avctx, AV_LOG_ERROR,
425 "MBAFF support not included; enable it at compile-time.\n");
426 #endif
427 sps->crop = get_bits1(&h->gb);
428 if (sps->crop) {
429 int crop_left = get_ue_golomb(&h->gb);
430 int crop_right = get_ue_golomb(&h->gb);
431 int crop_top = get_ue_golomb(&h->gb);
432 int crop_bottom = get_ue_golomb(&h->gb);
433
434 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
435 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
436 "values are l:%u r:%u t:%u b:%u\n",
437 crop_left, crop_right, crop_top, crop_bottom);
438
439 sps->crop_left =
440 sps->crop_right =
441 sps->crop_top =
442 sps->crop_bottom = 0;
443 } else {
444 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
445 int hsub = (sps->chroma_format_idc == 1 ||
446 sps->chroma_format_idc == 2) ? 1 : 0;
447 int step_x = 1 << hsub;
448 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
449
450 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
451 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
452 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
453 av_log(h->avctx, AV_LOG_WARNING,
454 "Reducing left cropping to %d "
455 "chroma samples to preserve alignment.\n",
456 crop_left);
457 }
458
459 sps->crop_left = crop_left * step_x;
460 sps->crop_right = crop_right * step_x;
461 sps->crop_top = crop_top * step_y;
462 sps->crop_bottom = crop_bottom * step_y;
463 }
464 } else {
465 sps->crop_left =
466 sps->crop_right =
467 sps->crop_top =
468 sps->crop_bottom =
469 sps->crop = 0;
470 }
471
472 sps->vui_parameters_present_flag = get_bits1(&h->gb);
473 if (sps->vui_parameters_present_flag) {
474 int ret = decode_vui_parameters(h, sps);
475 if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
476 goto fail;
477 }
478
479 if (!sps->sar.den)
480 sps->sar.den = 1;
481
482 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
483 static const char csp[4][5] = { "Gray", "420", "422", "444" };
484 av_log(h->avctx, AV_LOG_DEBUG,
485 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
486 sps_id, sps->profile_idc, sps->level_idc,
487 sps->poc_type,
488 sps->ref_frame_count,
489 sps->mb_width, sps->mb_height,
490 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
491 sps->direct_8x8_inference_flag ? "8B8" : "",
492 sps->crop_left, sps->crop_right,
493 sps->crop_top, sps->crop_bottom,
494 sps->vui_parameters_present_flag ? "VUI" : "",
495 csp[sps->chroma_format_idc],
496 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
497 sps->timing_info_present_flag ? sps->time_scale : 0);
498 }
499 sps->new = 1;
500
501 av_free(h->sps_buffers[sps_id]);
502 h->sps_buffers[sps_id] = sps;
503 h->sps = *sps;
504 h->current_sps_id = sps_id;
505
506 return 0;
507
508 fail:
509 av_free(sps);
510 return -1;
511 }
512
513 static void build_qp_table(PPS *pps, int t, int index, const int depth)
514 {
515 int i;
516 const int max_qp = 51 + 6 * (depth - 8);
517 for (i = 0; i < max_qp + 1; i++)
518 pps->chroma_qp_table[t][i] =
519 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
520 }
521
522 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
523 {
524 unsigned int pps_id = get_ue_golomb(&h->gb);
525 PPS *pps;
526 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
527 int bits_left;
528
529 if (pps_id >= MAX_PPS_COUNT) {
530 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
531 return AVERROR_INVALIDDATA;
532 } else if (h->sps.bit_depth_luma > 10) {
533 av_log(h->avctx, AV_LOG_ERROR,
534 "Unimplemented luma bit depth=%d (max=10)\n",
535 h->sps.bit_depth_luma);
536 return AVERROR_PATCHWELCOME;
537 }
538
539 pps = av_mallocz(sizeof(PPS));
540 if (!pps)
541 return AVERROR(ENOMEM);
542 pps->sps_id = get_ue_golomb_31(&h->gb);
543 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
544 h->sps_buffers[pps->sps_id] == NULL) {
545 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
546 goto fail;
547 }
548
549 pps->cabac = get_bits1(&h->gb);
550 pps->pic_order_present = get_bits1(&h->gb);
551 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
552 if (pps->slice_group_count > 1) {
553 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
554 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
555 switch (pps->mb_slice_group_map_type) {
556 case 0:
557 #if 0
558 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
559 | run_length[i] |1 |ue(v) |
560 #endif
561 break;
562 case 2:
563 #if 0
564 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
565 | top_left_mb[i] |1 |ue(v) |
566 | bottom_right_mb[i] |1 |ue(v) |
567 | } | | |
568 #endif
569 break;
570 case 3:
571 case 4:
572 case 5:
573 #if 0
574 | slice_group_change_direction_flag |1 |u(1) |
575 | slice_group_change_rate_minus1 |1 |ue(v) |
576 #endif
577 break;
578 case 6:
579 #if 0
580 | slice_group_id_cnt_minus1 |1 |ue(v) |
581 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
582 | slice_group_id[i] |1 |u(v) |
583 #endif
584 break;
585 }
586 }
587 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
588 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
589 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
590 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
591 goto fail;
592 }
593
594 pps->weighted_pred = get_bits1(&h->gb);
595 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
596 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
597 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
598 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
599 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
600 pps->constrained_intra_pred = get_bits1(&h->gb);
601 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
602
603 pps->transform_8x8_mode = 0;
604 // contents of sps/pps can change even if id doesn't, so reinit
605 h->dequant_coeff_pps = -1;
606 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
607 sizeof(pps->scaling_matrix4));
608 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
609 sizeof(pps->scaling_matrix8));
610
611 bits_left = bit_length - get_bits_count(&h->gb);
612 if (bits_left && (bits_left > 8 ||
613 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
614 pps->transform_8x8_mode = get_bits1(&h->gb);
615 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
616 pps->scaling_matrix4, pps->scaling_matrix8);
617 // second_chroma_qp_index_offset
618 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
619 } else {
620 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
621 }
622
623 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
624 h->sps.bit_depth_luma);
625 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
626 h->sps.bit_depth_luma);
627 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
628 pps->chroma_qp_diff = 1;
629
630 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
631 av_log(h->avctx, AV_LOG_DEBUG,
632 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
633 pps_id, pps->sps_id,
634 pps->cabac ? "CABAC" : "CAVLC",
635 pps->slice_group_count,
636 pps->ref_count[0], pps->ref_count[1],
637 pps->weighted_pred ? "weighted" : "",
638 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
639 pps->deblocking_filter_parameters_present ? "LPAR" : "",
640 pps->constrained_intra_pred ? "CONSTR" : "",
641 pps->redundant_pic_cnt_present ? "REDU" : "",
642 pps->transform_8x8_mode ? "8x8DCT" : "");
643 }
644
645 av_free(h->pps_buffers[pps_id]);
646 h->pps_buffers[pps_id] = pps;
647 return 0;
648
649 fail:
650 av_free(pps);
651 return -1;
652 }