00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
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"
00034 #include "golomb.h"
00035
00036
00037
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);
00147 get_bits(&s->gb, 4);
00148 for(i=0; i<cpb_count; i++){
00149 get_ue_golomb_long(&s->gb);
00150 get_ue_golomb_long(&s->gb);
00151 get_bits1(&s->gb);
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
00184
00185 if(get_bits1(&s->gb)){
00186 get_bits1(&s->gb);
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);
00192 sps->full_range = get_bits1(&s->gb);
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);
00197 sps->color_trc = get_bits(&s->gb, 8);
00198 sps->colorspace = get_bits(&s->gb, 8);
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)){
00209 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1;
00210 get_ue_golomb(&s->gb);
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);
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);
00239 get_ue_golomb(&s->gb);
00240 get_ue_golomb(&s->gb);
00241 get_ue_golomb(&s->gb);
00242 get_ue_golomb(&s->gb);
00243 sps->num_reorder_frames= get_ue_golomb(&s->gb);
00244 get_ue_golomb(&s->gb);
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 ){
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))
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){
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]);
00293 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]);
00294 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]);
00295 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]);
00296 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]);
00297 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]);
00298 if(is_sps || pps->transform_8x8_mode){
00299 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);
00300 if(sps->chroma_format_idc == 3){
00301 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);
00302 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);
00303 }
00304 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);
00305 if(sps->chroma_format_idc == 3){
00306 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);
00307 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);
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;
00322 constraint_set_flags |= get_bits1(&s->gb) << 1;
00323 constraint_set_flags |= get_bits1(&s->gb) << 2;
00324 constraint_set_flags |= get_bits1(&s->gb) << 3;
00325 get_bits(&s->gb, 4);
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){
00386 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00387 } else if(sps->poc_type == 1){
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;
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);
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 }