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