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