• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

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             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_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
00400         int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00401         sps->crop_left  = get_ue_golomb(&s->gb);
00402         sps->crop_right = get_ue_golomb(&s->gb);
00403         sps->crop_top   = get_ue_golomb(&s->gb);
00404         sps->crop_bottom= get_ue_golomb(&s->gb);
00405         if(sps->crop_left || sps->crop_top){
00406             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
00407         }
00408         if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
00409             av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
00410         }
00411     }else{
00412         sps->crop_left  =
00413         sps->crop_right =
00414         sps->crop_top   =
00415         sps->crop_bottom= 0;
00416     }
00417 
00418     sps->vui_parameters_present_flag= get_bits1(&s->gb);
00419     if( sps->vui_parameters_present_flag )
00420         if (decode_vui_parameters(h, sps) < 0)
00421             goto fail;
00422 
00423     if(!sps->sar.den)
00424         sps->sar.den= 1;
00425 
00426     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00427         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",
00428                sps_id, sps->profile_idc, sps->level_idc,
00429                sps->poc_type,
00430                sps->ref_frame_count,
00431                sps->mb_width, sps->mb_height,
00432                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00433                sps->direct_8x8_inference_flag ? "8B8" : "",
00434                sps->crop_left, sps->crop_right,
00435                sps->crop_top, sps->crop_bottom,
00436                sps->vui_parameters_present_flag ? "VUI" : "",
00437                ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00438                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00439                sps->timing_info_present_flag ? sps->time_scale : 0
00440                );
00441     }
00442 
00443     av_free(h->sps_buffers[sps_id]);
00444     h->sps_buffers[sps_id]= sps;
00445     h->sps = *sps;
00446     return 0;
00447 fail:
00448     av_free(sps);
00449     return -1;
00450 }
00451 
00452 static void
00453 build_qp_table(PPS *pps, int t, int index, const int depth)
00454 {
00455     int i;
00456     const int max_qp = 51 + 6*(depth-8);
00457     for(i = 0; i < max_qp+1; i++)
00458         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00459 }
00460 
00461 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00462     MpegEncContext * const s = &h->s;
00463     unsigned int pps_id= get_ue_golomb(&s->gb);
00464     PPS *pps;
00465     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00466     int bits_left;
00467 
00468     if(pps_id >= MAX_PPS_COUNT) {
00469         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00470         return -1;
00471     }
00472 
00473     pps= av_mallocz(sizeof(PPS));
00474     if(pps == NULL)
00475         return -1;
00476     pps->sps_id= get_ue_golomb_31(&s->gb);
00477     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00478         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00479         goto fail;
00480     }
00481 
00482     pps->cabac= get_bits1(&s->gb);
00483     pps->pic_order_present= get_bits1(&s->gb);
00484     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00485     if(pps->slice_group_count > 1 ){
00486         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00487         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00488         switch(pps->mb_slice_group_map_type){
00489         case 0:
00490 #if 0
00491 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00492 |    run_length[ i ]                                |1  |ue(v)   |
00493 #endif
00494             break;
00495         case 2:
00496 #if 0
00497 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00498 |{                                                  |   |        |
00499 |    top_left_mb[ i ]                               |1  |ue(v)   |
00500 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00501 |   }                                               |   |        |
00502 #endif
00503             break;
00504         case 3:
00505         case 4:
00506         case 5:
00507 #if 0
00508 |   slice_group_change_direction_flag               |1  |u(1)    |
00509 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00510 #endif
00511             break;
00512         case 6:
00513 #if 0
00514 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00515 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00516 |)                                                  |   |        |
00517 |    slice_group_id[ i ]                            |1  |u(v)    |
00518 #endif
00519             break;
00520         }
00521     }
00522     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00523     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00524     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00525         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00526         goto fail;
00527     }
00528 
00529     pps->weighted_pred= get_bits1(&s->gb);
00530     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00531     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00532     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00533     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00534     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00535     pps->constrained_intra_pred= get_bits1(&s->gb);
00536     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00537 
00538     pps->transform_8x8_mode= 0;
00539     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00540     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00541     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00542 
00543     bits_left = bit_length - get_bits_count(&s->gb);
00544     if (bits_left && (bits_left > 8 ||
00545                       show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
00546         pps->transform_8x8_mode= get_bits1(&s->gb);
00547         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00548         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00549     } else {
00550         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00551     }
00552 
00553     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00554     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00555     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00556         pps->chroma_qp_diff= 1;
00557 
00558     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00559         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",
00560                pps_id, pps->sps_id,
00561                pps->cabac ? "CABAC" : "CAVLC",
00562                pps->slice_group_count,
00563                pps->ref_count[0], pps->ref_count[1],
00564                pps->weighted_pred ? "weighted" : "",
00565                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00566                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00567                pps->constrained_intra_pred ? "CONSTR" : "",
00568                pps->redundant_pic_cnt_present ? "REDU" : "",
00569                pps->transform_8x8_mode ? "8x8DCT" : ""
00570                );
00571     }
00572 
00573     av_free(h->pps_buffers[pps_id]);
00574     h->pps_buffers[pps_id]= pps;
00575     return 0;
00576 fail:
00577     av_free(pps);
00578     return -1;
00579 }
Generated on Sat Mar 17 2012 12:57:45 for Libav by doxygen 1.7.1