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_long(&s->gb); /* bit_rate_value_minus1 */
00134         get_ue_golomb_long(&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             av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
00334             return -1;
00335         } else if(sps->chroma_format_idc == 3) {
00336             sps->residual_color_transform_flag = get_bits1(&s->gb);
00337         }
00338         sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
00339         sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
00340         sps->transform_bypass = get_bits1(&s->gb);
00341         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
00342     }else{
00343         sps->chroma_format_idc= 1;
00344         sps->bit_depth_luma   = 8;
00345         sps->bit_depth_chroma = 8;
00346     }
00347 
00348     sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
00349     sps->poc_type= get_ue_golomb_31(&s->gb);
00350 
00351     if(sps->poc_type == 0){ //FIXME #define
00352         sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00353     } else if(sps->poc_type == 1){//FIXME #define
00354         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
00355         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
00356         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
00357         sps->poc_cycle_length                = get_ue_golomb(&s->gb);
00358 
00359         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
00360             av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
00361             goto fail;
00362         }
00363 
00364         for(i=0; i<sps->poc_cycle_length; i++)
00365             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
00366     }else if(sps->poc_type != 2){
00367         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
00368         goto fail;
00369     }
00370 
00371     sps->ref_frame_count= get_ue_golomb_31(&s->gb);
00372     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
00373         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
00374         goto fail;
00375     }
00376     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
00377     sps->mb_width = get_ue_golomb(&s->gb) + 1;
00378     sps->mb_height= get_ue_golomb(&s->gb) + 1;
00379     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
00380        av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
00381         av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
00382         goto fail;
00383     }
00384 
00385     sps->frame_mbs_only_flag= get_bits1(&s->gb);
00386     if(!sps->frame_mbs_only_flag)
00387         sps->mb_aff= get_bits1(&s->gb);
00388     else
00389         sps->mb_aff= 0;
00390 
00391     sps->direct_8x8_inference_flag= get_bits1(&s->gb);
00392     if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
00393         av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
00394         goto fail;
00395     }
00396 
00397 #ifndef ALLOW_INTERLACE
00398     if(sps->mb_aff)
00399         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
00400 #endif
00401     sps->crop= get_bits1(&s->gb);
00402     if(sps->crop){
00403         int crop_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00404         sps->crop_left  = get_ue_golomb(&s->gb);
00405         sps->crop_right = get_ue_golomb(&s->gb);
00406         sps->crop_top   = get_ue_golomb(&s->gb);
00407         sps->crop_bottom= get_ue_golomb(&s->gb);
00408         if(sps->crop_left || sps->crop_top){
00409             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
00410         }
00411         if(sps->crop_right >= crop_limit || sps->crop_bottom >= crop_limit){
00412             av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
00413         }
00414     }else{
00415         sps->crop_left  =
00416         sps->crop_right =
00417         sps->crop_top   =
00418         sps->crop_bottom= 0;
00419     }
00420 
00421     sps->vui_parameters_present_flag= get_bits1(&s->gb);
00422     if( sps->vui_parameters_present_flag )
00423         if (decode_vui_parameters(h, sps) < 0)
00424             goto fail;
00425 
00426     if(!sps->sar.den)
00427         sps->sar.den= 1;
00428 
00429     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00430         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",
00431                sps_id, sps->profile_idc, sps->level_idc,
00432                sps->poc_type,
00433                sps->ref_frame_count,
00434                sps->mb_width, sps->mb_height,
00435                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00436                sps->direct_8x8_inference_flag ? "8B8" : "",
00437                sps->crop_left, sps->crop_right,
00438                sps->crop_top, sps->crop_bottom,
00439                sps->vui_parameters_present_flag ? "VUI" : "",
00440                ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00441                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00442                sps->timing_info_present_flag ? sps->time_scale : 0
00443                );
00444     }
00445 
00446     av_free(h->sps_buffers[sps_id]);
00447     h->sps_buffers[sps_id]= sps;
00448     h->sps = *sps;
00449     return 0;
00450 fail:
00451     av_free(sps);
00452     return -1;
00453 }
00454 
00455 static void
00456 build_qp_table(PPS *pps, int t, int index, const int depth)
00457 {
00458     int i;
00459     const int max_qp = 51 + 6*(depth-8);
00460     for(i = 0; i < max_qp+1; i++)
00461         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00462 }
00463 
00464 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00465     MpegEncContext * const s = &h->s;
00466     unsigned int pps_id= get_ue_golomb(&s->gb);
00467     PPS *pps;
00468     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00469     int bits_left;
00470 
00471     if(pps_id >= MAX_PPS_COUNT) {
00472         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00473         return -1;
00474     } else if (h->sps.bit_depth_luma > 10) {
00475         av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
00476         return AVERROR_PATCHWELCOME;
00477     }
00478 
00479     pps= av_mallocz(sizeof(PPS));
00480     if(pps == NULL)
00481         return -1;
00482     pps->sps_id= get_ue_golomb_31(&s->gb);
00483     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00484         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00485         goto fail;
00486     }
00487 
00488     pps->cabac= get_bits1(&s->gb);
00489     pps->pic_order_present= get_bits1(&s->gb);
00490     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00491     if(pps->slice_group_count > 1 ){
00492         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00493         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00494         switch(pps->mb_slice_group_map_type){
00495         case 0:
00496 #if 0
00497 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00498 |    run_length[ i ]                                |1  |ue(v)   |
00499 #endif
00500             break;
00501         case 2:
00502 #if 0
00503 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00504 |{                                                  |   |        |
00505 |    top_left_mb[ i ]                               |1  |ue(v)   |
00506 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00507 |   }                                               |   |        |
00508 #endif
00509             break;
00510         case 3:
00511         case 4:
00512         case 5:
00513 #if 0
00514 |   slice_group_change_direction_flag               |1  |u(1)    |
00515 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00516 #endif
00517             break;
00518         case 6:
00519 #if 0
00520 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00521 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00522 |)                                                  |   |        |
00523 |    slice_group_id[ i ]                            |1  |u(v)    |
00524 #endif
00525             break;
00526         }
00527     }
00528     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00529     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00530     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00531         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00532         goto fail;
00533     }
00534 
00535     pps->weighted_pred= get_bits1(&s->gb);
00536     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00537     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00538     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00539     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00540     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00541     pps->constrained_intra_pred= get_bits1(&s->gb);
00542     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00543 
00544     pps->transform_8x8_mode= 0;
00545     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00546     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00547     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00548 
00549     bits_left = bit_length - get_bits_count(&s->gb);
00550     if (bits_left && (bits_left > 8 ||
00551                       show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
00552         pps->transform_8x8_mode= get_bits1(&s->gb);
00553         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00554         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00555     } else {
00556         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00557     }
00558 
00559     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00560     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00561     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00562         pps->chroma_qp_diff= 1;
00563 
00564     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00565         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",
00566                pps_id, pps->sps_id,
00567                pps->cabac ? "CABAC" : "CAVLC",
00568                pps->slice_group_count,
00569                pps->ref_count[0], pps->ref_count[1],
00570                pps->weighted_pred ? "weighted" : "",
00571                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00572                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00573                pps->constrained_intra_pred ? "CONSTR" : "",
00574                pps->redundant_pic_cnt_present ? "REDU" : "",
00575                pps->transform_8x8_mode ? "8x8DCT" : ""
00576                );
00577     }
00578 
00579     av_free(h->pps_buffers[pps_id]);
00580     h->pps_buffers[pps_id]= pps;
00581     return 0;
00582 fail:
00583     av_free(pps);
00584     return -1;
00585 }