FFmpeg: libavcodec/h264_ps.c Source File

00001 /*
00002  * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
00003  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00028 #include "libavutil/imgutils.h"
00029 #include "internal.h"
00030 #include "dsputil.h"
00031 #include "avcodec.h"
00032 #include "h264.h"
00033 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
00034 #include "golomb.h"
00035 
00036 
00037 //#undef NDEBUG
00038 #include <assert.h>
00039 
00040 #define MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
00041 #define MIN_LOG2_MAX_FRAME_NUM    4
00042 
00043 static const AVRational pixel_aspect[17]={
00044  {0, 1},
00045  {1, 1},
00046  {12, 11},
00047  {10, 11},
00048  {16, 11},
00049  {40, 33},
00050  {24, 11},
00051  {20, 11},
00052  {32, 11},
00053  {80, 33},
00054  {18, 11},
00055  {15, 11},
00056  {64, 33},
00057  {160,99},
00058  {4, 3},
00059  {3, 2},
00060  {2, 1},
00061 };
00062 
00063 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
00064 
00065 #define CHROMA_QP_TABLE_END(d) \
00066      QP(0,d),  QP(1,d),  QP(2,d),  QP(3,d),  QP(4,d),  QP(5,d),\
00067      QP(6,d),  QP(7,d),  QP(8,d),  QP(9,d), QP(10,d), QP(11,d),\
00068     QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
00069     QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
00070     QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
00071     QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
00072     QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
00073     QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
00074     QP(39,d), QP(39,d), QP(39,d), QP(39,d)
00075 
00076 const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM+1] = {
00077     {
00078         CHROMA_QP_TABLE_END(8)
00079     },
00080     {
00081         0, 1, 2, 3, 4, 5,
00082         CHROMA_QP_TABLE_END(9)
00083     },
00084     {
00085         0, 1, 2, 3,  4,  5,
00086         6, 7, 8, 9, 10, 11,
00087         CHROMA_QP_TABLE_END(10)
00088     },
00089     {
00090         0,  1, 2, 3,  4,  5,
00091         6,  7, 8, 9, 10, 11,
00092         12,13,14,15, 16, 17,
00093         CHROMA_QP_TABLE_END(11)
00094     },
00095     {
00096         0,  1, 2, 3,  4,  5,
00097         6,  7, 8, 9, 10, 11,
00098         12,13,14,15, 16, 17,
00099         18,19,20,21, 22, 23,
00100         CHROMA_QP_TABLE_END(12)
00101     },
00102     {
00103         0,  1, 2, 3,  4,  5,
00104         6,  7, 8, 9, 10, 11,
00105         12,13,14,15, 16, 17,
00106         18,19,20,21, 22, 23,
00107         24,25,26,27, 28, 29,
00108         CHROMA_QP_TABLE_END(13)
00109     },
00110     {
00111         0,  1, 2, 3,  4,  5,
00112         6,  7, 8, 9, 10, 11,
00113         12,13,14,15, 16, 17,
00114         18,19,20,21, 22, 23,
00115         24,25,26,27, 28, 29,
00116         30,31,32,33, 34, 35,
00117         CHROMA_QP_TABLE_END(14)
00118     },
00119 };
00120 
00121 static const uint8_t default_scaling4[2][16]={
00122 {   6,13,20,28,
00123    13,20,28,32,
00124    20,28,32,37,
00125    28,32,37,42
00126 },{
00127    10,14,20,24,
00128    14,20,24,27,
00129    20,24,27,30,
00130    24,27,30,34
00131 }};
00132 
00133 static const uint8_t default_scaling8[2][64]={
00134 {   6,10,13,16,18,23,25,27,
00135    10,11,16,18,23,25,27,29,
00136    13,16,18,23,25,27,29,31,
00137    16,18,23,25,27,29,31,33,
00138    18,23,25,27,29,31,33,36,
00139    23,25,27,29,31,33,36,38,
00140    25,27,29,31,33,36,38,40,
00141    27,29,31,33,36,38,40,42
00142 },{
00143     9,13,15,17,19,21,22,24,
00144    13,13,17,19,21,22,24,25,
00145    15,17,19,21,22,24,25,27,
00146    17,19,21,22,24,25,27,28,
00147    19,21,22,24,25,27,28,30,
00148    21,22,24,25,27,28,30,32,
00149    22,24,25,27,28,30,32,33,
00150    24,25,27,28,30,32,33,35
00151 }};
00152 
00153 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
00154     MpegEncContext * const s = &h->s;
00155     int cpb_count, i;
00156     cpb_count = get_ue_golomb_31(&s->gb) + 1;
00157 
00158     if(cpb_count > 32U){
00159         av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
00160         return -1;
00161     }
00162 
00163     get_bits(&s->gb, 4); /* bit_rate_scale */
00164     get_bits(&s->gb, 4); /* cpb_size_scale */
00165     for(i=0; i<cpb_count; i++){
00166         get_ue_golomb_long(&s->gb); /* bit_rate_value_minus1 */
00167         get_ue_golomb_long(&s->gb); /* cpb_size_value_minus1 */
00168         get_bits1(&s->gb);     /* cbr_flag */
00169     }
00170     sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
00171     sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
00172     sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
00173     sps->time_offset_length = get_bits(&s->gb, 5);
00174     sps->cpb_cnt = cpb_count;
00175     return 0;
00176 }
00177 
00178 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
00179     MpegEncContext * const s = &h->s;
00180     int aspect_ratio_info_present_flag;
00181     unsigned int aspect_ratio_idc;
00182 
00183     aspect_ratio_info_present_flag= get_bits1(&s->gb);
00184 
00185     if( aspect_ratio_info_present_flag ) {
00186         aspect_ratio_idc= get_bits(&s->gb, 8);
00187         if( aspect_ratio_idc == EXTENDED_SAR ) {
00188             sps->sar.num= get_bits(&s->gb, 16);
00189             sps->sar.den= get_bits(&s->gb, 16);
00190         }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
00191             sps->sar=  pixel_aspect[aspect_ratio_idc];
00192         }else{
00193             av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
00194             return -1;
00195         }
00196     }else{
00197         sps->sar.num=
00198         sps->sar.den= 0;
00199     }
00200 //            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
00201 
00202     if(get_bits1(&s->gb)){      /* overscan_info_present_flag */
00203         get_bits1(&s->gb);      /* overscan_appropriate_flag */
00204     }
00205 
00206     sps->video_signal_type_present_flag = get_bits1(&s->gb);
00207     if(sps->video_signal_type_present_flag){
00208         get_bits(&s->gb, 3);    /* video_format */
00209         sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
00210 
00211         sps->colour_description_present_flag = get_bits1(&s->gb);
00212         if(sps->colour_description_present_flag){
00213             sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
00214             sps->color_trc       = get_bits(&s->gb, 8); /* transfer_characteristics */
00215             sps->colorspace      = get_bits(&s->gb, 8); /* matrix_coefficients */
00216             if (sps->color_primaries >= AVCOL_PRI_NB)
00217                 sps->color_primaries  = AVCOL_PRI_UNSPECIFIED;
00218             if (sps->color_trc >= AVCOL_TRC_NB)
00219                 sps->color_trc  = AVCOL_TRC_UNSPECIFIED;
00220             if (sps->colorspace >= AVCOL_SPC_NB)
00221                 sps->colorspace  = AVCOL_SPC_UNSPECIFIED;
00222         }
00223     }
00224 
00225     if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */
00226         s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1;  /* chroma_sample_location_type_top_field */
00227         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */
00228     }
00229 
00230     sps->timing_info_present_flag = get_bits1(&s->gb);
00231     if(sps->timing_info_present_flag){
00232         sps->num_units_in_tick = get_bits_long(&s->gb, 32);
00233         sps->time_scale = get_bits_long(&s->gb, 32);
00234         if(!sps->num_units_in_tick || !sps->time_scale){
00235             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);
00236             return -1;
00237         }
00238         sps->fixed_frame_rate_flag = get_bits1(&s->gb);
00239     }
00240 
00241     sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
00242     if(sps->nal_hrd_parameters_present_flag)
00243         if(decode_hrd_parameters(h, sps) < 0)
00244             return -1;
00245     sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
00246     if(sps->vcl_hrd_parameters_present_flag)
00247         if(decode_hrd_parameters(h, sps) < 0)
00248             return -1;
00249     if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
00250         get_bits1(&s->gb);     /* low_delay_hrd_flag */
00251     sps->pic_struct_present_flag = get_bits1(&s->gb);
00252     if(!get_bits_left(&s->gb))
00253         return 0;
00254     sps->bitstream_restriction_flag = get_bits1(&s->gb);
00255     if(sps->bitstream_restriction_flag){
00256         get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
00257         get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
00258         get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
00259         get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
00260         get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
00261         sps->num_reorder_frames= get_ue_golomb(&s->gb);
00262         get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
00263 
00264         if (get_bits_left(&s->gb) < 0) {
00265             sps->num_reorder_frames=0;
00266             sps->bitstream_restriction_flag= 0;
00267         }
00268 
00269         if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
00270             av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
00271             return -1;
00272         }
00273     }
00274 
00275     if (get_bits_left(&s->gb) < 0) {
00276         av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
00277         return AVERROR_INVALIDDATA;
00278     }
00279 
00280     return 0;
00281 }
00282 
00283 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
00284                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
00285     MpegEncContext * const s = &h->s;
00286     int i, last = 8, next = 8;
00287     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
00288     if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
00289         memcpy(factors, fallback_list, size*sizeof(uint8_t));
00290     else
00291     for(i=0;i<size;i++){
00292         if(next)
00293             next = (last + get_se_golomb(&s->gb)) & 0xff;
00294         if(!i && !next){ /* matrix not written, we use the preset one */
00295             memcpy(factors, jvt_list, size*sizeof(uint8_t));
00296             break;
00297         }
00298         last = factors[scan[i]] = next ? next : last;
00299     }
00300 }
00301 
00302 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
00303                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
00304     MpegEncContext * const s = &h->s;
00305     int fallback_sps = !is_sps && sps->scaling_matrix_present;
00306     const uint8_t *fallback[4] = {
00307         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
00308         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
00309         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
00310         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
00311     };
00312     if(get_bits1(&s->gb)){
00313         sps->scaling_matrix_present |= is_sps;
00314         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
00315         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
00316         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
00317         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
00318         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
00319         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
00320         if(is_sps || pps->transform_8x8_mode){
00321             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
00322             decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);  // Inter, Y
00323             if(sps->chroma_format_idc == 3){
00324                 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);  // Intra, Cr
00325                 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);  // Inter, Cr
00326                 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);  // Intra, Cb
00327                 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
00328             }
00329         }
00330     }
00331 }
00332 
00333 int ff_h264_decode_seq_parameter_set(H264Context *h){
00334     MpegEncContext * const s = &h->s;
00335     int profile_idc, level_idc, constraint_set_flags = 0;
00336     unsigned int sps_id;
00337     int i, log2_max_frame_num_minus4;
00338     SPS *sps;
00339 
00340     profile_idc= get_bits(&s->gb, 8);
00341     constraint_set_flags |= get_bits1(&s->gb) << 0;   //constraint_set0_flag
00342     constraint_set_flags |= get_bits1(&s->gb) << 1;   //constraint_set1_flag
00343     constraint_set_flags |= get_bits1(&s->gb) << 2;   //constraint_set2_flag
00344     constraint_set_flags |= get_bits1(&s->gb) << 3;   //constraint_set3_flag
00345     constraint_set_flags |= get_bits1(&s->gb) << 4;   //constraint_set4_flag
00346     constraint_set_flags |= get_bits1(&s->gb) << 5;   //constraint_set5_flag
00347     get_bits(&s->gb, 2); // reserved
00348     level_idc= get_bits(&s->gb, 8);
00349     sps_id= get_ue_golomb_31(&s->gb);
00350 
00351     if(sps_id >= MAX_SPS_COUNT) {
00352         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
00353         return -1;
00354     }
00355     sps= av_mallocz(sizeof(SPS));
00356     if(sps == NULL)
00357         return -1;
00358 
00359     sps->time_offset_length = 24;
00360     sps->profile_idc= profile_idc;
00361     sps->constraint_set_flags = constraint_set_flags;
00362     sps->level_idc= level_idc;
00363     sps->full_range = -1;
00364 
00365     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
00366     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
00367     sps->scaling_matrix_present = 0;
00368     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
00369 
00370     if(sps->profile_idc == 100 || sps->profile_idc == 110 ||
00371        sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc ==  44 ||
00372        sps->profile_idc ==  83 || sps->profile_idc ==  86 || sps->profile_idc == 118 ||
00373        sps->profile_idc == 128 || sps->profile_idc == 144) {
00374         sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
00375         if (sps->chroma_format_idc > 3U) {
00376             av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
00377             goto fail;
00378         } else if(sps->chroma_format_idc == 3) {
00379             sps->residual_color_transform_flag = get_bits1(&s->gb);
00380             if(sps->residual_color_transform_flag) {
00381                 av_log(h->s.avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
00382                 goto fail;
00383             }
00384         }
00385         sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
00386         sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
00387         if (sps->bit_depth_luma > 14U || sps->bit_depth_chroma > 14U) {
00388             av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
00389                    sps->bit_depth_luma, sps->bit_depth_chroma);
00390             goto fail;
00391         }
00392         sps->transform_bypass = get_bits1(&s->gb);
00393         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
00394     }else{
00395         sps->chroma_format_idc= 1;
00396         sps->bit_depth_luma   = 8;
00397         sps->bit_depth_chroma = 8;
00398     }
00399 
00400     log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
00401     if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
00402         log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
00403         av_log(h->s.avctx, AV_LOG_ERROR,
00404                "log2_max_frame_num_minus4 out of range (0-12): %d\n",
00405                log2_max_frame_num_minus4);
00406         goto fail;
00407     }
00408     sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
00409 
00410     sps->poc_type= get_ue_golomb_31(&s->gb);
00411 
00412     if(sps->poc_type == 0){ //FIXME #define
00413         unsigned t = get_ue_golomb(&s->gb);
00414         if(t>12){
00415             av_log(h->s.avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
00416             goto fail;
00417         }
00418         sps->log2_max_poc_lsb= t + 4;
00419     } else if(sps->poc_type == 1){//FIXME #define
00420         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
00421         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
00422         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
00423         sps->poc_cycle_length                = get_ue_golomb(&s->gb);
00424 
00425         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
00426             av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
00427             goto fail;
00428         }
00429 
00430         for(i=0; i<sps->poc_cycle_length; i++)
00431             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
00432     }else if(sps->poc_type != 2){
00433         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
00434         goto fail;
00435     }
00436 
00437     sps->ref_frame_count= get_ue_golomb_31(&s->gb);
00438     if (h->s.avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
00439         sps->ref_frame_count= FFMAX(2, sps->ref_frame_count);
00440     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
00441         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
00442         goto fail;
00443     }
00444     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
00445     sps->mb_width = get_ue_golomb(&s->gb) + 1;
00446     sps->mb_height= get_ue_golomb(&s->gb) + 1;
00447     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
00448        av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
00449         av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
00450         goto fail;
00451     }
00452 
00453     sps->frame_mbs_only_flag= get_bits1(&s->gb);
00454     if(!sps->frame_mbs_only_flag)
00455         sps->mb_aff= get_bits1(&s->gb);
00456     else
00457         sps->mb_aff= 0;
00458 
00459     sps->direct_8x8_inference_flag= get_bits1(&s->gb);
00460 
00461 #ifndef ALLOW_INTERLACE
00462     if(sps->mb_aff)
00463         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
00464 #endif
00465     sps->crop= get_bits1(&s->gb);
00466     if(sps->crop){
00467         int crop_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
00468         int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00469         sps->crop_left  = get_ue_golomb(&s->gb);
00470         sps->crop_right = get_ue_golomb(&s->gb);
00471         sps->crop_top   = get_ue_golomb(&s->gb);
00472         sps->crop_bottom= get_ue_golomb(&s->gb);
00473         if(sps->crop_left || sps->crop_top){
00474             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);
00475         }
00476         if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
00477             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);
00478         /* It is very unlikely that partial cropping will make anybody happy.
00479          * Not cropping at all fixes for example playback of Sisvel 3D streams
00480          * in applications supporting Sisvel 3D. */
00481         sps->crop_left  =
00482         sps->crop_right =
00483         sps->crop_top   =
00484         sps->crop_bottom= 0;
00485         }
00486     }else{
00487         sps->crop_left  =
00488         sps->crop_right =
00489         sps->crop_top   =
00490         sps->crop_bottom= 0;
00491     }
00492 
00493     sps->vui_parameters_present_flag= get_bits1(&s->gb);
00494     if( sps->vui_parameters_present_flag )
00495         if (decode_vui_parameters(h, sps) < 0)
00496             goto fail;
00497 
00498     if(!sps->sar.den)
00499         sps->sar.den= 1;
00500 
00501     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00502         static const char csp[4][5] = { "Gray", "420", "422", "444" };
00503         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",
00504                sps_id, sps->profile_idc, sps->level_idc,
00505                sps->poc_type,
00506                sps->ref_frame_count,
00507                sps->mb_width, sps->mb_height,
00508                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00509                sps->direct_8x8_inference_flag ? "8B8" : "",
00510                sps->crop_left, sps->crop_right,
00511                sps->crop_top, sps->crop_bottom,
00512                sps->vui_parameters_present_flag ? "VUI" : "",
00513                csp[sps->chroma_format_idc],
00514                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00515                sps->timing_info_present_flag ? sps->time_scale : 0,
00516                sps->bit_depth_luma,
00517                h->sps.bitstream_restriction_flag ? sps->num_reorder_frames : -1
00518                );
00519     }
00520     sps->new = 1;
00521 
00522     av_free(h->sps_buffers[sps_id]);
00523     h->sps_buffers[sps_id] = sps;
00524     h->sps                 = *sps;
00525     h->current_sps_id      = sps_id;
00526 
00527     return 0;
00528 fail:
00529     av_free(sps);
00530     return -1;
00531 }
00532 
00533 static void
00534 build_qp_table(PPS *pps, int t, int index, const int depth)
00535 {
00536     int i;
00537     const int max_qp = 51 + 6*(depth-8);
00538     for(i = 0; i < max_qp+1; i++)
00539         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00540 }
00541 
00542 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
00543 {
00544     const SPS *sps = h->sps_buffers[pps->sps_id];
00545     int profile_idc = sps->profile_idc;
00546 
00547     if ((profile_idc == 66 || profile_idc == 77 ||
00548          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
00549         av_log(h->s.avctx, AV_LOG_VERBOSE,
00550                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
00551         return 0;
00552     }
00553 
00554     return 1;
00555 }
00556 
00557 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00558     MpegEncContext * const s = &h->s;
00559     unsigned int pps_id= get_ue_golomb(&s->gb);
00560     PPS *pps;
00561     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00562     int bits_left;
00563 
00564     if(pps_id >= MAX_PPS_COUNT) {
00565         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00566         return -1;
00567     } else if (h->sps.bit_depth_luma > 14) {
00568         av_log(h->s.avctx, AV_LOG_ERROR, "Invalid luma bit depth=%d\n", h->sps.bit_depth_luma);
00569         return AVERROR_INVALIDDATA;
00570     } else if (h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13) {
00571         av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d\n", h->sps.bit_depth_luma);
00572         return AVERROR_PATCHWELCOME;
00573     }
00574 
00575     pps= av_mallocz(sizeof(PPS));
00576     if(pps == NULL)
00577         return -1;
00578     pps->sps_id= get_ue_golomb_31(&s->gb);
00579     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00580         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00581         goto fail;
00582     }
00583 
00584     pps->cabac= get_bits1(&s->gb);
00585     pps->pic_order_present= get_bits1(&s->gb);
00586     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00587     if(pps->slice_group_count > 1 ){
00588         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00589         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00590         switch(pps->mb_slice_group_map_type){
00591         case 0:
00592 #if 0
00593 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00594 |    run_length[ i ]                                |1  |ue(v)   |
00595 #endif
00596             break;
00597         case 2:
00598 #if 0
00599 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00600 |{                                                  |   |        |
00601 |    top_left_mb[ i ]                               |1  |ue(v)   |
00602 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00603 |   }                                               |   |        |
00604 #endif
00605             break;
00606         case 3:
00607         case 4:
00608         case 5:
00609 #if 0
00610 |   slice_group_change_direction_flag               |1  |u(1)    |
00611 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00612 #endif
00613             break;
00614         case 6:
00615 #if 0
00616 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00617 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00618 |)                                                  |   |        |
00619 |    slice_group_id[ i ]                            |1  |u(v)    |
00620 #endif
00621             break;
00622         }
00623     }
00624     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00625     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00626     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00627         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00628         goto fail;
00629     }
00630 
00631     pps->weighted_pred= get_bits1(&s->gb);
00632     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00633     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00634     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00635     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00636     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00637     pps->constrained_intra_pred= get_bits1(&s->gb);
00638     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00639 
00640     pps->transform_8x8_mode= 0;
00641     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00642     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00643     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00644 
00645     bits_left = bit_length - get_bits_count(&s->gb);
00646     if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
00647         pps->transform_8x8_mode= get_bits1(&s->gb);
00648         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00649         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00650     } else {
00651         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00652     }
00653 
00654     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00655     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00656     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00657         pps->chroma_qp_diff= 1;
00658 
00659     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00660         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",
00661                pps_id, pps->sps_id,
00662                pps->cabac ? "CABAC" : "CAVLC",
00663                pps->slice_group_count,
00664                pps->ref_count[0], pps->ref_count[1],
00665                pps->weighted_pred ? "weighted" : "",
00666                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00667                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00668                pps->constrained_intra_pred ? "CONSTR" : "",
00669                pps->redundant_pic_cnt_present ? "REDU" : "",
00670                pps->transform_8x8_mode ? "8x8DCT" : ""
00671                );
00672     }
00673 
00674     av_free(h->pps_buffers[pps_id]);
00675     h->pps_buffers[pps_id]= pps;
00676     return 0;
00677 fail:
00678     av_free(pps);
00679     return -1;
00680 }