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, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
00240 return -1;
00241 }
00242 }
00243 if (get_bits_left(&s->gb) < 0) {
00244 av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", -get_bits_left(&s->gb));
00245 return AVERROR_INVALIDDATA;
00246 }
00247
00248 return 0;
00249 }
00250
00251 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
00252 const uint8_t *jvt_list, const uint8_t *fallback_list){
00253 MpegEncContext * const s = &h->s;
00254 int i, last = 8, next = 8;
00255 const uint8_t *scan = size == 16 ? zigzag_scan : ff_zigzag_direct;
00256 if(!get_bits1(&s->gb))
00257 memcpy(factors, fallback_list, size*sizeof(uint8_t));
00258 else
00259 for(i=0;i<size;i++){
00260 if(next)
00261 next = (last + get_se_golomb(&s->gb)) & 0xff;
00262 if(!i && !next){
00263 memcpy(factors, jvt_list, size*sizeof(uint8_t));
00264 break;
00265 }
00266 last = factors[scan[i]] = next ? next : last;
00267 }
00268 }
00269
00270 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
00271 uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
00272 MpegEncContext * const s = &h->s;
00273 int fallback_sps = !is_sps && sps->scaling_matrix_present;
00274 const uint8_t *fallback[4] = {
00275 fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
00276 fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
00277 fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
00278 fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
00279 };
00280 if(get_bits1(&s->gb)){
00281 sps->scaling_matrix_present |= is_sps;
00282 decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]);
00283 decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]);
00284 decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]);
00285 decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]);
00286 decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]);
00287 decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]);
00288 if(is_sps || pps->transform_8x8_mode){
00289 decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);
00290 if(sps->chroma_format_idc == 3){
00291 decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[0],scaling_matrix8[0]);
00292 decode_scaling_list(h,scaling_matrix8[2],64,default_scaling8[0],scaling_matrix8[1]);
00293 }
00294 decode_scaling_list(h,scaling_matrix8[3],64,default_scaling8[1],fallback[3]);
00295 if(sps->chroma_format_idc == 3){
00296 decode_scaling_list(h,scaling_matrix8[4],64,default_scaling8[1],scaling_matrix8[3]);
00297 decode_scaling_list(h,scaling_matrix8[5],64,default_scaling8[1],scaling_matrix8[4]);
00298 }
00299 }
00300 }
00301 }
00302
00303 int ff_h264_decode_seq_parameter_set(H264Context *h){
00304 MpegEncContext * const s = &h->s;
00305 int profile_idc, level_idc, constraint_set_flags = 0;
00306 unsigned int sps_id;
00307 int i, log2_max_frame_num_minus4;
00308 SPS *sps;
00309
00310 profile_idc= get_bits(&s->gb, 8);
00311 constraint_set_flags |= get_bits1(&s->gb) << 0;
00312 constraint_set_flags |= get_bits1(&s->gb) << 1;
00313 constraint_set_flags |= get_bits1(&s->gb) << 2;
00314 constraint_set_flags |= get_bits1(&s->gb) << 3;
00315 get_bits(&s->gb, 4);
00316 level_idc= get_bits(&s->gb, 8);
00317 sps_id= get_ue_golomb_31(&s->gb);
00318
00319 if(sps_id >= MAX_SPS_COUNT) {
00320 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
00321 return -1;
00322 }
00323 sps= av_mallocz(sizeof(SPS));
00324 if(sps == NULL)
00325 return -1;
00326
00327 sps->time_offset_length = 24;
00328 sps->profile_idc= profile_idc;
00329 sps->constraint_set_flags = constraint_set_flags;
00330 sps->level_idc= level_idc;
00331
00332 memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
00333 memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
00334 sps->scaling_matrix_present = 0;
00335
00336 if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
00337 sps->profile_idc == 122 || sps->profile_idc == 244 ||
00338 sps->profile_idc == 44 || sps->profile_idc == 83 ||
00339 sps->profile_idc == 86 || sps->profile_idc == 118 ||
00340 sps->profile_idc == 128 || sps->profile_idc == 144) {
00341 sps->chroma_format_idc= get_ue_golomb_31(&s->gb);
00342 if(sps->chroma_format_idc > 3) {
00343 av_log(h->s.avctx, AV_LOG_ERROR, "chroma_format_idc (%u) out of range\n", sps->chroma_format_idc);
00344 return -1;
00345 } else if(sps->chroma_format_idc == 3) {
00346 sps->residual_color_transform_flag = get_bits1(&s->gb);
00347 }
00348 sps->bit_depth_luma = get_ue_golomb(&s->gb) + 8;
00349 sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
00350 sps->transform_bypass = get_bits1(&s->gb);
00351 decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
00352 }else{
00353 sps->chroma_format_idc= 1;
00354 sps->bit_depth_luma = 8;
00355 sps->bit_depth_chroma = 8;
00356 }
00357
00358 log2_max_frame_num_minus4 = get_ue_golomb(&s->gb);
00359 if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
00360 log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
00361 av_log(h->s.avctx, AV_LOG_ERROR,
00362 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
00363 log2_max_frame_num_minus4);
00364 return AVERROR_INVALIDDATA;
00365 }
00366 sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
00367
00368 sps->poc_type= get_ue_golomb_31(&s->gb);
00369
00370 if(sps->poc_type == 0){
00371 sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
00372 } else if(sps->poc_type == 1){
00373 sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
00374 sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
00375 sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
00376 sps->poc_cycle_length = get_ue_golomb(&s->gb);
00377
00378 if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
00379 av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
00380 goto fail;
00381 }
00382
00383 for(i=0; i<sps->poc_cycle_length; i++)
00384 sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
00385 }else if(sps->poc_type != 2){
00386 av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
00387 goto fail;
00388 }
00389
00390 sps->ref_frame_count= get_ue_golomb_31(&s->gb);
00391 if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
00392 av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
00393 goto fail;
00394 }
00395 sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
00396 sps->mb_width = get_ue_golomb(&s->gb) + 1;
00397 sps->mb_height= get_ue_golomb(&s->gb) + 1;
00398 if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
00399 av_image_check_size(16*sps->mb_width, 16*sps->mb_height, 0, h->s.avctx)){
00400 av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
00401 goto fail;
00402 }
00403
00404 sps->frame_mbs_only_flag= get_bits1(&s->gb);
00405 if(!sps->frame_mbs_only_flag)
00406 sps->mb_aff= get_bits1(&s->gb);
00407 else
00408 sps->mb_aff= 0;
00409
00410 sps->direct_8x8_inference_flag= get_bits1(&s->gb);
00411 if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
00412 av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
00413 goto fail;
00414 }
00415
00416 #ifndef ALLOW_INTERLACE
00417 if(sps->mb_aff)
00418 av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
00419 #endif
00420 sps->crop= get_bits1(&s->gb);
00421 if(sps->crop){
00422 int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
00423 int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
00424 sps->crop_left = get_ue_golomb(&s->gb);
00425 sps->crop_right = get_ue_golomb(&s->gb);
00426 sps->crop_top = get_ue_golomb(&s->gb);
00427 sps->crop_bottom= get_ue_golomb(&s->gb);
00428 if(sps->crop_left || sps->crop_top){
00429 av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
00430 }
00431 if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
00432 av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
00433 }
00434 }else{
00435 sps->crop_left =
00436 sps->crop_right =
00437 sps->crop_top =
00438 sps->crop_bottom= 0;
00439 }
00440
00441 sps->vui_parameters_present_flag= get_bits1(&s->gb);
00442 if( sps->vui_parameters_present_flag )
00443 if (decode_vui_parameters(h, sps) < 0)
00444 goto fail;
00445
00446 if(!sps->sar.den)
00447 sps->sar.den= 1;
00448
00449 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00450 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",
00451 sps_id, sps->profile_idc, sps->level_idc,
00452 sps->poc_type,
00453 sps->ref_frame_count,
00454 sps->mb_width, sps->mb_height,
00455 sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
00456 sps->direct_8x8_inference_flag ? "8B8" : "",
00457 sps->crop_left, sps->crop_right,
00458 sps->crop_top, sps->crop_bottom,
00459 sps->vui_parameters_present_flag ? "VUI" : "",
00460 ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc],
00461 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
00462 sps->timing_info_present_flag ? sps->time_scale : 0
00463 );
00464 }
00465
00466 av_free(h->sps_buffers[sps_id]);
00467 h->sps_buffers[sps_id]= sps;
00468 h->sps = *sps;
00469 return 0;
00470 fail:
00471 av_free(sps);
00472 return -1;
00473 }
00474
00475 static void
00476 build_qp_table(PPS *pps, int t, int index, const int depth)
00477 {
00478 int i;
00479 const int max_qp = 51 + 6*(depth-8);
00480 for(i = 0; i < max_qp+1; i++)
00481 pps->chroma_qp_table[t][i] = ff_h264_chroma_qp[depth-8][av_clip(i + index, 0, max_qp)];
00482 }
00483
00484 int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length){
00485 MpegEncContext * const s = &h->s;
00486 unsigned int pps_id= get_ue_golomb(&s->gb);
00487 PPS *pps;
00488 const int qp_bd_offset = 6*(h->sps.bit_depth_luma-8);
00489 int bits_left;
00490
00491 if(pps_id >= MAX_PPS_COUNT) {
00492 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
00493 return -1;
00494 } else if (h->sps.bit_depth_luma > 10) {
00495 av_log(h->s.avctx, AV_LOG_ERROR, "Unimplemented luma bit depth=%d (max=10)\n", h->sps.bit_depth_luma);
00496 return AVERROR_PATCHWELCOME;
00497 }
00498
00499 pps= av_mallocz(sizeof(PPS));
00500 if(pps == NULL)
00501 return -1;
00502 pps->sps_id= get_ue_golomb_31(&s->gb);
00503 if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
00504 av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
00505 goto fail;
00506 }
00507
00508 pps->cabac= get_bits1(&s->gb);
00509 pps->pic_order_present= get_bits1(&s->gb);
00510 pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
00511 if(pps->slice_group_count > 1 ){
00512 pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
00513 av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
00514 switch(pps->mb_slice_group_map_type){
00515 case 0:
00516 #if 0
00517 | for( i = 0; i <= num_slice_groups_minus1; i++ ) | | |
00518 | run_length[ i ] |1 |ue(v) |
00519 #endif
00520 break;
00521 case 2:
00522 #if 0
00523 | for( i = 0; i < num_slice_groups_minus1; i++ ) | | |
00524 |{ | | |
00525 | top_left_mb[ i ] |1 |ue(v) |
00526 | bottom_right_mb[ i ] |1 |ue(v) |
00527 | } | | |
00528 #endif
00529 break;
00530 case 3:
00531 case 4:
00532 case 5:
00533 #if 0
00534 | slice_group_change_direction_flag |1 |u(1) |
00535 | slice_group_change_rate_minus1 |1 |ue(v) |
00536 #endif
00537 break;
00538 case 6:
00539 #if 0
00540 | slice_group_id_cnt_minus1 |1 |ue(v) |
00541 | for( i = 0; i <= slice_group_id_cnt_minus1; i++ | | |
00542 |) | | |
00543 | slice_group_id[ i ] |1 |u(v) |
00544 #endif
00545 break;
00546 }
00547 }
00548 pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
00549 pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
00550 if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
00551 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
00552 goto fail;
00553 }
00554
00555 pps->weighted_pred= get_bits1(&s->gb);
00556 pps->weighted_bipred_idc= get_bits(&s->gb, 2);
00557 pps->init_qp= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00558 pps->init_qs= get_se_golomb(&s->gb) + 26 + qp_bd_offset;
00559 pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
00560 pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
00561 pps->constrained_intra_pred= get_bits1(&s->gb);
00562 pps->redundant_pic_cnt_present = get_bits1(&s->gb);
00563
00564 pps->transform_8x8_mode= 0;
00565 h->dequant_coeff_pps= -1;
00566 memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
00567 memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
00568
00569 bits_left = bit_length - get_bits_count(&s->gb);
00570 if (bits_left && (bits_left > 8 ||
00571 show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
00572 pps->transform_8x8_mode= get_bits1(&s->gb);
00573 decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
00574 pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb);
00575 } else {
00576 pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
00577 }
00578
00579 build_qp_table(pps, 0, pps->chroma_qp_index_offset[0], h->sps.bit_depth_luma);
00580 build_qp_table(pps, 1, pps->chroma_qp_index_offset[1], h->sps.bit_depth_luma);
00581 if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
00582 pps->chroma_qp_diff= 1;
00583
00584 if(s->avctx->debug&FF_DEBUG_PICT_INFO){
00585 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",
00586 pps_id, pps->sps_id,
00587 pps->cabac ? "CABAC" : "CAVLC",
00588 pps->slice_group_count,
00589 pps->ref_count[0], pps->ref_count[1],
00590 pps->weighted_pred ? "weighted" : "",
00591 pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
00592 pps->deblocking_filter_parameters_present ? "LPAR" : "",
00593 pps->constrained_intra_pred ? "CONSTR" : "",
00594 pps->redundant_pic_cnt_present ? "REDU" : "",
00595 pps->transform_8x8_mode ? "8x8DCT" : ""
00596 );
00597 }
00598
00599 av_free(h->pps_buffers[pps_id]);
00600 h->pps_buffers[pps_id]= pps;
00601 return 0;
00602 fail:
00603 av_free(pps);
00604 return -1;
00605 }