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 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);
00131 get_bits(&s->gb, 4);
00132 for(i=0; i<cpb_count; i++){
00133 get_ue_golomb_long(&s->gb);
00134 get_ue_golomb_long(&s->gb);
00135 get_bits1(&s->gb);
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
00168
00169 if(get_bits1(&s->gb)){
00170 get_bits1(&s->gb);
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);
00176 sps->full_range = get_bits1(&s->gb);
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);
00181 sps->color_trc = get_bits(&s->gb, 8);
00182 sps->colorspace = get_bits(&s->gb, 8);
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)){
00193 s->avctx->chroma_sample_location = get_ue_golomb(&s->gb)+1;
00194 get_ue_golomb(&s->gb);
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);
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);
00223 get_ue_golomb(&s->gb);
00224 get_ue_golomb(&s->gb);
00225 get_ue_golomb(&s->gb);
00226 get_ue_golomb(&s->gb);
00227 sps->num_reorder_frames= get_ue_golomb(&s->gb);
00228 get_ue_golomb(&s->gb);
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 ){
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))
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){
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]);
00277 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]);
00278 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]);
00279 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]);
00280 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]);
00281 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]);
00282 if(is_sps || pps->transform_8x8_mode){
00283 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);
00284 if(sps->chroma_format_idc == 3){
00285 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);
00286 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);
00287 }
00288 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);
00289 if(sps->chroma_format_idc == 3){
00290 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);
00291 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);
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;
00306 constraint_set_flags |= get_bits1(&s->gb) << 1;
00307 constraint_set_flags |= get_bits1(&s->gb) << 2;
00308 constraint_set_flags |= get_bits1(&s->gb) << 3;
00309 get_bits(&s->gb, 4);
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){
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){
00348 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00349 } else if(sps->poc_type == 1){
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_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
00400 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00401 sps->crop_left = get_ue_golomb(&s->gb);
00402 sps->crop_right = get_ue_golomb(&s->gb);
00403 sps->crop_top = get_ue_golomb(&s->gb);
00404 sps->crop_bottom= get_ue_golomb(&s->gb);
00405 if(sps->crop_left || sps->crop_top){
00406 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
00407 }
00408 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
00409 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
00410 }
00411 }else{
00412 sps->crop_left =
00413 sps->crop_right =
00414 sps->crop_top =
00415 sps->crop_bottom= 0;
00416 }
00417
00418 sps->vui_parameters_present_flag= get_bits1(&s->gb);
00419 if( sps->vui_parameters_present_flag )
00420 if (decode_vui_parameters(h, sps) < 0)
00421 goto fail;
00422
00423 if(!sps->sar.den)
00424 sps->sar.den= 1;
00425
00426 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00427 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",
00428 sps_id, sps->profile_idc, sps->level_idc,
00429 sps->poc_type,
00430 sps->ref_frame_count,
00431 sps->mb_width, sps->mb_height,
00432 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00433 sps->direct_8x8_inference_flag ? "8B8" : "",
00434 sps->crop_left, sps->crop_right,
00435 sps->crop_top, sps->crop_bottom,
00436 sps->vui_parameters_present_flag ? "VUI" : "",
00437 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00438 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00439 sps->timing_info_present_flag ? sps->time_scale : 0
00440 );
00441 }
00442
00443 av_free(h->sps_buffers[sps_id]);
00444 h->sps_buffers[sps_id]= sps;
00445 h->sps = *sps;
00446 return 0;
00447 fail:
00448 av_free(sps);
00449 return -1;
00450 }
00451
00452 static void
00453 build_qp_table(PPS *pps, int t, int index, const int depth)
00454 {
00455 int i;
00456 const int max_qp = 51 + 6*(depth-8);
00457 for(i = 0; i < max_qp+1; i++)
00458 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00459 }
00460
00461 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00462 MpegEncContext * const s = &h->s;
00463 unsigned int pps_id= get_ue_golomb(&s->gb);
00464 PPS *pps;
00465 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00466 int bits_left;
00467
00468 if(pps_id >= MAX_PPS_COUNT) {
00469 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00470 return -1;
00471 }
00472
00473 pps= av_mallocz(sizeof(PPS));
00474 if(pps == NULL)
00475 return -1;
00476 pps->sps_id= get_ue_golomb_31(&s->gb);
00477 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00478 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00479 goto fail;
00480 }
00481
00482 pps->cabac= get_bits1(&s->gb);
00483 pps->pic_order_present= get_bits1(&s->gb);
00484 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00485 if(pps->slice_group_count > 1 ){
00486 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00487 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00488 switch(pps->mb_slice_group_map_type){
00489 case 0:
00490 #if 0
00491 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
00492 | run_length[ i ] |1 |ue(v) |
00493 #endif
00494 break;
00495 case 2:
00496 #if 0
00497 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
00498 |{ | | |
00499 | top_left_mb[ i ] |1 |ue(v) |
00500 | bottom_right_mb[ i ] |1 |ue(v) |
00501 | } | | |
00502 #endif
00503 break;
00504 case 3:
00505 case 4:
00506 case 5:
00507 #if 0
00508 | slice_group_change_direction_flag |1 |u(1) |
00509 | slice_group_change_rate_minus1 |1 |ue(v) |
00510 #endif
00511 break;
00512 case 6:
00513 #if 0
00514 | slice_group_id_cnt_minus1 |1 |ue(v) |
00515 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
00516 |) | | |
00517 | slice_group_id[ i ] |1 |u(v) |
00518 #endif
00519 break;
00520 }
00521 }
00522 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00523 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00524 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00525 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00526 goto fail;
00527 }
00528
00529 pps->weighted_pred= get_bits1(&s->gb);
00530 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00531 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00532 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00533 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00534 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00535 pps->constrained_intra_pred= get_bits1(&s->gb);
00536 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00537
00538 pps->transform_8x8_mode= 0;
00539 h->dequant_coeff_pps= -1;
00540 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00541 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00542
00543 bits_left = bit_length - get_bits_count(&s->gb);
00544 if (bits_left && (bits_left > 8 ||
00545 show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
00546 pps->transform_8x8_mode= get_bits1(&s->gb);
00547 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00548 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb);
00549 } else {
00550 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00551 }
00552
00553 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00554 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00555 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00556 pps->chroma_qp_diff= 1;
00557
00558 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00559 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",
00560 pps_id, pps->sps_id,
00561 pps->cabac ? "CABAC" : "CAVLC",
00562 pps->slice_group_count,
00563 pps->ref_count[0], pps->ref_count[1],
00564 pps->weighted_pred ? "weighted" : "",
00565 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00566 pps->deblocking_filter_parameters_present ? "LPAR" : "",
00567 pps->constrained_intra_pred ? "CONSTR" : "",
00568 pps->redundant_pic_cnt_present ? "REDU" : "",
00569 pps->transform_8x8_mode ? "8x8DCT" : ""
00570 );
00571 }
00572
00573 av_free(h->pps_buffers[pps_id]);
00574 h->pps_buffers[pps_id]= pps;
00575 return 0;
00576 fail:
00577 av_free(pps);
00578 return -1;
00579 }