f3477c182349c3a0fd91e045b218ac5376919727
[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 <inttypes.h>
29
30 #include "libavutil/imgutils.h"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264.h"
34 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
35 #include "golomb.h"
36
37 #define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
38 #define MIN_LOG2_MAX_FRAME_NUM 4
39
40 static const AVRational pixel_aspect[17] = {
41 { 0, 1 },
42 { 1, 1 },
43 { 12, 11 },
44 { 10, 11 },
45 { 16, 11 },
46 { 40, 33 },
47 { 24, 11 },
48 { 20, 11 },
49 { 32, 11 },
50 { 80, 33 },
51 { 18, 11 },
52 { 15, 11 },
53 { 64, 33 },
54 { 160, 99 },
55 { 4, 3 },
56 { 3, 2 },
57 { 2, 1 },
58 };
59
60 #define QP(qP, depth) ((qP) + 6 * ((depth) - 8))
61
62 #define CHROMA_QP_TABLE_END(d) \
63 QP(0, d), QP(1, d), QP(2, d), QP(3, d), QP(4, d), QP(5, d), \
64 QP(6, d), QP(7, d), QP(8, d), QP(9, d), QP(10, d), QP(11, d), \
65 QP(12, d), QP(13, d), QP(14, d), QP(15, d), QP(16, d), QP(17, d), \
66 QP(18, d), QP(19, d), QP(20, d), QP(21, d), QP(22, d), QP(23, d), \
67 QP(24, d), QP(25, d), QP(26, d), QP(27, d), QP(28, d), QP(29, d), \
68 QP(29, d), QP(30, d), QP(31, d), QP(32, d), QP(32, d), QP(33, d), \
69 QP(34, d), QP(34, d), QP(35, d), QP(35, d), QP(36, d), QP(36, d), \
70 QP(37, d), QP(37, d), QP(37, d), QP(38, d), QP(38, d), QP(38, d), \
71 QP(39, d), QP(39, d), QP(39, d), QP(39, d)
72
73 const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1] = {
74 { CHROMA_QP_TABLE_END(8) },
75 { 0, 1, 2, 3, 4, 5,
76 CHROMA_QP_TABLE_END(9) },
77 { 0, 1, 2, 3, 4, 5,
78 6, 7, 8, 9, 10, 11,
79 CHROMA_QP_TABLE_END(10) },
80 };
81
82 static const uint8_t default_scaling4[2][16] = {
83 { 6, 13, 20, 28, 13, 20, 28, 32,
84 20, 28, 32, 37, 28, 32, 37, 42 },
85 { 10, 14, 20, 24, 14, 20, 24, 27,
86 20, 24, 27, 30, 24, 27, 30, 34 }
87 };
88
89 static const uint8_t default_scaling8[2][64] = {
90 { 6, 10, 13, 16, 18, 23, 25, 27,
91 10, 11, 16, 18, 23, 25, 27, 29,
92 13, 16, 18, 23, 25, 27, 29, 31,
93 16, 18, 23, 25, 27, 29, 31, 33,
94 18, 23, 25, 27, 29, 31, 33, 36,
95 23, 25, 27, 29, 31, 33, 36, 38,
96 25, 27, 29, 31, 33, 36, 38, 40,
97 27, 29, 31, 33, 36, 38, 40, 42 },
98 { 9, 13, 15, 17, 19, 21, 22, 24,
99 13, 13, 17, 19, 21, 22, 24, 25,
100 15, 17, 19, 21, 22, 24, 25, 27,
101 17, 19, 21, 22, 24, 25, 27, 28,
102 19, 21, 22, 24, 25, 27, 28, 30,
103 21, 22, 24, 25, 27, 28, 30, 32,
104 22, 24, 25, 27, 28, 30, 32, 33,
105 24, 25, 27, 28, 30, 32, 33, 35 }
106 };
107
108 static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
109 {
110 int cpb_count, i;
111 cpb_count = get_ue_golomb_31(&h->gb) + 1;
112
113 if (cpb_count > 32U) {
114 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
115 return AVERROR_INVALIDDATA;
116 }
117
118 get_bits(&h->gb, 4); /* bit_rate_scale */
119 get_bits(&h->gb, 4); /* cpb_size_scale */
120 for (i = 0; i < cpb_count; i++) {
121 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
122 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
123 get_bits1(&h->gb); /* cbr_flag */
124 }
125 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
126 sps->cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
127 sps->dpb_output_delay_length = get_bits(&h->gb, 5) + 1;
128 sps->time_offset_length = get_bits(&h->gb, 5);
129 sps->cpb_cnt = cpb_count;
130 return 0;
131 }
132
133 static inline int decode_vui_parameters(H264Context *h, SPS *sps)
134 {
135 int aspect_ratio_info_present_flag;
136 unsigned int aspect_ratio_idc;
137
138 aspect_ratio_info_present_flag = get_bits1(&h->gb);
139
140 if (aspect_ratio_info_present_flag) {
141 aspect_ratio_idc = get_bits(&h->gb, 8);
142 if (aspect_ratio_idc == EXTENDED_SAR) {
143 sps->sar.num = get_bits(&h->gb, 16);
144 sps->sar.den = get_bits(&h->gb, 16);
145 } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
146 sps->sar = pixel_aspect[aspect_ratio_idc];
147 } else {
148 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
149 return AVERROR_INVALIDDATA;
150 }
151 } else {
152 sps->sar.num =
153 sps->sar.den = 0;
154 }
155
156 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
157 get_bits1(&h->gb); /* overscan_appropriate_flag */
158
159 sps->video_signal_type_present_flag = get_bits1(&h->gb);
160 if (sps->video_signal_type_present_flag) {
161 get_bits(&h->gb, 3); /* video_format */
162 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
163
164 sps->colour_description_present_flag = get_bits1(&h->gb);
165 if (sps->colour_description_present_flag) {
166 sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
167 sps->color_trc = get_bits(&h->gb, 8); /* transfer_characteristics */
168 sps->colorspace = get_bits(&h->gb, 8); /* matrix_coefficients */
169 if (sps->color_primaries >= AVCOL_PRI_NB)
170 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
171 if (sps->color_trc >= AVCOL_TRC_NB)
172 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
173 if (sps->colorspace >= AVCOL_SPC_NB)
174 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
175 }
176 }
177
178 /* chroma_location_info_present_flag */
179 if (get_bits1(&h->gb)) {
180 /* chroma_sample_location_type_top_field */
181 h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
182 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
183 }
184
185 sps->timing_info_present_flag = get_bits1(&h->gb);
186 if (sps->timing_info_present_flag) {
187 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
188 sps->time_scale = get_bits_long(&h->gb, 32);
189 if (!sps->num_units_in_tick || !sps->time_scale) {
190 av_log(h->avctx, AV_LOG_ERROR,
191 "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",
192 sps->time_scale, sps->num_units_in_tick);
193 return AVERROR_INVALIDDATA;
194 }
195 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
196 }
197
198 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
199 if (sps->nal_hrd_parameters_present_flag)
200 if (decode_hrd_parameters(h, sps) < 0)
201 return AVERROR_INVALIDDATA;
202 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
203 if (sps->vcl_hrd_parameters_present_flag)
204 if (decode_hrd_parameters(h, sps) < 0)
205 return AVERROR_INVALIDDATA;
206 if (sps->nal_hrd_parameters_present_flag ||
207 sps->vcl_hrd_parameters_present_flag)
208 get_bits1(&h->gb); /* low_delay_hrd_flag */
209 sps->pic_struct_present_flag = get_bits1(&h->gb);
210
211 sps->bitstream_restriction_flag = get_bits1(&h->gb);
212 if (sps->bitstream_restriction_flag) {
213 get_bits1(&h->gb); /* motion_vectors_over_pic_boundaries_flag */
214 get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
215 get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
216 get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
217 get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
218 sps->num_reorder_frames = get_ue_golomb(&h->gb);
219 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
220
221 if (get_bits_left(&h->gb) < 0) {
222 sps->num_reorder_frames = 0;
223 sps->bitstream_restriction_flag = 0;
224 }
225
226 if (sps->num_reorder_frames > 16U
227 /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
228 av_log(h->avctx, AV_LOG_ERROR,
229 "Clipping illegal num_reorder_frames %d\n",
230 sps->num_reorder_frames);
231 sps->num_reorder_frames = 16;
232 return AVERROR_INVALIDDATA;
233 }
234 }
235 if (get_bits_left(&h->gb) < 0) {
236 av_log(h->avctx, AV_LOG_ERROR,
237 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
238 return AVERROR_INVALIDDATA;
239 }
240
241 return 0;
242 }
243
244 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
245 const uint8_t *jvt_list,
246 const uint8_t *fallback_list)
247 {
248 int i, last = 8, next = 8;
249 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
250 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
251 memcpy(factors, fallback_list, size * sizeof(uint8_t));
252 else
253 for (i = 0; i < size; i++) {
254 if (next)
255 next = (last + get_se_golomb(&h->gb)) & 0xff;
256 if (!i && !next) { /* matrix not written, we use the preset one */
257 memcpy(factors, jvt_list, size * sizeof(uint8_t));
258 break;
259 }
260 last = factors[scan[i]] = next ? next : last;
261 }
262 }
263
264 static void decode_scaling_matrices(H264Context *h, SPS *sps,
265 PPS *pps, int is_sps,
266 uint8_t(*scaling_matrix4)[16],
267 uint8_t(*scaling_matrix8)[64])
268 {
269 int fallback_sps = !is_sps && sps->scaling_matrix_present;
270 const uint8_t *fallback[4] = {
271 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
272 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
273 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
274 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
275 };
276 if (get_bits1(&h->gb)) {
277 sps->scaling_matrix_present |= is_sps;
278 decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]); // Intra, Y
279 decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
280 decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
281 decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]); // Inter, Y
282 decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
283 decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
284 if (is_sps || pps->transform_8x8_mode) {
285 decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
286 if (sps->chroma_format_idc == 3) {
287 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
288 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
289 }
290 decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
291 if (sps->chroma_format_idc == 3) {
292 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
293 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
294 }
295 }
296 }
297 }
298
299 int ff_h264_decode_seq_parameter_set(H264Context *h)
300 {
301 int profile_idc, level_idc, constraint_set_flags = 0;
302 unsigned int sps_id;
303 int i, log2_max_frame_num_minus4;
304 SPS *sps;
305
306 profile_idc = get_bits(&h->gb, 8);
307 constraint_set_flags |= get_bits1(&h->gb) << 0; // constraint_set0_flag
308 constraint_set_flags |= get_bits1(&h->gb) << 1; // constraint_set1_flag
309 constraint_set_flags |= get_bits1(&h->gb) << 2; // constraint_set2_flag
310 constraint_set_flags |= get_bits1(&h->gb) << 3; // constraint_set3_flag
311 constraint_set_flags |= get_bits1(&h->gb) << 4; // constraint_set4_flag
312 constraint_set_flags |= get_bits1(&h->gb) << 5; // constraint_set5_flag
313 skip_bits(&h->gb, 2); // reserved_zero_2bits
314 level_idc = get_bits(&h->gb, 8);
315 sps_id = get_ue_golomb_31(&h->gb);
316
317 if (sps_id >= MAX_SPS_COUNT) {
318 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
319 return AVERROR_INVALIDDATA;
320 }
321 sps = av_mallocz(sizeof(SPS));
322 if (!sps)
323 return AVERROR(ENOMEM);
324
325 sps->sps_id = sps_id;
326 sps->time_offset_length = 24;
327 sps->profile_idc = profile_idc;
328 sps->constraint_set_flags = constraint_set_flags;
329 sps->level_idc = level_idc;
330
331 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
332 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
333 sps->scaling_matrix_present = 0;
334
335 if (sps->profile_idc == 100 || // High profile
336 sps->profile_idc == 110 || // High10 profile
337 sps->profile_idc == 122 || // High422 profile
338 sps->profile_idc == 244 || // High444 Predictive profile
339 sps->profile_idc == 44 || // Cavlc444 profile
340 sps->profile_idc == 83 || // Scalable Constrained High profile (SVC)
341 sps->profile_idc == 86 || // Scalable High Intra profile (SVC)
342 sps->profile_idc == 118 || // Stereo High profile (MVC)
343 sps->profile_idc == 128 || // Multiview High profile (MVC)
344 sps->profile_idc == 138 || // Multiview Depth High profile (MVCD)
345 sps->profile_idc == 144) { // old High444 profile
346 sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
347 if (sps->chroma_format_idc > 3) {
348 avpriv_request_sample(h->avctx, "chroma_format_idc %u",
349 sps->chroma_format_idc);
350 goto fail;
351 } else if (sps->chroma_format_idc == 3) {
352 sps->residual_color_transform_flag = get_bits1(&h->gb);
353 }
354 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
355 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
356 if (sps->bit_depth_chroma != sps->bit_depth_luma) {
357 avpriv_request_sample(h->avctx,
358 "Different chroma and luma bit depth");
359 goto fail;
360 }
361 sps->transform_bypass = get_bits1(&h->gb);
362 decode_scaling_matrices(h, sps, NULL, 1,
363 sps->scaling_matrix4, sps->scaling_matrix8);
364 } else {
365 sps->chroma_format_idc = 1;
366 sps->bit_depth_luma = 8;
367 sps->bit_depth_chroma = 8;
368 }
369
370 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
371 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
372 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
373 av_log(h->avctx, AV_LOG_ERROR,
374 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
375 log2_max_frame_num_minus4);
376 goto fail;
377 }
378 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
379
380 sps->poc_type = get_ue_golomb_31(&h->gb);
381
382 if (sps->poc_type == 0) { // FIXME #define
383 sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
384 } else if (sps->poc_type == 1) { // FIXME #define
385 sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
386 sps->offset_for_non_ref_pic = get_se_golomb(&h->gb);
387 sps->offset_for_top_to_bottom_field = get_se_golomb(&h->gb);
388 sps->poc_cycle_length = get_ue_golomb(&h->gb);
389
390 if ((unsigned)sps->poc_cycle_length >=
391 FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
392 av_log(h->avctx, AV_LOG_ERROR,
393 "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
394 goto fail;
395 }
396
397 for (i = 0; i < sps->poc_cycle_length; i++)
398 sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
399 } else if (sps->poc_type != 2) {
400 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
401 goto fail;
402 }
403
404 sps->ref_frame_count = get_ue_golomb_31(&h->gb);
405 if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
406 sps->ref_frame_count >= 32U) {
407 av_log(h->avctx, AV_LOG_ERROR,
408 "too many reference frames %d\n", sps->ref_frame_count);
409 goto fail;
410 }
411 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
412 sps->mb_width = get_ue_golomb(&h->gb) + 1;
413 sps->mb_height = get_ue_golomb(&h->gb) + 1;
414 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
415 (unsigned)sps->mb_height >= INT_MAX / 16 ||
416 av_image_check_size(16 * sps->mb_width,
417 16 * sps->mb_height, 0, h->avctx)) {
418 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
419 goto fail;
420 }
421
422 sps->frame_mbs_only_flag = get_bits1(&h->gb);
423 if (!sps->frame_mbs_only_flag)
424 sps->mb_aff = get_bits1(&h->gb);
425 else
426 sps->mb_aff = 0;
427
428 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
429 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
430 av_log(h->avctx, AV_LOG_ERROR,
431 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
432 goto fail;
433 }
434
435 #ifndef ALLOW_INTERLACE
436 if (sps->mb_aff)
437 av_log(h->avctx, AV_LOG_ERROR,
438 "MBAFF support not included; enable it at compile-time.\n");
439 #endif
440 sps->crop = get_bits1(&h->gb);
441 if (sps->crop) {
442 int crop_left = get_ue_golomb(&h->gb);
443 int crop_right = get_ue_golomb(&h->gb);
444 int crop_top = get_ue_golomb(&h->gb);
445 int crop_bottom = get_ue_golomb(&h->gb);
446
447 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
448 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
449 "values are l:%d r:%d t:%d b:%d\n",
450 crop_left, crop_right, crop_top, crop_bottom);
451
452 sps->crop_left =
453 sps->crop_right =
454 sps->crop_top =
455 sps->crop_bottom = 0;
456 } else {
457 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
458 int hsub = (sps->chroma_format_idc == 1 ||
459 sps->chroma_format_idc == 2) ? 1 : 0;
460 int step_x = 1 << hsub;
461 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
462
463 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
464 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
465 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
466 av_log(h->avctx, AV_LOG_WARNING,
467 "Reducing left cropping to %d "
468 "chroma samples to preserve alignment.\n",
469 crop_left);
470 }
471
472 sps->crop_left = crop_left * step_x;
473 sps->crop_right = crop_right * step_x;
474 sps->crop_top = crop_top * step_y;
475 sps->crop_bottom = crop_bottom * step_y;
476 }
477 } else {
478 sps->crop_left =
479 sps->crop_right =
480 sps->crop_top =
481 sps->crop_bottom =
482 sps->crop = 0;
483 }
484
485 sps->vui_parameters_present_flag = get_bits1(&h->gb);
486 if (sps->vui_parameters_present_flag) {
487 int ret = decode_vui_parameters(h, sps);
488 if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
489 goto fail;
490 }
491
492 if (!sps->sar.den)
493 sps->sar.den = 1;
494
495 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
496 static const char csp[4][5] = { "Gray", "420", "422", "444" };
497 av_log(h->avctx, AV_LOG_DEBUG,
498 "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %d/%d\n",
499 sps_id, sps->profile_idc, sps->level_idc,
500 sps->poc_type,
501 sps->ref_frame_count,
502 sps->mb_width, sps->mb_height,
503 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
504 sps->direct_8x8_inference_flag ? "8B8" : "",
505 sps->crop_left, sps->crop_right,
506 sps->crop_top, sps->crop_bottom,
507 sps->vui_parameters_present_flag ? "VUI" : "",
508 csp[sps->chroma_format_idc],
509 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
510 sps->timing_info_present_flag ? sps->time_scale : 0);
511 }
512 sps->new = 1;
513
514 av_free(h->sps_buffers[sps_id]);
515 h->sps_buffers[sps_id] = sps;
516 h->sps = *sps;
517
518 return 0;
519
520 fail:
521 av_free(sps);
522 return -1;
523 }
524
525 static void build_qp_table(PPS *pps, int t, int index, const int depth)
526 {
527 int i;
528 const int max_qp = 51 + 6 * (depth - 8);
529 for (i = 0; i < max_qp + 1; i++)
530 pps->chroma_qp_table[t][i] =
531 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
532 }
533
534 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
535 {
536 unsigned int pps_id = get_ue_golomb(&h->gb);
537 PPS *pps;
538 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
539 int bits_left;
540
541 if (pps_id >= MAX_PPS_COUNT) {
542 av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
543 return AVERROR_INVALIDDATA;
544 } else if (h->sps.bit_depth_luma > 10) {
545 av_log(h->avctx, AV_LOG_ERROR,
546 "Unimplemented luma bit depth=%d (max=10)\n",
547 h->sps.bit_depth_luma);
548 return AVERROR_PATCHWELCOME;
549 }
550
551 pps = av_mallocz(sizeof(PPS));
552 if (!pps)
553 return AVERROR(ENOMEM);
554 pps->sps_id = get_ue_golomb_31(&h->gb);
555 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
556 h->sps_buffers[pps->sps_id] == NULL) {
557 av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
558 goto fail;
559 }
560
561 pps->cabac = get_bits1(&h->gb);
562 pps->pic_order_present = get_bits1(&h->gb);
563 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
564 if (pps->slice_group_count > 1) {
565 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
566 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
567 switch (pps->mb_slice_group_map_type) {
568 case 0:
569 #if 0
570 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
571 | run_length[i] |1 |ue(v) |
572 #endif
573 break;
574 case 2:
575 #if 0
576 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
577 | top_left_mb[i] |1 |ue(v) |
578 | bottom_right_mb[i] |1 |ue(v) |
579 | } | | |
580 #endif
581 break;
582 case 3:
583 case 4:
584 case 5:
585 #if 0
586 | slice_group_change_direction_flag |1 |u(1) |
587 | slice_group_change_rate_minus1 |1 |ue(v) |
588 #endif
589 break;
590 case 6:
591 #if 0
592 | slice_group_id_cnt_minus1 |1 |ue(v) |
593 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
594 | slice_group_id[i] |1 |u(v) |
595 #endif
596 break;
597 }
598 }
599 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
600 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
601 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
602 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
603 goto fail;
604 }
605
606 pps->weighted_pred = get_bits1(&h->gb);
607 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
608 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
609 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
610 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
611 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
612 pps->constrained_intra_pred = get_bits1(&h->gb);
613 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
614
615 pps->transform_8x8_mode = 0;
616 // contents of sps/pps can change even if id doesn't, so reinit
617 h->dequant_coeff_pps = -1;
618 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
619 sizeof(pps->scaling_matrix4));
620 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
621 sizeof(pps->scaling_matrix8));
622
623 bits_left = bit_length - get_bits_count(&h->gb);
624 if (bits_left && (bits_left > 8 ||
625 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
626 pps->transform_8x8_mode = get_bits1(&h->gb);
627 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
628 pps->scaling_matrix4, pps->scaling_matrix8);
629 // second_chroma_qp_index_offset
630 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
631 } else {
632 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
633 }
634
635 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
636 h->sps.bit_depth_luma);
637 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
638 h->sps.bit_depth_luma);
639 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
640 pps->chroma_qp_diff = 1;
641
642 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
643 av_log(h->avctx, AV_LOG_DEBUG,
644 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
645 pps_id, pps->sps_id,
646 pps->cabac ? "CABAC" : "CAVLC",
647 pps->slice_group_count,
648 pps->ref_count[0], pps->ref_count[1],
649 pps->weighted_pred ? "weighted" : "",
650 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
651 pps->deblocking_filter_parameters_present ? "LPAR" : "",
652 pps->constrained_intra_pred ? "CONSTR" : "",
653 pps->redundant_pic_cnt_present ? "REDU" : "",
654 pps->transform_8x8_mode ? "8x8DCT" : "");
655 }
656
657 av_free(h->pps_buffers[pps_id]);
658 h->pps_buffers[pps_id] = pps;
659 return 0;
660
661 fail:
662 av_free(pps);
663 return -1;
664 }