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