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