• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/h264_ps.c

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