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