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