avcodec/h264_ps: Move truncation check from VUI to SPS
[ffmpeg.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 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     return 0;
245 }
246
247 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
248                                 const uint8_t *jvt_list,
249                                 const uint8_t *fallback_list)
250 {
251     int i, last = 8, next = 8;
252     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
253     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
254         memcpy(factors, fallback_list, size * sizeof(uint8_t));
255     else
256         for (i = 0; i < size; i++) {
257             if (next)
258                 next = (last + get_se_golomb(&h->gb)) & 0xff;
259             if (!i && !next) { /* matrix not written, we use the preset one */
260                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
261                 break;
262             }
263             last = factors[scan[i]] = next ? next : last;
264         }
265 }
266
267 static void decode_scaling_matrices(H264Context *h, SPS *sps,
268                                     PPS *pps, int is_sps,
269                                     uint8_t(*scaling_matrix4)[16],
270                                     uint8_t(*scaling_matrix8)[64])
271 {
272     int fallback_sps = !is_sps && sps->scaling_matrix_present;
273     const uint8_t *fallback[4] = {
274         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
275         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
276         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
277         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
278     };
279     if (get_bits1(&h->gb)) {
280         sps->scaling_matrix_present |= is_sps;
281         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
282         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
283         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
284         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
285         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
286         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
287         if (is_sps || pps->transform_8x8_mode) {
288             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
289             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
290             if (sps->chroma_format_idc == 3) {
291                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
292                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
293                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
294                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
295             }
296         }
297     }
298 }
299
300 int ff_h264_decode_seq_parameter_set(H264Context *h)
301 {
302     int profile_idc, level_idc, constraint_set_flags = 0;
303     unsigned int sps_id;
304     int i, log2_max_frame_num_minus4;
305     SPS *sps;
306
307     profile_idc           = get_bits(&h->gb, 8);
308     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
309     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
310     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
311     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
312     constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
313     constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
314     skip_bits(&h->gb, 2);                             // reserved_zero_2bits
315     level_idc = get_bits(&h->gb, 8);
316     sps_id    = get_ue_golomb_31(&h->gb);
317
318     if (sps_id >= MAX_SPS_COUNT) {
319         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
320         return AVERROR_INVALIDDATA;
321     }
322     sps = av_mallocz(sizeof(SPS));
323     if (!sps)
324         return AVERROR(ENOMEM);
325
326     sps->sps_id               = sps_id;
327     sps->time_offset_length   = 24;
328     sps->profile_idc          = profile_idc;
329     sps->constraint_set_flags = constraint_set_flags;
330     sps->level_idc            = level_idc;
331     sps->full_range           = -1;
332
333     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
334     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
335     sps->scaling_matrix_present = 0;
336     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
337
338     if (sps->profile_idc == 100 ||  // High profile
339         sps->profile_idc == 110 ||  // High10 profile
340         sps->profile_idc == 122 ||  // High422 profile
341         sps->profile_idc == 244 ||  // High444 Predictive profile
342         sps->profile_idc ==  44 ||  // Cavlc444 profile
343         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)
344         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)
345         sps->profile_idc == 118 ||  // Stereo High profile (MVC)
346         sps->profile_idc == 128 ||  // Multiview High profile (MVC)
347         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
348         sps->profile_idc == 144) {  // old High444 profile
349         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
350         if (sps->chroma_format_idc > 3U) {
351             avpriv_request_sample(h->avctx, "chroma_format_idc %u",
352                                   sps->chroma_format_idc);
353             goto fail;
354         } else if (sps->chroma_format_idc == 3) {
355             sps->residual_color_transform_flag = get_bits1(&h->gb);
356             if (sps->residual_color_transform_flag) {
357                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
358                 goto fail;
359             }
360         }
361         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
362         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
363         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
364             avpriv_request_sample(h->avctx,
365                                   "Different chroma and luma bit depth");
366             goto fail;
367         }
368         if (sps->bit_depth_luma   < 8 || sps->bit_depth_luma   > 14 ||
369             sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
370             av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
371                    sps->bit_depth_luma, sps->bit_depth_chroma);
372             goto fail;
373         }
374         sps->transform_bypass = get_bits1(&h->gb);
375         decode_scaling_matrices(h, sps, NULL, 1,
376                                 sps->scaling_matrix4, sps->scaling_matrix8);
377     } else {
378         sps->chroma_format_idc = 1;
379         sps->bit_depth_luma    = 8;
380         sps->bit_depth_chroma  = 8;
381     }
382
383     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
384     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
385         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
386         av_log(h->avctx, AV_LOG_ERROR,
387                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
388                log2_max_frame_num_minus4);
389         goto fail;
390     }
391     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
392
393     sps->poc_type = get_ue_golomb_31(&h->gb);
394
395     if (sps->poc_type == 0) { // FIXME #define
396         unsigned t = get_ue_golomb(&h->gb);
397         if (t>12) {
398             av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
399             goto fail;
400         }
401         sps->log2_max_poc_lsb = t + 4;
402     } else if (sps->poc_type == 1) { // FIXME #define
403         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
404         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
405         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
406         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
407
408         if ((unsigned)sps->poc_cycle_length >=
409             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
410             av_log(h->avctx, AV_LOG_ERROR,
411                    "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
412             goto fail;
413         }
414
415         for (i = 0; i < sps->poc_cycle_length; i++)
416             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
417     } else if (sps->poc_type != 2) {
418         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
419         goto fail;
420     }
421
422     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
423     if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
424         sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
425     if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
426         sps->ref_frame_count > 16U) {
427         av_log(h->avctx, AV_LOG_ERROR,
428                "too many reference frames %d\n", sps->ref_frame_count);
429         goto fail;
430     }
431     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
432     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
433     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
434     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
435         (unsigned)sps->mb_height >= INT_MAX / 16 ||
436         av_image_check_size(16 * sps->mb_width,
437                             16 * sps->mb_height, 0, h->avctx)) {
438         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
439         goto fail;
440     }
441
442     sps->frame_mbs_only_flag = get_bits1(&h->gb);
443     if (!sps->frame_mbs_only_flag)
444         sps->mb_aff = get_bits1(&h->gb);
445     else
446         sps->mb_aff = 0;
447
448     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
449
450 #ifndef ALLOW_INTERLACE
451     if (sps->mb_aff)
452         av_log(h->avctx, AV_LOG_ERROR,
453                "MBAFF support not included; enable it at compile-time.\n");
454 #endif
455     sps->crop = get_bits1(&h->gb);
456     if (sps->crop) {
457         unsigned int crop_left   = get_ue_golomb(&h->gb);
458         unsigned int crop_right  = get_ue_golomb(&h->gb);
459         unsigned int crop_top    = get_ue_golomb(&h->gb);
460         unsigned int crop_bottom = get_ue_golomb(&h->gb);
461         int width  = 16 * sps->mb_width;
462         int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
463
464         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
465             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
466                                            "values are l:%d r:%d t:%d b:%d\n",
467                    crop_left, crop_right, crop_top, crop_bottom);
468
469             sps->crop_left   =
470             sps->crop_right  =
471             sps->crop_top    =
472             sps->crop_bottom = 0;
473         } else {
474             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
475             int hsub   = (sps->chroma_format_idc == 1 ||
476                           sps->chroma_format_idc == 2) ? 1 : 0;
477             int step_x = 1 << hsub;
478             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
479
480             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
481                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
482                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
483                 av_log(h->avctx, AV_LOG_WARNING,
484                        "Reducing left cropping to %d "
485                        "chroma samples to preserve alignment.\n",
486                        crop_left);
487             }
488
489             if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
490                 crop_right > (unsigned)INT_MAX / 4 / step_x ||
491                 crop_top   > (unsigned)INT_MAX / 4 / step_y ||
492                 crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
493                 (crop_left + crop_right ) * step_x >= width ||
494                 (crop_top  + crop_bottom) * step_y >= height
495             ) {
496                 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);
497                 goto fail;
498             }
499
500             sps->crop_left   = crop_left   * step_x;
501             sps->crop_right  = crop_right  * step_x;
502             sps->crop_top    = crop_top    * step_y;
503             sps->crop_bottom = crop_bottom * step_y;
504         }
505     } else {
506         sps->crop_left   =
507         sps->crop_right  =
508         sps->crop_top    =
509         sps->crop_bottom =
510         sps->crop        = 0;
511     }
512
513     sps->vui_parameters_present_flag = get_bits1(&h->gb);
514     if (sps->vui_parameters_present_flag) {
515         int ret = decode_vui_parameters(h, sps);
516         if (ret < 0)
517             goto fail;
518     }
519
520     if (get_bits_left(&h->gb) < 0) {
521         av_log(h->avctx, AV_LOG_ERROR,
522                "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
523         goto fail;
524     }
525
526     if (!sps->sar.den)
527         sps->sar.den = 1;
528
529     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
530         static const char csp[4][5] = { "Gray", "420", "422", "444" };
531         av_log(h->avctx, AV_LOG_DEBUG,
532                "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",
533                sps_id, sps->profile_idc, sps->level_idc,
534                sps->poc_type,
535                sps->ref_frame_count,
536                sps->mb_width, sps->mb_height,
537                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
538                sps->direct_8x8_inference_flag ? "8B8" : "",
539                sps->crop_left, sps->crop_right,
540                sps->crop_top, sps->crop_bottom,
541                sps->vui_parameters_present_flag ? "VUI" : "",
542                csp[sps->chroma_format_idc],
543                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
544                sps->timing_info_present_flag ? sps->time_scale : 0,
545                sps->bit_depth_luma,
546                sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
547                );
548     }
549     sps->new = 1;
550
551     av_free(h->sps_buffers[sps_id]);
552     h->sps_buffers[sps_id] = sps;
553
554     return 0;
555
556 fail:
557     av_free(sps);
558     return -1;
559 }
560
561 static void build_qp_table(PPS *pps, int t, int index, const int depth)
562 {
563     int i;
564     const int max_qp = 51 + 6 * (depth - 8);
565     for (i = 0; i < max_qp + 1; i++)
566         pps->chroma_qp_table[t][i] =
567             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
568 }
569
570 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
571 {
572     const SPS *sps = h->sps_buffers[pps->sps_id];
573     int profile_idc = sps->profile_idc;
574
575     if ((profile_idc == 66 || profile_idc == 77 ||
576          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
577         av_log(h->avctx, AV_LOG_VERBOSE,
578                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
579         return 0;
580     }
581
582     return 1;
583 }
584
585 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
586 {
587     const SPS *sps;
588     unsigned int pps_id = get_ue_golomb(&h->gb);
589     PPS *pps;
590     int qp_bd_offset;
591     int bits_left;
592
593     if (pps_id >= MAX_PPS_COUNT) {
594         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
595         return AVERROR_INVALIDDATA;
596     }
597
598     pps = av_mallocz(sizeof(PPS));
599     if (!pps)
600         return AVERROR(ENOMEM);
601     pps->sps_id = get_ue_golomb_31(&h->gb);
602     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
603         !h->sps_buffers[pps->sps_id]) {
604         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
605         goto fail;
606     }
607     sps = h->sps_buffers[pps->sps_id];
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     qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
666
667     pps->weighted_pred                        = get_bits1(&h->gb);
668     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
669     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
670     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
671     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
672     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
673     pps->constrained_intra_pred               = get_bits1(&h->gb);
674     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
675
676     pps->transform_8x8_mode = 0;
677     // contents of sps/pps can change even if id doesn't, so reinit
678     h->dequant_coeff_pps = -1;
679     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
680            sizeof(pps->scaling_matrix4));
681     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
682            sizeof(pps->scaling_matrix8));
683
684     bits_left = bit_length - get_bits_count(&h->gb);
685     if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
686         pps->transform_8x8_mode = get_bits1(&h->gb);
687         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
688                                 pps->scaling_matrix4, pps->scaling_matrix8);
689         // second_chroma_qp_index_offset
690         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
691     } else {
692         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
693     }
694
695     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
696                    sps->bit_depth_luma);
697     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
698                    sps->bit_depth_luma);
699     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
700         pps->chroma_qp_diff = 1;
701
702     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
703         av_log(h->avctx, AV_LOG_DEBUG,
704                "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
705                pps_id, pps->sps_id,
706                pps->cabac ? "CABAC" : "CAVLC",
707                pps->slice_group_count,
708                pps->ref_count[0], pps->ref_count[1],
709                pps->weighted_pred ? "weighted" : "",
710                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
711                pps->deblocking_filter_parameters_present ? "LPAR" : "",
712                pps->constrained_intra_pred ? "CONSTR" : "",
713                pps->redundant_pic_cnt_present ? "REDU" : "",
714                pps->transform_8x8_mode ? "8x8DCT" : "");
715     }
716
717     av_free(h->pps_buffers[pps_id]);
718     h->pps_buffers[pps_id] = pps;
719     return 0;
720
721 fail:
722     av_free(pps);
723     return -1;
724 }