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