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