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