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