h264: add MVCD to the list of High profiles in SPS
[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                    "Clipping illegal num_reorder_frames %d\n",
228                    sps->num_reorder_frames);
229             sps->num_reorder_frames = 16;
230             return AVERROR_INVALIDDATA;
231         }
232     }
233     if (get_bits_left(&h->gb) < 0) {
234         av_log(h->avctx, AV_LOG_ERROR,
235                "Overread VUI by %d bits\n", -get_bits_left(&h->gb));
236         return AVERROR_INVALIDDATA;
237     }
238
239     return 0;
240 }
241
242 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
243                                 const uint8_t *jvt_list,
244                                 const uint8_t *fallback_list)
245 {
246     int i, last = 8, next = 8;
247     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
248     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
249         memcpy(factors, fallback_list, size * sizeof(uint8_t));
250     else
251         for (i = 0; i < size; i++) {
252             if (next)
253                 next = (last + get_se_golomb(&h->gb)) & 0xff;
254             if (!i && !next) { /* matrix not written, we use the preset one */
255                 memcpy(factors, jvt_list, size * sizeof(uint8_t));
256                 break;
257             }
258             last = factors[scan[i]] = next ? next : last;
259         }
260 }
261
262 static void decode_scaling_matrices(H264Context *h, SPS *sps,
263                                     PPS *pps, int is_sps,
264                                     uint8_t(*scaling_matrix4)[16],
265                                     uint8_t(*scaling_matrix8)[64])
266 {
267     int fallback_sps = !is_sps && sps->scaling_matrix_present;
268     const uint8_t *fallback[4] = {
269         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
270         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
271         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
272         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
273     };
274     if (get_bits1(&h->gb)) {
275         sps->scaling_matrix_present |= is_sps;
276         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
277         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
278         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
279         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
280         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
281         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
282         if (is_sps || pps->transform_8x8_mode) {
283             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
284             if (sps->chroma_format_idc == 3) {
285                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
286                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
287             }
288             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
289             if (sps->chroma_format_idc == 3) {
290                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
291                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
292             }
293         }
294     }
295 }
296
297 int ff_h264_decode_seq_parameter_set(H264Context *h)
298 {
299     int profile_idc, level_idc, constraint_set_flags = 0;
300     unsigned int sps_id;
301     int i, log2_max_frame_num_minus4;
302     SPS *sps;
303
304     profile_idc           = get_bits(&h->gb, 8);
305     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
306     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
307     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
308     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
309     get_bits(&h->gb, 4); // reserved
310     level_idc = get_bits(&h->gb, 8);
311     sps_id    = get_ue_golomb_31(&h->gb);
312
313     if (sps_id >= MAX_SPS_COUNT) {
314         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
315         return AVERROR_INVALIDDATA;
316     }
317     sps = av_mallocz(sizeof(SPS));
318     if (!sps)
319         return AVERROR(ENOMEM);
320
321     sps->sps_id               = sps_id;
322     sps->time_offset_length   = 24;
323     sps->profile_idc          = profile_idc;
324     sps->constraint_set_flags = constraint_set_flags;
325     sps->level_idc            = level_idc;
326
327     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
328     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
329     sps->scaling_matrix_present = 0;
330
331     if (sps->profile_idc == 100 ||  // High profile
332         sps->profile_idc == 110 ||  // High10 profile
333         sps->profile_idc == 122 ||  // High422 profile
334         sps->profile_idc == 244 ||  // High444 Predictive profile
335         sps->profile_idc ==  44 ||  // Cavlc444 profile
336         sps->profile_idc ==  83 ||  // Scalable Constrained High profile (SVC)
337         sps->profile_idc ==  86 ||  // Scalable High Intra profile (SVC)
338         sps->profile_idc == 118 ||  // Stereo High profile (MVC)
339         sps->profile_idc == 128 ||  // Multiview High profile (MVC)
340         sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
341         sps->profile_idc == 144) {  // old High444 profile
342         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
343         if (sps->chroma_format_idc > 3) {
344             avpriv_request_sample(h->avctx, "chroma_format_idc %u",
345                                   sps->chroma_format_idc);
346             goto fail;
347         } else if (sps->chroma_format_idc == 3) {
348             sps->residual_color_transform_flag = get_bits1(&h->gb);
349         }
350         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
351         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
352         if (sps->bit_depth_chroma != sps->bit_depth_luma) {
353             avpriv_request_sample(h->avctx,
354                                   "Different chroma and luma bit depth");
355             goto fail;
356         }
357         sps->transform_bypass = get_bits1(&h->gb);
358         decode_scaling_matrices(h, sps, NULL, 1,
359                                 sps->scaling_matrix4, sps->scaling_matrix8);
360     } else {
361         sps->chroma_format_idc = 1;
362         sps->bit_depth_luma    = 8;
363         sps->bit_depth_chroma  = 8;
364     }
365
366     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
367     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
368         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
369         av_log(h->avctx, AV_LOG_ERROR,
370                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
371                log2_max_frame_num_minus4);
372         goto fail;
373     }
374     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
375
376     sps->poc_type = get_ue_golomb_31(&h->gb);
377
378     if (sps->poc_type == 0) { // FIXME #define
379         sps->log2_max_poc_lsb = get_ue_golomb(&h->gb) + 4;
380     } else if (sps->poc_type == 1) { // FIXME #define
381         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
382         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
383         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
384         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
385
386         if ((unsigned)sps->poc_cycle_length >=
387             FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
388             av_log(h->avctx, AV_LOG_ERROR,
389                    "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
390             goto fail;
391         }
392
393         for (i = 0; i < sps->poc_cycle_length; i++)
394             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
395     } else if (sps->poc_type != 2) {
396         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
397         goto fail;
398     }
399
400     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
401     if (sps->ref_frame_count > MAX_PICTURE_COUNT - 2 ||
402         sps->ref_frame_count >= 32U) {
403         av_log(h->avctx, AV_LOG_ERROR,
404                "too many reference frames %d\n", sps->ref_frame_count);
405         goto fail;
406     }
407     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
408     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
409     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
410     if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
411         (unsigned)sps->mb_height >= INT_MAX / 16 ||
412         av_image_check_size(16 * sps->mb_width,
413                             16 * sps->mb_height, 0, h->avctx)) {
414         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
415         goto fail;
416     }
417
418     sps->frame_mbs_only_flag = get_bits1(&h->gb);
419     if (!sps->frame_mbs_only_flag)
420         sps->mb_aff = get_bits1(&h->gb);
421     else
422         sps->mb_aff = 0;
423
424     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
425     if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
426         av_log(h->avctx, AV_LOG_ERROR,
427                "This stream was generated by a broken encoder, invalid 8x8 inference\n");
428         goto fail;
429     }
430
431 #ifndef ALLOW_INTERLACE
432     if (sps->mb_aff)
433         av_log(h->avctx, AV_LOG_ERROR,
434                "MBAFF support not included; enable it at compile-time.\n");
435 #endif
436     sps->crop = get_bits1(&h->gb);
437     if (sps->crop) {
438         int crop_left   = get_ue_golomb(&h->gb);
439         int crop_right  = get_ue_golomb(&h->gb);
440         int crop_top    = get_ue_golomb(&h->gb);
441         int crop_bottom = get_ue_golomb(&h->gb);
442
443         if (h->avctx->flags2 & CODEC_FLAG2_IGNORE_CROP) {
444             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
445                                            "values are l:%u r:%u t:%u b:%u\n",
446                    crop_left, crop_right, crop_top, crop_bottom);
447
448             sps->crop_left   =
449             sps->crop_right  =
450             sps->crop_top    =
451             sps->crop_bottom = 0;
452         } else {
453             int vsub   = (sps->chroma_format_idc == 1) ? 1 : 0;
454             int hsub   = (sps->chroma_format_idc == 1 ||
455                           sps->chroma_format_idc == 2) ? 1 : 0;
456             int step_x = 1 << hsub;
457             int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
458
459             if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
460                 !(h->avctx->flags & CODEC_FLAG_UNALIGNED)) {
461                 crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
462                 av_log(h->avctx, AV_LOG_WARNING,
463                        "Reducing left cropping to %d "
464                        "chroma samples to preserve alignment.\n",
465                        crop_left);
466             }
467
468             sps->crop_left   = crop_left   * step_x;
469             sps->crop_right  = crop_right  * step_x;
470             sps->crop_top    = crop_top    * step_y;
471             sps->crop_bottom = crop_bottom * step_y;
472         }
473     } else {
474         sps->crop_left   =
475         sps->crop_right  =
476         sps->crop_top    =
477         sps->crop_bottom =
478         sps->crop        = 0;
479     }
480
481     sps->vui_parameters_present_flag = get_bits1(&h->gb);
482     if (sps->vui_parameters_present_flag) {
483         int ret = decode_vui_parameters(h, sps);
484         if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE)
485             goto fail;
486     }
487
488     if (!sps->sar.den)
489         sps->sar.den = 1;
490
491     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
492         static const char csp[4][5] = { "Gray", "420", "422", "444" };
493         av_log(h->avctx, AV_LOG_DEBUG,
494                "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
495                sps_id, sps->profile_idc, sps->level_idc,
496                sps->poc_type,
497                sps->ref_frame_count,
498                sps->mb_width, sps->mb_height,
499                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
500                sps->direct_8x8_inference_flag ? "8B8" : "",
501                sps->crop_left, sps->crop_right,
502                sps->crop_top, sps->crop_bottom,
503                sps->vui_parameters_present_flag ? "VUI" : "",
504                csp[sps->chroma_format_idc],
505                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
506                sps->timing_info_present_flag ? sps->time_scale : 0);
507     }
508     sps->new = 1;
509
510     av_free(h->sps_buffers[sps_id]);
511     h->sps_buffers[sps_id] = sps;
512     h->sps                 = *sps;
513
514     return 0;
515
516 fail:
517     av_free(sps);
518     return -1;
519 }
520
521 static void build_qp_table(PPS *pps, int t, int index, const int depth)
522 {
523     int i;
524     const int max_qp = 51 + 6 * (depth - 8);
525     for (i = 0; i < max_qp + 1; i++)
526         pps->chroma_qp_table[t][i] =
527             ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
528 }
529
530 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
531 {
532     unsigned int pps_id = get_ue_golomb(&h->gb);
533     PPS *pps;
534     const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
535     int bits_left;
536
537     if (pps_id >= MAX_PPS_COUNT) {
538         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
539         return AVERROR_INVALIDDATA;
540     } else if (h->sps.bit_depth_luma > 10) {
541         av_log(h->avctx, AV_LOG_ERROR,
542                "Unimplemented luma bit depth=%d (max=10)\n",
543                h->sps.bit_depth_luma);
544         return AVERROR_PATCHWELCOME;
545     }
546
547     pps = av_mallocz(sizeof(PPS));
548     if (!pps)
549         return AVERROR(ENOMEM);
550     pps->sps_id = get_ue_golomb_31(&h->gb);
551     if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
552         h->sps_buffers[pps->sps_id] == NULL) {
553         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
554         goto fail;
555     }
556
557     pps->cabac             = get_bits1(&h->gb);
558     pps->pic_order_present = get_bits1(&h->gb);
559     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
560     if (pps->slice_group_count > 1) {
561         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
562         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
563         switch (pps->mb_slice_group_map_type) {
564         case 0:
565 #if 0
566     |       for (i = 0; i <= num_slice_groups_minus1; i++)  |   |      |
567     |           run_length[i]                               |1  |ue(v) |
568 #endif
569             break;
570         case 2:
571 #if 0
572     |       for (i = 0; i < num_slice_groups_minus1; i++) { |   |      |
573     |           top_left_mb[i]                              |1  |ue(v) |
574     |           bottom_right_mb[i]                          |1  |ue(v) |
575     |       }                                               |   |      |
576 #endif
577             break;
578         case 3:
579         case 4:
580         case 5:
581 #if 0
582     |       slice_group_change_direction_flag               |1  |u(1)  |
583     |       slice_group_change_rate_minus1                  |1  |ue(v) |
584 #endif
585             break;
586         case 6:
587 #if 0
588     |       slice_group_id_cnt_minus1                       |1  |ue(v) |
589     |       for (i = 0; i <= slice_group_id_cnt_minus1; i++)|   |      |
590     |           slice_group_id[i]                           |1  |u(v)  |
591 #endif
592             break;
593         }
594     }
595     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
596     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
597     if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
598         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
599         goto fail;
600     }
601
602     pps->weighted_pred                        = get_bits1(&h->gb);
603     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
604     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
605     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
606     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
607     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
608     pps->constrained_intra_pred               = get_bits1(&h->gb);
609     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
610
611     pps->transform_8x8_mode = 0;
612     // contents of sps/pps can change even if id doesn't, so reinit
613     h->dequant_coeff_pps = -1;
614     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
615            sizeof(pps->scaling_matrix4));
616     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
617            sizeof(pps->scaling_matrix8));
618
619     bits_left = bit_length - get_bits_count(&h->gb);
620     if (bits_left && (bits_left > 8 ||
621                       show_bits(&h->gb, bits_left) != 1 << (bits_left - 1))) {
622         pps->transform_8x8_mode = get_bits1(&h->gb);
623         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
624                                 pps->scaling_matrix4, pps->scaling_matrix8);
625         // second_chroma_qp_index_offset
626         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
627     } else {
628         pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
629     }
630
631     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0],
632                    h->sps.bit_depth_luma);
633     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
634                    h->sps.bit_depth_luma);
635     if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
636         pps->chroma_qp_diff = 1;
637
638     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
639         av_log(h->avctx, AV_LOG_DEBUG,
640                "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
641                pps_id, pps->sps_id,
642                pps->cabac ? "CABAC" : "CAVLC",
643                pps->slice_group_count,
644                pps->ref_count[0], pps->ref_count[1],
645                pps->weighted_pred ? "weighted" : "",
646                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
647                pps->deblocking_filter_parameters_present ? "LPAR" : "",
648                pps->constrained_intra_pred ? "CONSTR" : "",
649                pps->redundant_pic_cnt_present ? "REDU" : "",
650                pps->transform_8x8_mode ? "8x8DCT" : "");
651     }
652
653     av_free(h->pps_buffers[pps_id]);
654     h->pps_buffers[pps_id] = pps;
655     return 0;
656
657 fail:
658     av_free(pps);
659     return -1;
660 }