h264: reset num_reorder_frames if it is invalid
[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,
9ecabd78
AK
227 "Clipping illegal num_reorder_frames %d\n",
228 sps->num_reorder_frames);
229 sps->num_reorder_frames = 16;
c18838f5 230 return AVERROR_INVALIDDATA;
889fce8e
MN
231 }
232 }
2c541554 233 if (get_bits_left(&h->gb) < 0) {
330ad1f6
DB
234 av_log(h->avctx, AV_LOG_ERROR,
235 "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
3aa661ec
MN
236 return AVERROR_INVALIDDATA;
237 }
889fce8e
MN
238
239 return 0;
240}
241
242static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
330ad1f6
DB
243 const uint8_t *jvt_list,
244 const uint8_t *fallback_list)
245{
889fce8e
MN
246 int i, last = 8, next = 8;
247 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
330ad1f6
DB
248 if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
249 memcpy(factors, fallback_list, size * sizeof(uint8_t));
889fce8e 250 else
330ad1f6
DB
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;
889fce8e 259 }
889fce8e
MN
260}
261
330ad1f6
DB
262static 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{
889fce8e
MN
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],
c90b9442 272 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
889fce8e 273 };
330ad1f6 274 if (get_bits1(&h->gb)) {
889fce8e 275 sps->scaling_matrix_present |= is_sps;
330ad1f6
DB
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
c90b9442 287 }
330ad1f6
DB
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
c90b9442 292 }
889fce8e
MN
293 }
294 }
295}
296
330ad1f6
DB
297int ff_h264_decode_seq_parameter_set(H264Context *h)
298{
fe9a3fbe 299 int profile_idc, level_idc, constraint_set_flags = 0;
889fce8e 300 unsigned int sps_id;
d7d6efe4 301 int i, log2_max_frame_num_minus4;
889fce8e
MN
302 SPS *sps;
303
330ad1f6
DB
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
2c541554 309 get_bits(&h->gb, 4); // reserved
330ad1f6
DB
310 level_idc = get_bits(&h->gb, 8);
311 sps_id = get_ue_golomb_31(&h->gb);
889fce8e 312
330ad1f6 313 if (sps_id >= MAX_SPS_COUNT) {
2c541554 314 av_log(h->avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
c18838f5 315 return AVERROR_INVALIDDATA;
889fce8e 316 }
330ad1f6 317 sps = av_mallocz(sizeof(SPS));
c18838f5
DB
318 if (!sps)
319 return AVERROR(ENOMEM);
889fce8e 320
330ad1f6
DB
321 sps->time_offset_length = 24;
322 sps->profile_idc = profile_idc;
fe9a3fbe 323 sps->constraint_set_flags = constraint_set_flags;
330ad1f6 324 sps->level_idc = level_idc;
889fce8e
MN
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
1c8bf3bf
VL
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) {
330ad1f6
DB
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);
cb348677 340 goto fail;
330ad1f6 341 } else if (sps->chroma_format_idc == 3) {
2c541554 342 sps->residual_color_transform_flag = get_bits1(&h->gb);
6ef40639 343 }
2c541554
AK
344 sps->bit_depth_luma = get_ue_golomb(&h->gb) + 8;
345 sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
bfd26b7c
AK
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 }
2c541554 351 sps->transform_bypass = get_bits1(&h->gb);
330ad1f6
DB
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;
889fce8e
MN
358 }
359
2c541554 360 log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
d7d6efe4
JG
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) {
2c541554 363 av_log(h->avctx, AV_LOG_ERROR,
d7d6efe4
JG
364 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
365 log2_max_frame_num_minus4);
a421bbfe 366 goto fail;
d7d6efe4
JG
367 }
368 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
369
330ad1f6 370 sps->poc_type = get_ue_golomb_31(&h->gb);
889fce8e 371
330ad1f6
DB
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);
889fce8e 379
330ad1f6
DB
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);
889fce8e
MN
384 goto fail;
385 }
386
330ad1f6
DB
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) {
2c541554 390 av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
889fce8e
MN
391 goto fail;
392 }
393
330ad1f6
DB
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) {
2c541554 397 av_log(h->avctx, AV_LOG_ERROR, "too many reference frames\n");
889fce8e
MN
398 goto fail;
399 }
330ad1f6
DB
400 sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
401 sps->mb_width = get_ue_golomb(&h->gb) + 1;
402 sps->mb_height = get_ue_golomb(&h->gb) + 1;
403 if ((unsigned)sps->mb_width >= INT_MAX / 16 ||
404 (unsigned)sps->mb_height >= INT_MAX / 16 ||
405 av_image_check_size(16 * sps->mb_width,
406 16 * sps->mb_height, 0, h->avctx)) {
2c541554 407 av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
889fce8e
MN
408 goto fail;
409 }
410
330ad1f6
DB
411 sps->frame_mbs_only_flag = get_bits1(&h->gb);
412 if (!sps->frame_mbs_only_flag)
413 sps->mb_aff = get_bits1(&h->gb);
889fce8e 414 else
330ad1f6 415 sps->mb_aff = 0;
889fce8e 416
330ad1f6
DB
417 sps->direct_8x8_inference_flag = get_bits1(&h->gb);
418 if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
419 av_log(h->avctx, AV_LOG_ERROR,
420 "This stream was generated by a broken encoder, invalid 8x8 inference\n");
1c3ce2cd
MN
421 goto fail;
422 }
889fce8e
MN
423
424#ifndef ALLOW_INTERLACE
330ad1f6
DB
425 if (sps->mb_aff)
426 av_log(h->avctx, AV_LOG_ERROR,
427 "MBAFF support not included; enable it at compile-time.\n");
889fce8e 428#endif
330ad1f6
DB
429 sps->crop = get_bits1(&h->gb);
430 if (sps->crop) {
5e83d9ac
AK
431 int crop_left = get_ue_golomb(&h->gb);
432 int crop_right = get_ue_golomb(&h->gb);
433 int crop_top = get_ue_golomb(&h->gb);
434 int crop_bottom = get_ue_golomb(&h->gb);
435
2c541554 436 if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
5e83d9ac 437 av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
330ad1f6
DB
438 "values are l:%u r:%u t:%u b:%u\n",
439 crop_left, crop_right, crop_top, crop_bottom);
a84fb6e0
VG
440
441 sps->crop_left =
442 sps->crop_right =
443 sps->crop_top =
444 sps->crop_bottom = 0;
5e83d9ac 445 } else {
330ad1f6
DB
446 int vsub = (sps->chroma_format_idc == 1) ? 1 : 0;
447 int hsub = (sps->chroma_format_idc == 1 ||
448 sps->chroma_format_idc == 2) ? 1 : 0;
5e83d9ac
AK
449 int step_x = 1 << hsub;
450 int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
451
452 if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
453 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
454 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
330ad1f6
DB
455 av_log(h->avctx, AV_LOG_WARNING,
456 "Reducing left cropping to %d "
5e83d9ac
AK
457 "chroma samples to preserve alignment.\n",
458 crop_left);
459 }
460
461 sps->crop_left = crop_left * step_x;
462 sps->crop_right = crop_right * step_x;
463 sps->crop_top = crop_top * step_y;
464 sps->crop_bottom = crop_bottom * step_y;
889fce8e 465 }
330ad1f6
DB
466 } else {
467 sps->crop_left =
468 sps->crop_right =
469 sps->crop_top =
470 sps->crop_bottom =
471 sps->crop = 0;
889fce8e
MN
472 }
473
330ad1f6 474 sps->vui_parameters_present_flag = get_bits1(&h->gb);
94603feb
AK
475 if (sps->vui_parameters_present_flag) {
476 int ret = decode_vui_parameters(h, sps);
477 if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
889fce8e 478 goto fail;
94603feb 479 }
889fce8e 480
330ad1f6
DB
481 if (!sps->sar.den)
482 sps->sar.den = 1;
cfa5a81e 483
330ad1f6 484 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
be391fb6 485 static const char csp[4][5] = { "Gray", "420", "422", "444" };
330ad1f6
DB
486 av_log(h->avctx, AV_LOG_DEBUG,
487 "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
488 sps_id, sps->profile_idc, sps->level_idc,
489 sps->poc_type,
490 sps->ref_frame_count,
491 sps->mb_width, sps->mb_height,
492 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
493 sps->direct_8x8_inference_flag ? "8B8" : "",
494 sps->crop_left, sps->crop_right,
495 sps->crop_top, sps->crop_bottom,
496 sps->vui_parameters_present_flag ? "VUI" : "",
be391fb6 497 csp[sps->chroma_format_idc],
889fce8e 498 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
330ad1f6 499 sps->timing_info_present_flag ? sps->time_scale : 0);
889fce8e 500 }
072be3e8 501 sps->new = 1;
889fce8e
MN
502
503 av_free(h->sps_buffers[sps_id]);
072be3e8
JG
504 h->sps_buffers[sps_id] = sps;
505 h->sps = *sps;
506 h->current_sps_id = sps_id;
507
889fce8e 508 return 0;
330ad1f6 509
889fce8e
MN
510fail:
511 av_free(sps);
512 return -1;
513}
514
330ad1f6 515static void build_qp_table(PPS *pps, int t, int index, const int depth)
889fce8e
MN
516{
517 int i;
330ad1f6
DB
518 const int max_qp = 51 + 6 * (depth - 8);
519 for (i = 0; i < max_qp + 1; i++)
520 pps->chroma_qp_table[t][i] =
521 ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
889fce8e
MN
522}
523
330ad1f6
DB
524int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
525{
526 unsigned int pps_id = get_ue_golomb(&h->gb);
889fce8e 527 PPS *pps;
330ad1f6 528 const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
be1242a3 529 int bits_left;
889fce8e 530
330ad1f6 531 if (pps_id >= MAX_PPS_COUNT) {
2c541554 532 av_log(h->avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
c18838f5 533 return AVERROR_INVALIDDATA;
732f9fcf 534 } else if (h->sps.bit_depth_luma > 10) {
330ad1f6
DB
535 av_log(h->avctx, AV_LOG_ERROR,
536 "Unimplemented luma bit depth=%d (max=10)\n",
537 h->sps.bit_depth_luma);
732f9fcf 538 return AVERROR_PATCHWELCOME;
889fce8e
MN
539 }
540
330ad1f6 541 pps = av_mallocz(sizeof(PPS));
c18838f5
DB
542 if (!pps)
543 return AVERROR(ENOMEM);
330ad1f6
DB
544 pps->sps_id = get_ue_golomb_31(&h->gb);
545 if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
546 h->sps_buffers[pps->sps_id] == NULL) {
2c541554 547 av_log(h->avctx, AV_LOG_ERROR, "sps_id out of range\n");
889fce8e
MN
548 goto fail;
549 }
550
330ad1f6
DB
551 pps->cabac = get_bits1(&h->gb);
552 pps->pic_order_present = get_bits1(&h->gb);
553 pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
554 if (pps->slice_group_count > 1) {
555 pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
2c541554 556 av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
330ad1f6 557 switch (pps->mb_slice_group_map_type) {
889fce8e
MN
558 case 0:
559#if 0
330ad1f6
DB
560 | for (i = 0; i <= num_slice_groups_minus1; i++) | | |
561 | run_length[i] |1 |ue(v) |
889fce8e
MN
562#endif
563 break;
564 case 2:
565#if 0
330ad1f6
DB
566 | for (i = 0; i < num_slice_groups_minus1; i++) { | | |
567 | top_left_mb[i] |1 |ue(v) |
568 | bottom_right_mb[i] |1 |ue(v) |
569 | } | | |
889fce8e
MN
570#endif
571 break;
572 case 3:
573 case 4:
574 case 5:
575#if 0
330ad1f6
DB
576 | slice_group_change_direction_flag |1 |u(1) |
577 | slice_group_change_rate_minus1 |1 |ue(v) |
889fce8e
MN
578#endif
579 break;
580 case 6:
581#if 0
330ad1f6
DB
582 | slice_group_id_cnt_minus1 |1 |ue(v) |
583 | for (i = 0; i <= slice_group_id_cnt_minus1; i++)| | |
584 | slice_group_id[i] |1 |u(v) |
889fce8e
MN
585#endif
586 break;
587 }
588 }
330ad1f6
DB
589 pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
590 pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
591 if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
2c541554 592 av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
889fce8e
MN
593 goto fail;
594 }
595
330ad1f6
DB
596 pps->weighted_pred = get_bits1(&h->gb);
597 pps->weighted_bipred_idc = get_bits(&h->gb, 2);
598 pps->init_qp = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
599 pps->init_qs = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
600 pps->chroma_qp_index_offset[0] = get_se_golomb(&h->gb);
601 pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
602 pps->constrained_intra_pred = get_bits1(&h->gb);
603 pps->redundant_pic_cnt_present = get_bits1(&h->gb);
604
605 pps->transform_8x8_mode = 0;
606 // contents of sps/pps can change even if id doesn't, so reinit
607 h->dequant_coeff_pps = -1;
608 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
609 sizeof(pps->scaling_matrix4));
610 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
611 sizeof(pps->scaling_matrix8));
889fce8e 612
2c541554 613 bits_left = bit_length - get_bits_count(&h->gb);
be1242a3 614 if (bits_left && (bits_left > 8 ||
2c541554 615 show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
330ad1f6
DB
616 pps->transform_8x8_mode = get_bits1(&h->gb);
617 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
618 pps->scaling_matrix4, pps->scaling_matrix8);
619 // second_chroma_qp_index_offset
620 pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
889fce8e 621 } else {
330ad1f6 622 pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
889fce8e
MN
623 }
624
330ad1f6
DB
625 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
626 h->sps.bit_depth_luma);
627 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
628 h->sps.bit_depth_luma);
629 if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
630 pps->chroma_qp_diff = 1;
889fce8e 631
330ad1f6
DB
632 if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
633 av_log(h->avctx, AV_LOG_DEBUG,
634 "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
889fce8e
MN
635 pps_id, pps->sps_id,
636 pps->cabac ? "CABAC" : "CAVLC",
637 pps->slice_group_count,
638 pps->ref_count[0], pps->ref_count[1],
639 pps->weighted_pred ? "weighted" : "",
640 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
641 pps->deblocking_filter_parameters_present ? "LPAR" : "",
642 pps->constrained_intra_pred ? "CONSTR" : "",
643 pps->redundant_pic_cnt_present ? "REDU" : "",
330ad1f6 644 pps->transform_8x8_mode ? "8x8DCT" : "");
889fce8e
MN
645 }
646
647 av_free(h->pps_buffers[pps_id]);
330ad1f6 648 h->pps_buffers[pps_id] = pps;
889fce8e 649 return 0;
330ad1f6 650
889fce8e
MN
651fail:
652 av_free(pps);
653 return -1;
654}