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

Generated on Fri Feb 22 2013 07:24:26 for FFmpeg by  doxygen 1.7.1