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