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