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     if(!get_bits_left(&s->gb))
00233         return 0;
00234     sps->bitstream_restriction_flag = get_bits1(&s->gb);
00235     if(sps->bitstream_restriction_flag){
00236         get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
00237         get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
00238         get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
00239         get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
00240         get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
00241         sps->num_reorder_frames= get_ue_golomb(&s->gb);
00242         get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
00243 
00244         if (get_bits_left(&s->gb) < 0) {
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     if (get_bits_left(&s->gb) < 0) {
00256         av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
00257         return AVERROR_INVALIDDATA;
00258     }
00259 
00260     return 0;
00261 }
00262 
00263 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
00264                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
00265     MpegEncContext * const s = &h->s;
00266     int i, last = 8, next = 8;
00267     const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
00268     if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
00269         memcpy(factors, fallback_list, size*sizeof(uint8_t));
00270     else
00271     for(i=0;i<size;i++){
00272         if(next)
00273             next = (last + get_se_golomb(&s->gb)) & 0xff;
00274         if(!i && !next){ /* matrix not written, we use the preset one */
00275             memcpy(factors, jvt_list, size*sizeof(uint8_t));
00276             break;
00277         }
00278         last = factors[scan[i]] = next ? next : last;
00279     }
00280 }
00281 
00282 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
00283                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
00284     MpegEncContext * const s = &h->s;
00285     int fallback_sps = !is_sps && sps->scaling_matrix_present;
00286     const uint8_t *fallback[4] = {
00287         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
00288         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
00289         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
00290         fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
00291     };
00292     if(get_bits1(&s->gb)){
00293         sps->scaling_matrix_present |= is_sps;
00294         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
00295         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
00296         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
00297         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
00298         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
00299         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
00300         if(is_sps || pps->transform_8x8_mode){
00301             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
00302             if(sps->chroma_format_idc == 3){
00303                 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);  // Intra, Cr
00304                 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);  // Intra, Cb
00305             }
00306             decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);  // Inter, Y
00307             if(sps->chroma_format_idc == 3){
00308                 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);  // Inter, Cr
00309                 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);  // Inter, Cb
00310             }
00311         }
00312     }
00313 }
00314 
00315 int ff_h264_decode_seq_parameter_set(H264Context *h){
00316     MpegEncContext * const s = &h->s;
00317     int profile_idc, level_idc, constraint_set_flags = 0;
00318     unsigned int sps_id;
00319     int i;
00320     SPS *sps;
00321 
00322     profile_idc= get_bits(&s->gb, 8);
00323     constraint_set_flags |= get_bits1(&s->gb) << 0;   //constraint_set0_flag
00324     constraint_set_flags |= get_bits1(&s->gb) << 1;   //constraint_set1_flag
00325     constraint_set_flags |= get_bits1(&s->gb) << 2;   //constraint_set2_flag
00326     constraint_set_flags |= get_bits1(&s->gb) << 3;   //constraint_set3_flag
00327     get_bits(&s->gb, 4); // reserved
00328     level_idc= get_bits(&s->gb, 8);
00329     sps_id= get_ue_golomb_31(&s->gb);
00330 
00331     if(sps_id >= MAX_SPS_COUNT) {
00332         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
00333         return -1;
00334     }
00335     sps= av_mallocz(sizeof(SPS));
00336     if(sps == NULL)
00337         return -1;
00338 
00339     sps->time_offset_length = 24;
00340     sps->profile_idc= profile_idc;
00341     sps->constraint_set_flags = constraint_set_flags;
00342     sps->level_idc= level_idc;
00343     sps->full_range = -1;
00344 
00345     memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
00346     memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
00347     sps->scaling_matrix_present = 0;
00348     sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
00349 
00350     if(sps->profile_idc >= 100){ //high profile
00351         sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
00352         if (sps->chroma_format_idc > 3U) {
00353             av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc %d is illegal\n", sps->chroma_format_idc);
00354             goto fail;
00355         } else if(sps->chroma_format_idc == 3) {
00356             sps->residual_color_transform_flag = get_bits1(&s->gb);
00357         }
00358         sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
00359         sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
00360         if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {
00361             av_log(h->s.avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
00362                    sps->bit_depth_luma, sps->bit_depth_chroma);
00363             goto fail;
00364         }
00365         sps->transform_bypass = get_bits1(&s->gb);
00366         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
00367     }else{
00368         sps->chroma_format_idc= 1;
00369         sps->bit_depth_luma   = 8;
00370         sps->bit_depth_chroma = 8;
00371     }
00372 
00373     sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
00374     if (sps->log2_max_frame_num < 4 || sps->log2_max_frame_num > 16) {
00375         av_log(h->s.avctx, AV_LOG_ERROR, "illegal log2_max_frame_num %d\n",
00376                sps->log2_max_frame_num);
00377         goto fail;
00378     }
00379 
00380     sps->poc_type= get_ue_golomb_31(&s->gb);
00381 
00382     if(sps->poc_type == 0){ //FIXME #define
00383         sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00384     } else if(sps->poc_type == 1){//FIXME #define
00385         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
00386         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
00387         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
00388         sps->poc_cycle_length                = get_ue_golomb(&s->gb);
00389 
00390         if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
00391             av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
00392             goto fail;
00393         }
00394 
00395         for(i=0; i<sps->poc_cycle_length; i++)
00396             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
00397     }else if(sps->poc_type != 2){
00398         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
00399         goto fail;
00400     }
00401 
00402     sps->ref_frame_count= get_ue_golomb_31(&s->gb);
00403     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
00404         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
00405         goto fail;
00406     }
00407     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
00408     sps->mb_width = get_ue_golomb(&s->gb) + 1;
00409     sps->mb_height= get_ue_golomb(&s->gb) + 1;
00410     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
00411        av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
00412         av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
00413         goto fail;
00414     }
00415 
00416     sps->frame_mbs_only_flag= get_bits1(&s->gb);
00417     if(!sps->frame_mbs_only_flag)
00418         sps->mb_aff= get_bits1(&s->gb);
00419     else
00420         sps->mb_aff= 0;
00421 
00422     sps->direct_8x8_inference_flag= get_bits1(&s->gb);
00423 
00424 #ifndef ALLOW_INTERLACE
00425     if(sps->mb_aff)
00426         av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
00427 #endif
00428     sps->crop= get_bits1(&s->gb);
00429     if(sps->crop){
00430         int crop_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
00431         int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00432         sps->crop_left  = get_ue_golomb(&s->gb);
00433         sps->crop_right = get_ue_golomb(&s->gb);
00434         sps->crop_top   = get_ue_golomb(&s->gb);
00435         sps->crop_bottom= get_ue_golomb(&s->gb);
00436         if(sps->crop_left || sps->crop_top){
00437             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ... (left: %d, top: %d)\n", sps->crop_left, sps->crop_top);
00438         }
00439         if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
00440             av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
00441         /* It is very unlikely that partial cropping will make anybody happy.
00442          * Not cropping at all fixes for example playback of Sisvel 3D streams
00443          * in applications supporting Sisvel 3D. */
00444         sps->crop_left  =
00445         sps->crop_right =
00446         sps->crop_top   =
00447         sps->crop_bottom= 0;
00448         }
00449     }else{
00450         sps->crop_left  =
00451         sps->crop_right =
00452         sps->crop_top   =
00453         sps->crop_bottom= 0;
00454     }
00455 
00456     sps->vui_parameters_present_flag= get_bits1(&s->gb);
00457     if( sps->vui_parameters_present_flag )
00458         if (decode_vui_parameters(h, sps) < 0)
00459             goto fail;
00460 
00461     if(!sps->sar.den)
00462         sps->sar.den= 1;
00463 
00464     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00465         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",
00466                sps_id, sps->profile_idc, sps->level_idc,
00467                sps->poc_type,
00468                sps->ref_frame_count,
00469                sps->mb_width, sps->mb_height,
00470                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00471                sps->direct_8x8_inference_flag ? "8B8" : "",
00472                sps->crop_left, sps->crop_right,
00473                sps->crop_top, sps->crop_bottom,
00474                sps->vui_parameters_present_flag ? "VUI" : "",
00475                ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00476                sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00477                sps->timing_info_present_flag ? sps->time_scale : 0,
00478                sps->bit_depth_luma
00479                );
00480     }
00481 
00482     av_free(h->sps_buffers[sps_id]);
00483     h->sps_buffers[sps_id]= sps;
00484     h->sps = *sps;
00485     return 0;
00486 fail:
00487     av_free(sps);
00488     return -1;
00489 }
00490 
00491 static void
00492 build_qp_table(PPS *pps, int t, int index, const int depth)
00493 {
00494     int i;
00495     const int max_qp = 51 + 6*(depth-8);
00496     for(i = 0; i < max_qp+1; i++)
00497         pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00498 }
00499 
00500 static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
00501 {
00502     const SPS *sps = h->sps_buffers[pps->sps_id];
00503     int profile_idc = sps->profile_idc;
00504 
00505     if ((profile_idc == 66 || profile_idc == 77 ||
00506          profile_idc == 88) && (sps->constraint_set_flags & 7)) {
00507         av_log(h->s.avctx, AV_LOG_VERBOSE,
00508                "Current profile doesn't provide more RBSP data in PPS, skipping\n");
00509         return 0;
00510     }
00511 
00512     return 1;
00513 }
00514 
00515 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00516     MpegEncContext * const s = &h->s;
00517     unsigned int pps_id= get_ue_golomb(&s->gb);
00518     PPS *pps;
00519     const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00520     int bits_left;
00521 
00522     if(pps_id >= MAX_PPS_COUNT) {
00523         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00524         return -1;
00525     } else if (h->sps.bit_depth_luma > 10) {
00526         av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
00527         return AVERROR_PATCHWELCOME;
00528     }
00529 
00530     pps= av_mallocz(sizeof(PPS));
00531     if(pps == NULL)
00532         return -1;
00533     pps->sps_id= get_ue_golomb_31(&s->gb);
00534     if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00535         av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00536         goto fail;
00537     }
00538 
00539     pps->cabac= get_bits1(&s->gb);
00540     pps->pic_order_present= get_bits1(&s->gb);
00541     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00542     if(pps->slice_group_count > 1 ){
00543         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00544         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00545         switch(pps->mb_slice_group_map_type){
00546         case 0:
00547 #if 0
00548 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
00549 |    run_length[ i ]                                |1  |ue(v)   |
00550 #endif
00551             break;
00552         case 2:
00553 #if 0
00554 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
00555 |{                                                  |   |        |
00556 |    top_left_mb[ i ]                               |1  |ue(v)   |
00557 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
00558 |   }                                               |   |        |
00559 #endif
00560             break;
00561         case 3:
00562         case 4:
00563         case 5:
00564 #if 0
00565 |   slice_group_change_direction_flag               |1  |u(1)    |
00566 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
00567 #endif
00568             break;
00569         case 6:
00570 #if 0
00571 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
00572 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
00573 |)                                                  |   |        |
00574 |    slice_group_id[ i ]                            |1  |u(v)    |
00575 #endif
00576             break;
00577         }
00578     }
00579     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00580     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00581     if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00582         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00583         goto fail;
00584     }
00585 
00586     pps->weighted_pred= get_bits1(&s->gb);
00587     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00588     pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00589     pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00590     pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00591     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00592     pps->constrained_intra_pred= get_bits1(&s->gb);
00593     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00594 
00595     pps->transform_8x8_mode= 0;
00596     h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
00597     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00598     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00599 
00600     bits_left = bit_length - get_bits_count(&s->gb);
00601     if(bits_left > 0 && more_rbsp_data_in_pps(h, pps)){
00602         pps->transform_8x8_mode= get_bits1(&s->gb);
00603         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00604         pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
00605     } else {
00606         pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00607     }
00608 
00609     build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00610     build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00611     if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00612         pps->chroma_qp_diff= 1;
00613 
00614     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00615         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",
00616                pps_id, pps->sps_id,
00617                pps->cabac ? "CABAC" : "CAVLC",
00618                pps->slice_group_count,
00619                pps->ref_count[0], pps->ref_count[1],
00620                pps->weighted_pred ? "weighted" : "",
00621                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00622                pps->deblocking_filter_parameters_present ? "LPAR" : "",
00623                pps->constrained_intra_pred ? "CONSTR" : "",
00624                pps->redundant_pic_cnt_present ? "REDU" : "",
00625                pps->transform_8x8_mode ? "8x8DCT" : ""
00626                );
00627     }
00628 
00629     av_free(h->pps_buffers[pps_id]);
00630     h->pps_buffers[pps_id]= pps;
00631     return 0;
00632 fail:
00633     av_free(pps);
00634     return -1;
00635 }