h264: reject mismatching luma/chroma bit depths during sps parsing
[libav.git] / libavcodec / h264_ps.c
CommitLineData
889fce8e
MN
1/*
2 * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
2912e87a 5 * This file is part of Libav.
889fce8e 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
889fce8e
MN
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 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
889fce8e
MN
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
889fce8e
MN
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22/**
ba87f080 23 * @file
889fce8e
MN
24 * H.264 / AVC / MPEG4 part10 parameter set decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
737eb597 28#include "libavutil/imgutils.h"
889fce8e 29#include "internal.h"
889fce8e
MN
30#include "avcodec.h"
31#include "h264.h"
32#include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
33#include "golomb.h"
34
d7d6efe4
JG
35#define MAX_LOG2_MAX_FRAME_NUM (12 + 4)
36#define MIN_LOG2_MAX_FRAME_NUM 4
37
330ad1f6
DB
38static 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 },
889fce8e
MN
56};
57
330ad1f6
DB
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
71const 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) },
889fce8e
MN
78};
79
330ad1f6
DB
80static 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
87static 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
106static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
107{
889fce8e 108 int cpb_count, i;
2c541554 109 cpb_count = get_ue_golomb_31(&h->gb) + 1;
889fce8e 110
330ad1f6 111 if (cpb_count > 32U) {
2c541554 112 av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
c18838f5 113 return AVERROR_INVALIDDATA;
889fce8e
MN
114 }
115
2c541554
AK
116 get_bits(&h->gb, 4); /* bit_rate_scale */
117 get_bits(&h->gb, 4); /* cpb_size_scale */
330ad1f6 118 for (i = 0; i < cpb_count; i++) {
2c541554
AK
119 get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
120 get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
330ad1f6 121 get_bits1(&h->gb); /* cbr_flag */
889fce8e 122 }
2c541554 123 sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
330ad1f6
DB
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;
889fce8e
MN
128 return 0;
129}
130
330ad1f6
DB
131static inline int decode_vui_parameters(H264Context *h, SPS *sps)
132{
889fce8e
MN
133 int aspect_ratio_info_present_flag;
134 unsigned int aspect_ratio_idc;
135
330ad1f6 136 aspect_ratio_info_present_flag = get_bits1(&h->gb);
889fce8e 137
330ad1f6
DB
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 {
2c541554 146 av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
c18838f5 147 return AVERROR_INVALIDDATA;
889fce8e 148 }
330ad1f6
DB
149 } else {
150 sps->sar.num =
151 sps->sar.den = 0;
889fce8e 152 }
889fce8e 153
330ad1f6 154 if (get_bits1(&h->gb)) /* overscan_info_present_flag */
2c541554 155 get_bits1(&h->gb); /* overscan_appropriate_flag */
889fce8e 156
2c541554 157 sps->video_signal_type_present_flag = get_bits1(&h->gb);
330ad1f6
DB
158 if (sps->video_signal_type_present_flag) {
159 get_bits(&h->gb, 3); /* video_format */
2c541554 160 sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
889fce8e 161
2c541554 162 sps->colour_description_present_flag = get_bits1(&h->gb);
330ad1f6 163 if (sps->colour_description_present_flag) {
2c541554
AK
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 */
889fce8e 167 if (sps->color_primaries >= AVCOL_PRI_NB)
330ad1f6 168 sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
889fce8e 169 if (sps->color_trc >= AVCOL_TRC_NB)
330ad1f6 170 sps->color_trc = AVCOL_TRC_UNSPECIFIED;
889fce8e 171 if (sps->colorspace >= AVCOL_SPC_NB)
330ad1f6 172 sps->colorspace = AVCOL_SPC_UNSPECIFIED;
889fce8e
MN
173 }
174 }
175
330ad1f6
DB
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;
2c541554 180 get_ue_golomb(&h->gb); /* chroma_sample_location_type_bottom_field */
889fce8e
MN
181 }
182
2c541554 183 sps->timing_info_present_flag = get_bits1(&h->gb);
330ad1f6 184 if (sps->timing_info_present_flag) {
2c541554 185 sps->num_units_in_tick = get_bits_long(&h->gb, 32);
330ad1f6
DB
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);
c18838f5 191 return AVERROR_INVALIDDATA;
889fce8e 192 }
2c541554 193 sps->fixed_frame_rate_flag = get_bits1(&h->gb);
889fce8e
MN
194 }
195
2c541554 196 sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
330ad1f6
DB
197 if (sps->nal_hrd_parameters_present_flag)
198 if (decode_hrd_parameters(h, sps) < 0)
c18838f5 199 return AVERROR_INVALIDDATA;
2c541554 200 sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
330ad1f6
DB
201 if (sps->vcl_hrd_parameters_present_flag)
202 if (decode_hrd_parameters(h, sps) < 0)
c18838f5 203 return AVERROR_INVALIDDATA;
330ad1f6
DB
204 if (sps->nal_hrd_parameters_present_flag ||
205 sps->vcl_hrd_parameters_present_flag)
2c541554
AK
206 get_bits1(&h->gb); /* low_delay_hrd_flag */
207 sps->pic_struct_present_flag = get_bits1(&h->gb);
889fce8e 208
2c541554 209 sps->bitstream_restriction_flag = get_bits1(&h->gb);
330ad1f6 210 if (sps->bitstream_restriction_flag) {
2c541554
AK
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 */
330ad1f6 216 sps->num_reorder_frames = get_ue_golomb(&h->gb);
2c541554
AK
217 get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
218
219 if (get_bits_left(&h->gb) < 0) {
330ad1f6
DB
220 sps->num_reorder_frames = 0;
221 sps->bitstream_restriction_flag = 0;
f4348e6c
MN
222 }
223
330ad1f6
DB
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);
c18838f5 228 return AVERROR_INVALIDDATA;
889fce8e
MN
229 }
230 }
2c541554 231 if (get_bits_left(&h->gb) < 0) {
330ad1f6
DB
232 av_log(h->avctx, AV_LOG_ERROR,
233 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
3aa661ec
MN
234 return AVERROR_INVALIDDATA;
235 }
889fce8e
MN
236
237 return 0;
238}
239
240static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
330ad1f6
DB
241 const uint8_t *jvt_list,
242 const uint8_t *fallback_list)
243{
889fce8e
MN
244 int i, last = 8, next = 8;
245 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
330ad1f6
DB
246 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
247 memcpy(factors, fallback_list, size * sizeof(uint8_t));
889fce8e 248 else
330ad1f6
DB
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;
889fce8e 257 }
889fce8e
MN
258}
259
330ad1f6
DB
260static 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{
889fce8e
MN
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],
c90b9442 270 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
889fce8e 271 };
330ad1f6 272 if (get_bits1(&h->gb)) {
889fce8e 273 sps->scaling_matrix_present |= is_sps;
330ad1f6
DB
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
c90b9442 285 }
330ad1f6
DB
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
c90b9442 290 }
889fce8e
MN
291 }
292 }
293}
294
330ad1f6
DB
295int ff_h264_decode_seq_parameter_set(H264Context *h)
296{
fe9a3fbe 297 int profile_idc, level_idc, constraint_set_flags = 0;
889fce8e 298 unsigned int sps_id;
d7d6efe4 299 int i, log2_max_frame_num_minus4;
889fce8e
MN
300 SPS *sps;
301
330ad1f6
DB
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
2c541554 307 get_bits(&h->gb, 4); // reserved
330ad1f6
DB
308 level_idc = get_bits(&h->gb, 8);
309 sps_id = get_ue_golomb_31(&h->gb);
889fce8e 310
330ad1f6 311 if (sps_id >= MAX_SPS_COUNT) {
2c541554 312 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
c18838f5 313 return AVERROR_INVALIDDATA;
889fce8e 314 }
330ad1f6 315 sps = av_mallocz(sizeof(SPS));
c18838f5
DB
316 if (!sps)
317 return AVERROR(ENOMEM);
889fce8e 318
330ad1f6
DB
319 sps->time_offset_length = 24;
320 sps->profile_idc = profile_idc;
fe9a3fbe 321 sps->constraint_set_flags = constraint_set_flags;
330ad1f6 322 sps->level_idc = level_idc;
889fce8e
MN
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
1c8bf3bf
VL
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) {
330ad1f6
DB
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);
cb348677 338 goto fail;
330ad1f6 339 } else if (sps->chroma_format_idc == 3) {
2c541554 340 sps->residual_color_transform_flag = get_bits1(&h->gb);
6ef40639 341 }
2c541554
AK
342 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
343 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
bfd26b7c
AK
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 }
2c541554 349 sps->transform_bypass = get_bits1(&h->gb);
330ad1f6
DB
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;
889fce8e
MN
356 }
357
2c541554 358 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
d7d6efe4
JG
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) {
2c541554 361 av_log(h->avctx, AV_LOG_ERROR,
d7d6efe4
JG
362 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
363 log2_max_frame_num_minus4);
a421bbfe 364 goto fail;
d7d6efe4
JG
365 }
366 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
367
330ad1f6 368 sps->poc_type = get_ue_golomb_31(&h->gb);
889fce8e 369
330ad1f6
DB
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);
889fce8e 377
330ad1f6
DB
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);
889fce8e
MN
382 goto fail;
383 }
384
330ad1f6
DB
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) {
2c541554 388 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
889fce8e
MN
389 goto fail;
390 }
391
330ad1f6
DB
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) {
2c541554 395 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
889fce8e
MN
396 goto fail;
397 }
330ad1f6
DB
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)) {
2c541554 405 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
889fce8e
MN
406 goto fail;
407 }
408
330ad1f6
DB
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);
889fce8e 412 else
330ad1f6 413 sps->mb_aff = 0;
889fce8e 414
330ad1f6
DB
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");
1c3ce2cd
MN
419 goto fail;
420 }
889fce8e
MN
421
422#ifndef ALLOW_INTERLACE
330ad1f6
DB
423 if (sps->mb_aff)
424 av_log(h->avctx, AV_LOG_ERROR,
425 "MBAFF support not included; enable it at compile-time.\n");
889fce8e 426#endif
330ad1f6
DB
427 sps->crop = get_bits1(&h->gb);
428 if (sps->crop) {
5e83d9ac
AK
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
2c541554 434 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
5e83d9ac 435 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
330ad1f6
DB
436 "values are l:%u r:%u t:%u b:%u\n",
437 crop_left, crop_right, crop_top, crop_bottom);
a84fb6e0
VG
438
439 sps->crop_left =
440 sps->crop_right =
441 sps->crop_top =
442 sps->crop_bottom = 0;
5e83d9ac 443 } else {
330ad1f6
DB
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;
5e83d9ac
AK
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));
330ad1f6
DB
453 av_log(h->avctx, AV_LOG_WARNING,
454 "Reducing left cropping to %d "
5e83d9ac
AK
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;
889fce8e 463 }
330ad1f6
DB
464 } else {
465 sps->crop_left =
466 sps->crop_right =
467 sps->crop_top =
468 sps->crop_bottom =
469 sps->crop = 0;
889fce8e
MN
470 }
471
330ad1f6 472 sps->vui_parameters_present_flag = get_bits1(&h->gb);
94603feb
AK
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)
889fce8e 476 goto fail;
94603feb 477 }
889fce8e 478
330ad1f6
DB
479 if (!sps->sar.den)
480 sps->sar.den = 1;
cfa5a81e 481
330ad1f6 482 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
be391fb6 483 static const char csp[4][5] = { "Gray", "420", "422", "444" };
330ad1f6
DB
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",
889fce8e
MN
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" : "",
be391fb6 495 csp[sps->chroma_format_idc],
889fce8e 496 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
330ad1f6 497 sps->timing_info_present_flag ? sps->time_scale : 0);
889fce8e 498 }
072be3e8 499 sps->new = 1;
889fce8e
MN
500
501 av_free(h->sps_buffers[sps_id]);
072be3e8
JG
502 h->sps_buffers[sps_id] = sps;
503 h->sps = *sps;
504 h->current_sps_id = sps_id;
505
889fce8e 506 return 0;
330ad1f6 507
889fce8e
MN
508fail:
509 av_free(sps);
510 return -1;
511}
512
330ad1f6 513static void build_qp_table(PPS *pps, int t, int index, const int depth)
889fce8e
MN
514{
515 int i;
330ad1f6
DB
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)];
889fce8e
MN
520}
521
330ad1f6
DB
522int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
523{
524 unsigned int pps_id = get_ue_golomb(&h->gb);
889fce8e 525 PPS *pps;
330ad1f6 526 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
be1242a3 527 int bits_left;
889fce8e 528
330ad1f6 529 if (pps_id >= MAX_PPS_COUNT) {
2c541554 530 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
c18838f5 531 return AVERROR_INVALIDDATA;
732f9fcf 532 } else if (h->sps.bit_depth_luma > 10) {
330ad1f6
DB
533 av_log(h->avctx, AV_LOG_ERROR,
534 "Unimplemented luma bit depth=%d (max=10)\n",
535 h->sps.bit_depth_luma);
732f9fcf 536 return AVERROR_PATCHWELCOME;
889fce8e
MN
537 }
538
330ad1f6 539 pps = av_mallocz(sizeof(PPS));
c18838f5
DB
540 if (!pps)
541 return AVERROR(ENOMEM);
330ad1f6
DB
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) {
2c541554 545 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
889fce8e
MN
546 goto fail;
547 }
548
330ad1f6
DB
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);
2c541554 554 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
330ad1f6 555 switch (pps->mb_slice_group_map_type) {
889fce8e
MN
556 case 0:
557#if 0
330ad1f6
DB
558 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
559 | run_length[i] |1 |ue(v) |
889fce8e
MN
560#endif
561 break;
562 case 2:
563#if 0
330ad1f6
DB
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 | } | | |
889fce8e
MN
568#endif
569 break;
570 case 3:
571 case 4:
572 case 5:
573#if 0
330ad1f6
DB
574 | slice_group_change_direction_flag |1 |u(1) |
575 | slice_group_change_rate_minus1 |1 |ue(v) |
889fce8e
MN
576#endif
577 break;
578 case 6:
579#if 0
330ad1f6
DB
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) |
889fce8e
MN
583#endif
584 break;
585 }
586 }
330ad1f6
DB
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) {
2c541554 590 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
889fce8e
MN
591 goto fail;
592 }
593
330ad1f6
DB
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));
889fce8e 610
2c541554 611 bits_left = bit_length - get_bits_count(&h->gb);
be1242a3 612 if (bits_left && (bits_left > 8 ||
2c541554 613 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
330ad1f6
DB
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);
889fce8e 619 } else {
330ad1f6 620 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
889fce8e
MN
621 }
622
330ad1f6
DB
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;
889fce8e 629
330ad1f6
DB
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",
889fce8e
MN
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" : "",
330ad1f6 642 pps->transform_8x8_mode ? "8x8DCT" : "");
889fce8e
MN
643 }
644
645 av_free(h->pps_buffers[pps_id]);
330ad1f6 646 h->pps_buffers[pps_id] = pps;
889fce8e 647 return 0;
330ad1f6 648
889fce8e
MN
649fail:
650 av_free(pps);
651 return -1;
652}