Libav 0.7.1
libavcodec/h264_ps.c
Go to the documentation of this 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 Libav.
00006  *
00007  * Libav 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  * Libav 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 Libav; 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 static const AVRational pixel_aspect[17]={
00041  {0, 1},
00042  {1, 1},
00043  {12, 11},
00044  {10, 11},
00045  {16, 11},
00046  {40, 33},
00047  {24, 11},
00048  {20, 11},
00049  {32, 11},
00050  {80, 33},
00051  {18, 11},
00052  {15, 11},
00053  {64, 33},
00054  {160,99},
00055  {4, 3},
00056  {3, 2},
00057  {2, 1},
00058 };
00059 
00060 #define QP(qP,depth) ( (qP)+6*((depth)-8) )
00061 
00062 #define CHROMA_QP_TABLE_END(d) \
00063      QP(0,d),  QP(1,d),  QP(2,d),  QP(3,d),  QP(4,d),  QP(5,d),\
00064      QP(6,d),  QP(7,d),  QP(8,d),  QP(9,d), QP(10,d), QP(11,d),\
00065     QP(12,d), QP(13,d), QP(14,d), QP(15,d), QP(16,d), QP(17,d),\
00066     QP(18,d), QP(19,d), QP(20,d), QP(21,d), QP(22,d), QP(23,d),\
00067     QP(24,d), QP(25,d), QP(26,d), QP(27,d), QP(28,d), QP(29,d),\
00068     QP(29,d), QP(30,d), QP(31,d), QP(32,d), QP(32,d), QP(33,d),\
00069     QP(34,d), QP(34,d), QP(35,d), QP(35,d), QP(36,d), QP(36,d),\
00070     QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
00071     QP(39,d), QP(39,d), QP(39,d), QP(39,d)
00072 
00073 const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM+1] = {
00074     {
00075         CHROMA_QP_TABLE_END(8)
00076     },
00077     {
00078         0, 1, 2, 3, 4, 5,
00079         CHROMA_QP_TABLE_END(9)
00080     },
00081     {
00082         0, 1, 2, 3,  4,  5,
00083         6, 7, 8, 9, 10, 11,
00084         CHROMA_QP_TABLE_END(10)
00085     },
00086 };
00087 
00088 static const uint8_t default_scaling4[2][16]={
00089 {   6,13,20,28,
00090    13,20,28,32,
00091    20,28,32,37,
00092    28,32,37,42
00093 },{
00094    10,14,20,24,
00095    14,20,24,27,
00096    20,24,27,30,
00097    24,27,30,34
00098 }};
00099 
00100 static const uint8_t default_scaling8[2][64]={
00101 {   6,10,13,16,18,23,25,27,
00102    10,11,16,18,23,25,27,29,
00103    13,16,18,23,25,27,29,31,
00104    16,18,23,25,27,29,31,33,
00105    18,23,25,27,29,31,33,36,
00106    23,25,27,29,31,33,36,38,
00107    25,27,29,31,33,36,38,40,
00108    27,29,31,33,36,38,40,42
00109 },{
00110     9,13,15,17,19,21,22,24,
00111    13,13,17,19,21,22,24,25,
00112    15,17,19,21,22,24,25,27,
00113    17,19,21,22,24,25,27,28,
00114    19,21,22,24,25,27,28,30,
00115    21,22,24,25,27,28,30,32,
00116    22,24,25,27,28,30,32,33,
00117    24,25,27,28,30,32,33,35
00118 }};
00119 
00120 static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
00121     MpegEncContext * const s = &h->s;
00122     int cpb_count, i;
00123     cpb_count = get_ue_golomb_31(&s->gb) + 1;
00124 
00125     if(cpb_count > 32U){
00126         av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
00127         return -1;
00128     }
00129 
00130     get_bits(&s->gb, 4); /* bit_rate_scale */
00131     get_bits(&s->gb, 4); /* cpb_size_scale */
00132     for(i=0; i<cpb_count; i++){
00133         get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
00134         get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
00135         get_bits1(&s->gb);     /* cbr_flag */
00136     }
00137     sps->initial_cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
00138     sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
00139     sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
00140     sps->time_offset_length = get_bits(&s->gb, 5);
00141     sps->cpb_cnt = cpb_count;
00142     return 0;
00143 }
00144 
00145 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
00146     MpegEncContext * const s = &h->s;
00147     int aspect_ratio_info_present_flag;
00148     unsigned int aspect_ratio_idc;
00149 
00150     aspect_ratio_info_present_flag= get_bits1(&s->gb);
00151 
00152     if( aspect_ratio_info_present_flag ) {
00153         aspect_ratio_idc= get_bits(&s->gb, 8);
00154         if( aspect_ratio_idc == EXTENDED_SAR ) {
00155             sps->sar.num= get_bits(&s->gb, 16);
00156             sps->sar.den= get_bits(&s->gb, 16);
00157         }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
00158             sps->sar=  pixel_aspect[aspect_ratio_idc];
00159         }else{
00160             av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
00161             return -1;
00162         }
00163     }else{
00164         sps->sar.num=
00165         sps->sar.den= 0;
00166     }
00167 //            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
00168 
00169     if(get_bits1(&s->gb)){      /* overscan_info_present_flag */
00170         get_bits1(&s->gb);      /* overscan_appropriate_flag */
00171     }
00172 
00173     sps->video_signal_type_present_flag = get_bits1(&s->gb);
00174     if(sps->video_signal_type_present_flag){
00175         get_bits(&s->gb, 3);    /* video_format */
00176         sps->full_range = get_bits1(&s->gb); /* video_full_range_flag */
00177 
00178         sps->colour_description_present_flag = get_bits1(&s->gb);
00179         if(sps->colour_description_present_flag){
00180             sps->color_primaries = get_bits(&s->gb, 8); /* colour_primaries */
00181             sps->color_trc       = get_bits(&s->gb, 8); /* transfer_characteristics */
00182             sps->colorspace      = get_bits(&s->gb, 8); /* matrix_coefficients */
00183             if (sps->color_primaries >= AVCOL_PRI_NB)
00184                 sps->color_primaries  = AVCOL_PRI_UNSPECIFIED;
00185             if (sps->color_trc >= AVCOL_TRC_NB)
00186                 sps->color_trc  = AVCOL_TRC_UNSPECIFIED;
00187             if (sps->colorspace >= AVCOL_SPC_NB)
00188                 sps->colorspace  = AVCOL_SPC_UNSPECIFIED;
00189         }
00190     }
00191 
00192     if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */
00193         s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1;  /* chroma_sample_location_type_top_field */
00194         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */
00195     }
00196 
00197     sps->timing_info_present_flag = get_bits1(&s->gb);
00198     if(sps->timing_info_present_flag){
00199         sps->num_units_in_tick = get_bits_long(&s->gb, 32);
00200         sps->time_scale = get_bits_long(&s->gb, 32);
00201         if(!sps->num_units_in_tick || !sps->time_scale){
00202             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);
00203             return -1;
00204         }
00205         sps->fixed_frame_rate_flag = get_bits1(&s->gb);
00206     }
00207 
00208     sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
00209     if(sps->nal_hrd_parameters_present_flag)
00210         if(decode_hrd_parameters(h, sps) < 0)
00211             return -1;
00212     sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
00213     if(sps->vcl_hrd_parameters_present_flag)
00214         if(decode_hrd_parameters(h, sps) < 0)
00215             return -1;
00216     if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
00217         get_bits1(&s->gb);     /* low_delay_hrd_flag */
00218     sps->pic_struct_present_flag = get_bits1(&s->gb);
00219 
00220     sps->bitstream_restriction_flag = get_bits1(&s->gb);
00221     if(sps->bitstream_restriction_flag){
00222         get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
00223         get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
00224         get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
00225         get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
00226         get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
00227         sps->num_reorder_frames= get_ue_golomb(&s->gb);
00228         get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
00229 
00230         if(s->gb.size_in_bits < get_bits_count(&s->gb)){
00231             av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
00232             sps->num_reorder_frames=0;
00233             sps->bitstream_restriction_flag= 0;
00234         }
00235 
00236         if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
00237             av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
00238             return -1;
00239         }
00240     }
00241 
00242     return 0;
00243 }
00244 
00245 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
00246                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
00247     MpegEncContext * const s = &h->s;
00248     int i, last = 8, next = 8;
00249     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
00250     if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
00251         memcpy(factors, fallback_list, size*sizeof(uint8_t));
00252     else
00253     for(i=0;i<size;i++){
00254         if(next)
00255             next = (last + get_se_golomb(&s->gb)) & 0xff;
00256         if(!i && !next){ /* matrix not written, we use the preset one */
00257             memcpy(factors, jvt_list, size*sizeof(uint8_t));
00258             break;
00259         }
00260         last = factors[scan[i]] = next ? next : last;
00261     }
00262 }
00263 
00264 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
00265                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
00266     MpegEncContext * const s = &h->s;
00267     int fallback_sps = !is_sps && sps->scaling_matrix_present;
00268     const uint8_t *fallback[4] = {
00269         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
00270         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
00271         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
00272         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
00273     };
00274     if(get_bits1(&s->gb)){
00275         sps->scaling_matrix_present |= is_sps;
00276         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
00277         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
00278         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
00279         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
00280         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
00281         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
00282         if(is_sps || pps->transform_8x8_mode){
00283             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
00284             if(sps->chroma_format_idc == 3){
00285                 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);  // Intra, Cr
00286                 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);  // Intra, Cb
00287             }
00288             decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);  // Inter, Y
00289             if(sps->chroma_format_idc == 3){
00290                 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);  // Inter, Cr
00291                 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
00292             }
00293         }
00294     }
00295 }
00296 
00297 int ff_h264_decode_seq_parameter_set(H264Context *h){
00298     MpegEncContext * const s = &h->s;
00299     int profile_idc, level_idc, constraint_set_flags = 0;
00300     unsigned int sps_id;
00301     int i;
00302     SPS *sps;
00303 
00304     profile_idc= get_bits(&s->gb, 8);
00305     constraint_set_flags |= get_bits1(&s->gb) << 0;   //constraint_set0_flag
00306     constraint_set_flags |= get_bits1(&s->gb) << 1;   //constraint_set1_flag
00307     constraint_set_flags |= get_bits1(&s->gb) << 2;   //constraint_set2_flag
00308     constraint_set_flags |= get_bits1(&s->gb) << 3;   //constraint_set3_flag
00309     get_bits(&s->gb, 4); // reserved
00310     level_idc= get_bits(&s->gb, 8);
00311     sps_id= get_ue_golomb_31(&s->gb);
00312 
00313     if(sps_id >= MAX_SPS_COUNT) {
00314         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
00315         return -1;
00316     }
00317     sps= av_mallocz(sizeof(SPS));
00318     if(sps == NULL)
00319         return -1;
00320 
00321     sps->time_offset_length = 24;
00322     sps->profile_idc= profile_idc;
00323     sps->constraint_set_flags = constraint_set_flags;
00324     sps->level_idc= level_idc;
00325 
00326     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
00327     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
00328     sps->scaling_matrix_present = 0;
00329 
00330     if(sps->profile_idc >= 100){ //high profile
00331         sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
00332         if(sps->chroma_format_idc == 3)
00333             sps->residual_color_transform_flag = get_bits1(&s->gb);
00334         sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
00335         sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
00336         sps->transform_bypass = get_bits1(&s->gb);
00337         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
00338     }else{
00339         sps->chroma_format_idc= 1;
00340         sps->bit_depth_luma   = 8;
00341         sps->bit_depth_chroma = 8;
00342     }
00343 
00344     sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
00345     sps->poc_type= get_ue_golomb_31(&s->gb);
00346 
00347     if(sps->poc_type == 0){ //FIXME #define
00348         sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00349     } else if(sps->poc_type == 1){//FIXME #define
00350         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
00351         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
00352         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
00353         sps->poc_cycle_length                = get_ue_golomb(&s->gb);
00354 
00355         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
00356             av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
00357             goto fail;
00358         }
00359 
00360         for(i=0; i<sps->poc_cycle_length; i++)
00361             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
00362     }else if(sps->poc_type != 2){
00363         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
00364         goto fail;
00365     }
00366 
00367     sps->ref_frame_count= get_ue_golomb_31(&s->gb);
00368     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
00369         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
00370         goto fail;
00371     }
00372     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
00373     sps->mb_width = get_ue_golomb(&s->gb) + 1;
00374     sps->mb_height= get_ue_golomb(&s->gb) + 1;
00375     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
00376        av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
00377         av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
00378         goto fail;
00379     }
00380 
00381     sps->frame_mbs_only_flag= get_bits1(&s->gb);
00382     if(!sps->frame_mbs_only_flag)
00383         sps->mb_aff= get_bits1(&s->gb);
00384     else
00385         sps->mb_aff= 0;
00386 
00387     sps->direct_8x8_inference_flag= get_bits1(&s->gb);
00388     if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
00389         av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
00390         goto fail;
00391     }
00392 
00393 #ifndef ALLOW_INTERLACE
00394     if(sps->mb_aff)
00395         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
00396 #endif
00397     sps->crop= get_bits1(&s->gb);
00398     if(sps->crop){
00399         int crop_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00400         sps->crop_left  = get_ue_golomb(&s->gb);
00401         sps->crop_right = get_ue_golomb(&s->gb);
00402         sps->crop_top   = get_ue_golomb(&s->gb);
00403         sps->crop_bottom= get_ue_golomb(&s->gb);
00404         if(sps->crop_left || sps->crop_top){
00405             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
00406         }
00407         if(sps->crop_right >= crop_limit || sps->crop_bottom >= crop_limit){
00408             av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
00409         }
00410     }else{
00411         sps->crop_left  =
00412         sps->crop_right =
00413         sps->crop_top   =
00414         sps->crop_bottom= 0;
00415     }
00416 
00417     sps->vui_parameters_present_flag= get_bits1(&s->gb);
00418     if( sps->vui_parameters_present_flag )
00419         if (decode_vui_parameters(h, sps) < 0)
00420             goto fail;
00421 
00422     if(!sps->sar.den)
00423         sps->sar.den= 1;
00424 
00425     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00426         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\n",
00427                sps_id, sps->profile_idc, sps->level_idc,
00428                sps->poc_type,
00429                sps->ref_frame_count,
00430                sps->mb_width, sps->mb_height,
00431                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00432                sps->direct_8x8_inference_flag ? "8B8" : "",
00433                sps->crop_left, sps->crop_right,
00434                sps->crop_top, sps->crop_bottom,
00435                sps->vui_parameters_present_flag ? "VUI" : "",
00436                ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00437                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00438                sps->timing_info_present_flag ? sps->time_scale : 0
00439                );
00440     }
00441 
00442     av_free(h->sps_buffers[sps_id]);
00443     h->sps_buffers[sps_id]= sps;
00444     h->sps = *sps;
00445     return 0;
00446 fail:
00447     av_free(sps);
00448     return -1;
00449 }
00450 
00451 static void
00452 build_qp_table(PPS *pps, int t, int index, const int depth)
00453 {
00454     int i;
00455     const int max_qp = 51 + 6*(depth-8);
00456     for(i = 0; i < max_qp+1; i++)
00457         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00458 }
00459 
00460 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00461     MpegEncContext * const s = &h->s;
00462     unsigned int pps_id= get_ue_golomb(&s->gb);
00463     PPS *pps;
00464     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00465 
00466     if(pps_id >= MAX_PPS_COUNT) {
00467         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00468         return -1;
00469     }
00470 
00471     pps= av_mallocz(sizeof(PPS));
00472     if(pps == NULL)
00473         return -1;
00474     pps->sps_id= get_ue_golomb_31(&s->gb);
00475     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00476         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00477         goto fail;
00478     }
00479 
00480     pps->cabac= get_bits1(&s->gb);
00481     pps->pic_order_present= get_bits1(&s->gb);
00482     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00483     if(pps->slice_group_count > 1 ){
00484         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00485         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00486         switch(pps->mb_slice_group_map_type){
00487         case 0:
00488 #if 0
00489 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00490 |    run_length[ i ]                                |1  |ue(v)   |
00491 #endif
00492             break;
00493         case 2:
00494 #if 0
00495 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00496 |{                                                  |   |        |
00497 |    top_left_mb[ i ]                               |1  |ue(v)   |
00498 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00499 |   }                                               |   |        |
00500 #endif
00501             break;
00502         case 3:
00503         case 4:
00504         case 5:
00505 #if 0
00506 |   slice_group_change_direction_flag               |1  |u(1)    |
00507 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00508 #endif
00509             break;
00510         case 6:
00511 #if 0
00512 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00513 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00514 |)                                                  |   |        |
00515 |    slice_group_id[ i ]                            |1  |u(v)    |
00516 #endif
00517             break;
00518         }
00519     }
00520     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00521     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00522     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00523         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00524         goto fail;
00525     }
00526 
00527     pps->weighted_pred= get_bits1(&s->gb);
00528     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00529     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00530     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00531     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00532     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00533     pps->constrained_intra_pred= get_bits1(&s->gb);
00534     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00535 
00536     pps->transform_8x8_mode= 0;
00537     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00538     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00539     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00540 
00541     if(get_bits_count(&s->gb) < bit_length){
00542         pps->transform_8x8_mode= get_bits1(&s->gb);
00543         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00544         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00545     } else {
00546         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00547     }
00548 
00549     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00550     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00551     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00552         pps->chroma_qp_diff= 1;
00553 
00554     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00555         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",
00556                pps_id, pps->sps_id,
00557                pps->cabac ? "CABAC" : "CAVLC",
00558                pps->slice_group_count,
00559                pps->ref_count[0], pps->ref_count[1],
00560                pps->weighted_pred ? "weighted" : "",
00561                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00562                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00563                pps->constrained_intra_pred ? "CONSTR" : "",
00564                pps->redundant_pic_cnt_present ? "REDU" : "",
00565                pps->transform_8x8_mode ? "8x8DCT" : ""
00566                );
00567     }
00568 
00569     av_free(h->pps_buffers[pps_id]);
00570     h->pps_buffers[pps_id]= pps;
00571     return 0;
00572 fail:
00573     av_free(pps);
00574     return -1;
00575 }