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