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