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

Generated on Wed Apr 11 2012 07:31:33 for FFmpeg by  doxygen 1.7.1