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