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