FFmpeg: libavcodec/h264_ps.c Source File

00001 /*
00002  * H.26L/H.264/AVC/JVT/14496-10/... parameter set decoding
00003  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00028 #include "libavutil/imgutils.h"
00029 #include "internal.h"
00030 #include "dsputil.h"
00031 #include "avcodec.h"
00032 #include "h264.h"
00033 #include "h264data.h" //FIXME FIXME FIXME (just for zigzag_scan)
00034 #include "golomb.h"
00035 
00036 
00037 //#undef NDEBUG
00038 #include <assert.h>
00039 
00040 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         } else if(sps->chroma_format_idc == 3) {
00349             sps->residual_color_transform_flag = get_bits1(&s->gb);
00350         }
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     } else if (h->sps.bit_depth_luma > 10) {
00494         av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
00495         return AVERROR_PATCHWELCOME;
00496     }
00497 
00498     pps= av_mallocz(sizeof(PPS));
00499     if(pps == NULL)
00500         return -1;
00501     pps->sps_id= get_ue_golomb_31(&s->gb);
00502     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00503         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00504         goto fail;
00505     }
00506 
00507     pps->cabac= get_bits1(&s->gb);
00508     pps->pic_order_present= get_bits1(&s->gb);
00509     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00510     if(pps->slice_group_count > 1 ){
00511         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00512         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00513         switch(pps->mb_slice_group_map_type){
00514         case 0:
00515 #if 0
00516 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00517 |    run_length[ i ]                                |1  |ue(v)   |
00518 #endif
00519             break;
00520         case 2:
00521 #if 0
00522 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00523 |{                                                  |   |        |
00524 |    top_left_mb[ i ]                               |1  |ue(v)   |
00525 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00526 |   }                                               |   |        |
00527 #endif
00528             break;
00529         case 3:
00530         case 4:
00531         case 5:
00532 #if 0
00533 |   slice_group_change_direction_flag               |1  |u(1)    |
00534 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00535 #endif
00536             break;
00537         case 6:
00538 #if 0
00539 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00540 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00541 |)                                                  |   |        |
00542 |    slice_group_id[ i ]                            |1  |u(v)    |
00543 #endif
00544             break;
00545         }
00546     }
00547     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00548     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00549     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00550         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00551         goto fail;
00552     }
00553 
00554     pps->weighted_pred= get_bits1(&s->gb);
00555     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00556     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00557     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00558     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00559     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00560     pps->constrained_intra_pred= get_bits1(&s->gb);
00561     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00562 
00563     pps->transform_8x8_mode= 0;
00564     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00565     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00566     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00567 
00568     bits_left = bit_length - get_bits_count(&s->gb);
00569     if (bits_left && (bits_left > 8 ||
00570                       show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
00571         pps->transform_8x8_mode= get_bits1(&s->gb);
00572         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00573         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00574     } else {
00575         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00576     }
00577 
00578     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00579     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00580     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00581         pps->chroma_qp_diff= 1;
00582 
00583     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00584         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",
00585                pps_id, pps->sps_id,
00586                pps->cabac ? "CABAC" : "CAVLC",
00587                pps->slice_group_count,
00588                pps->ref_count[0], pps->ref_count[1],
00589                pps->weighted_pred ? "weighted" : "",
00590                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00591                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00592                pps->constrained_intra_pred ? "CONSTR" : "",
00593                pps->redundant_pic_cnt_present ? "REDU" : "",
00594                pps->transform_8x8_mode ? "8x8DCT" : ""
00595                );
00596     }
00597 
00598     av_free(h->pps_buffers[pps_id]);
00599     h->pps_buffers[pps_id]= pps;
00600     return 0;
00601 fail:
00602     av_free(pps);
00603     return -1;
00604 }