1 /* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18 #include "avcdec_lib.h" 19 #include "avcdec_bitstream.h" 20 #include "oscl_mem.h" 21 #include "avcdec_api.h" 22 23 /** see subclause 7.4.2.1 */ 24 AVCDec_Status DecodeSPS(AVCDecObject *decvid, AVCDecBitstream *stream) 25 { 26 AVCDec_Status status = AVCDEC_SUCCESS; 27 AVCSeqParamSet *seqParam; 28 uint temp; 29 int i; 30 uint profile_idc, constrained_set0_flag, constrained_set1_flag, constrained_set2_flag; 31 uint level_idc, seq_parameter_set_id; 32 void *userData = decvid->avcHandle->userData; 33 AVCHandle *avcHandle = decvid->avcHandle; 34 35 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "DecodeSPS", -1, -1); 36 37 BitstreamReadBits(stream, 8, &profile_idc); 38 BitstreamRead1Bit(stream, &constrained_set0_flag); 39 // if (profile_idc != 66 && constrained_set0_flag != 1) 40 // { 41 // return AVCDEC_FAIL; 42 // } 43 BitstreamRead1Bit(stream, &constrained_set1_flag); 44 BitstreamRead1Bit(stream, &constrained_set2_flag); 45 BitstreamReadBits(stream, 5, &temp); 46 BitstreamReadBits(stream, 8, &level_idc); 47 if (level_idc > 51) 48 { 49 return AVCDEC_FAIL; 50 } 51 if (mapLev2Idx[level_idc] == 255) 52 { 53 return AVCDEC_FAIL; 54 } 55 ue_v(stream, &seq_parameter_set_id); 56 57 if (seq_parameter_set_id > 31) 58 { 59 return AVCDEC_FAIL; 60 } 61 62 /* Allocate sequence param set for seqParams[seq_parameter_set_id]. */ 63 if (decvid->seqParams[seq_parameter_set_id] == NULL) /* allocate seqParams[id] */ 64 { 65 decvid->seqParams[seq_parameter_set_id] = 66 (AVCSeqParamSet*) avcHandle->CBAVC_Malloc(userData, sizeof(AVCSeqParamSet), DEFAULT_ATTR); 67 68 if (decvid->seqParams[seq_parameter_set_id] == NULL) 69 { 70 return AVCDEC_MEMORY_FAIL; 71 } 72 } 73 74 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "done alloc seqParams", -1, -1); 75 76 seqParam = decvid->seqParams[seq_parameter_set_id]; 77 78 seqParam->profile_idc = profile_idc; 79 seqParam->constrained_set0_flag = constrained_set0_flag; 80 seqParam->constrained_set1_flag = constrained_set1_flag; 81 seqParam->constrained_set2_flag = constrained_set2_flag; 82 seqParam->level_idc = level_idc; 83 seqParam->seq_parameter_set_id = seq_parameter_set_id; 84 85 /* continue decoding SPS */ 86 ue_v(stream, &(seqParam->log2_max_frame_num_minus4)); 87 88 if (seqParam->log2_max_frame_num_minus4 > 12) 89 { 90 return AVCDEC_FAIL; 91 } 92 93 ue_v(stream, &(seqParam->pic_order_cnt_type)); 94 95 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "check point 1", seqParam->log2_max_frame_num_minus4, seqParam->pic_order_cnt_type); 96 97 if (seqParam->pic_order_cnt_type == 0) 98 { 99 ue_v(stream, &(seqParam->log2_max_pic_order_cnt_lsb_minus4)); 100 } 101 else if (seqParam->pic_order_cnt_type == 1) 102 { // MC_CHECK 103 BitstreamRead1Bit(stream, (uint*)&(seqParam->delta_pic_order_always_zero_flag)); 104 se_v32bit(stream, &(seqParam->offset_for_non_ref_pic)); 105 se_v32bit(stream, &(seqParam->offset_for_top_to_bottom_field)); 106 ue_v(stream, &(seqParam->num_ref_frames_in_pic_order_cnt_cycle)); 107 108 for (i = 0; i < (int)(seqParam->num_ref_frames_in_pic_order_cnt_cycle); i++) 109 { 110 se_v32bit(stream, &(seqParam->offset_for_ref_frame[i])); 111 } 112 } 113 114 ue_v(stream, &(seqParam->num_ref_frames)); 115 116 if (seqParam->num_ref_frames > 16) 117 { 118 return AVCDEC_FAIL; 119 } 120 121 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "check point 2", seqParam->num_ref_frames, -1); 122 123 BitstreamRead1Bit(stream, (uint*)&(seqParam->gaps_in_frame_num_value_allowed_flag)); 124 ue_v(stream, &(seqParam->pic_width_in_mbs_minus1)); 125 126 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "picwidth", seqParam->pic_width_in_mbs_minus1, -1); 127 128 ue_v(stream, &(seqParam->pic_height_in_map_units_minus1)); 129 130 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "picwidth", seqParam->pic_height_in_map_units_minus1, -1); 131 132 BitstreamRead1Bit(stream, (uint*)&(seqParam->frame_mbs_only_flag)); 133 134 seqParam->mb_adaptive_frame_field_flag = 0; /* default value */ 135 if (!seqParam->frame_mbs_only_flag) 136 { 137 BitstreamRead1Bit(stream, (uint*)&(seqParam->mb_adaptive_frame_field_flag)); 138 } 139 140 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "check point 3", seqParam->frame_mbs_only_flag, -1); 141 142 BitstreamRead1Bit(stream, (uint*)&(seqParam->direct_8x8_inference_flag)); 143 144 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "check point 4", seqParam->direct_8x8_inference_flag, -1); 145 146 BitstreamRead1Bit(stream, (uint*)&(seqParam->frame_cropping_flag)); 147 seqParam->frame_crop_left_offset = 0; /* default value */ 148 seqParam->frame_crop_right_offset = 0;/* default value */ 149 seqParam->frame_crop_top_offset = 0;/* default value */ 150 seqParam->frame_crop_bottom_offset = 0;/* default value */ 151 if (seqParam->frame_cropping_flag) 152 { 153 ue_v(stream, &(seqParam->frame_crop_left_offset)); 154 ue_v(stream, &(seqParam->frame_crop_right_offset)); 155 ue_v(stream, &(seqParam->frame_crop_top_offset)); 156 ue_v(stream, &(seqParam->frame_crop_bottom_offset)); 157 } 158 159 DEBUG_LOG(userData, AVC_LOGTYPE_INFO, "check point 5", seqParam->frame_cropping_flag, -1); 160 161 BitstreamRead1Bit(stream, (uint*)&(seqParam->vui_parameters_present_flag)); 162 if (seqParam->vui_parameters_present_flag) 163 { 164 status = vui_parameters(decvid, stream, seqParam); 165 if (status != AVCDEC_SUCCESS) 166 { 167 return AVCDEC_FAIL; 168 } 169 } 170 171 return status; 172 } 173 174 175 AVCDec_Status vui_parameters(AVCDecObject *decvid, AVCDecBitstream *stream, AVCSeqParamSet *currSPS) 176 { 177 uint temp; 178 uint temp32; 179 uint aspect_ratio_idc, overscan_appopriate_flag, video_format, video_full_range_flag; 180 /* aspect_ratio_info_present_flag */ 181 BitstreamRead1Bit(stream, &temp); 182 if (temp) 183 { 184 BitstreamReadBits(stream, 8, &aspect_ratio_idc); 185 if (aspect_ratio_idc == 255) 186 { 187 /* sar_width */ 188 BitstreamReadBits(stream, 16, &temp); 189 /* sar_height */ 190 BitstreamReadBits(stream, 16, &temp); 191 } 192 } 193 /* overscan_info_present */ 194 BitstreamRead1Bit(stream, &temp); 195 if (temp) 196 { 197 BitstreamRead1Bit(stream, &overscan_appopriate_flag); 198 } 199 /* video_signal_type_present_flag */ 200 BitstreamRead1Bit(stream, &temp); 201 if (temp) 202 { 203 BitstreamReadBits(stream, 3, &video_format); 204 BitstreamRead1Bit(stream, &video_full_range_flag); 205 /* colour_description_present_flag */ 206 BitstreamRead1Bit(stream, &temp); 207 if (temp) 208 { 209 /* colour_primaries */ 210 BitstreamReadBits(stream, 8, &temp); 211 /* transfer_characteristics */ 212 BitstreamReadBits(stream, 8, &temp); 213 /* matrix coefficients */ 214 BitstreamReadBits(stream, 8, &temp); 215 } 216 } 217 /* chroma_loc_info_present_flag */ 218 BitstreamRead1Bit(stream, &temp); 219 if (temp) 220 { 221 /* chroma_sample_loc_type_top_field */ 222 ue_v(stream, &temp); 223 /* chroma_sample_loc_type_bottom_field */ 224 ue_v(stream, &temp); 225 } 226 227 /* timing_info_present_flag*/ 228 BitstreamRead1Bit(stream, &temp); 229 if (temp) 230 { 231 /* num_unit_in_tick*/ 232 BitstreamReadBits(stream, 32, &temp32); 233 /* time_scale */ 234 BitstreamReadBits(stream, 32, &temp32); 235 /* fixed_frame_rate_flag */ 236 BitstreamRead1Bit(stream, &temp); 237 } 238 239 /* nal_hrd_parameters_present_flag */ 240 BitstreamRead1Bit(stream, &temp); 241 currSPS->vui_parameters.nal_hrd_parameters_present_flag = temp; 242 if (temp) 243 { 244 hrd_parameters(decvid, stream, &(currSPS->vui_parameters.nal_hrd_parameters)); 245 } 246 /* vcl_hrd_parameters_present_flag*/ 247 BitstreamRead1Bit(stream, &temp); 248 currSPS->vui_parameters.vcl_hrd_parameters_present_flag = temp; 249 if (temp) 250 { 251 hrd_parameters(decvid, stream, &(currSPS->vui_parameters.vcl_hrd_parameters)); 252 } 253 if (currSPS->vui_parameters.nal_hrd_parameters_present_flag || currSPS->vui_parameters.vcl_hrd_parameters_present_flag) 254 { 255 /* low_delay_hrd_flag */ 256 BitstreamRead1Bit(stream, &temp); 257 } 258 /* pic_struct_present_flag */ 259 BitstreamRead1Bit(stream, &temp); 260 currSPS->vui_parameters.pic_struct_present_flag = temp; 261 /* bitstream_restriction_flag */ 262 BitstreamRead1Bit(stream, &temp); 263 if (temp) 264 { 265 /* motion_vectors_over_pic_boundaries_flag */ 266 BitstreamRead1Bit(stream, &temp); 267 /* max_bytes_per_pic_denom */ 268 ue_v(stream, &temp); 269 /* max_bits_per_mb_denom */ 270 ue_v(stream, &temp); 271 /* log2_max_mv_length_horizontal */ 272 ue_v(stream, &temp); 273 /* log2_max_mv_length_vertical */ 274 ue_v(stream, &temp); 275 /* num_reorder_frames */ 276 ue_v(stream, &temp); 277 /* max_dec_frame_buffering */ 278 ue_v(stream, &temp); 279 } 280 return AVCDEC_SUCCESS; 281 } 282 AVCDec_Status hrd_parameters(AVCDecObject *decvid, AVCDecBitstream *stream, AVCHRDParams *HRDParam) 283 { 284 OSCL_UNUSED_ARG(decvid); 285 uint temp; 286 uint cpb_cnt_minus1; 287 uint i; 288 ue_v(stream, &cpb_cnt_minus1); 289 HRDParam->cpb_cnt_minus1 = cpb_cnt_minus1; 290 /* bit_rate_scale */ 291 BitstreamReadBits(stream, 4, &temp); 292 /* cpb_size_scale */ 293 BitstreamReadBits(stream, 4, &temp); 294 for (i = 0; i <= cpb_cnt_minus1; i++) 295 { 296 /* bit_rate_value_minus1[i] */ 297 ue_v(stream, &temp); 298 /* cpb_size_value_minus1[i] */ 299 ue_v(stream, &temp); 300 /* cbr_flag[i] */ 301 ue_v(stream, &temp); 302 } 303 /* initial_cpb_removal_delay_length_minus1 */ 304 BitstreamReadBits(stream, 5, &temp); 305 /* cpb_removal_delay_length_minus1 */ 306 BitstreamReadBits(stream, 5, &temp); 307 HRDParam->cpb_removal_delay_length_minus1 = temp; 308 /* dpb_output_delay_length_minus1 */ 309 BitstreamReadBits(stream, 5, &temp); 310 HRDParam->dpb_output_delay_length_minus1 = temp; 311 /* time_offset_length */ 312 BitstreamReadBits(stream, 5, &temp); 313 HRDParam->time_offset_length = temp; 314 return AVCDEC_SUCCESS; 315 } 316 317 318 /** see subclause 7.4.2.2 */ 319 AVCDec_Status DecodePPS(AVCDecObject *decvid, AVCCommonObj *video, AVCDecBitstream *stream) 320 { 321 AVCPicParamSet *picParam; 322 AVCDec_Status status; 323 int i, iGroup, numBits; 324 int PicWidthInMbs, PicHeightInMapUnits, PicSizeInMapUnits; 325 uint pic_parameter_set_id, seq_parameter_set_id; 326 void *userData = decvid->avcHandle->userData; 327 AVCHandle *avcHandle = decvid->avcHandle; 328 329 ue_v(stream, &pic_parameter_set_id); 330 if (pic_parameter_set_id > 255) 331 { 332 return AVCDEC_FAIL; 333 } 334 335 ue_v(stream, &seq_parameter_set_id); 336 337 if (seq_parameter_set_id > 31) 338 { 339 return AVCDEC_FAIL; 340 } 341 342 /* 2.1 if picParams[pic_param_set_id] is NULL, allocate it. */ 343 if (decvid->picParams[pic_parameter_set_id] == NULL) 344 { 345 decvid->picParams[pic_parameter_set_id] = 346 (AVCPicParamSet*)avcHandle->CBAVC_Malloc(userData, sizeof(AVCPicParamSet), DEFAULT_ATTR); 347 if (decvid->picParams[pic_parameter_set_id] == NULL) 348 { 349 return AVCDEC_MEMORY_FAIL; 350 } 351 352 decvid->picParams[pic_parameter_set_id]->slice_group_id = NULL; 353 } 354 355 video->currPicParams = picParam = decvid->picParams[pic_parameter_set_id]; 356 picParam->seq_parameter_set_id = seq_parameter_set_id; 357 picParam->pic_parameter_set_id = pic_parameter_set_id; 358 359 BitstreamRead1Bit(stream, (uint*)&(picParam->entropy_coding_mode_flag)); 360 if (picParam->entropy_coding_mode_flag) 361 { 362 status = AVCDEC_FAIL; 363 goto clean_up; 364 } 365 BitstreamRead1Bit(stream, (uint*)&(picParam->pic_order_present_flag)); 366 ue_v(stream, &(picParam->num_slice_groups_minus1)); 367 368 if (picParam->num_slice_groups_minus1 > MAX_NUM_SLICE_GROUP - 1) 369 { 370 status = AVCDEC_FAIL; 371 goto clean_up; 372 } 373 374 picParam->slice_group_change_rate_minus1 = 0; /* default value */ 375 if (picParam->num_slice_groups_minus1 > 0) 376 { 377 ue_v(stream, &(picParam->slice_group_map_type)); 378 if (picParam->slice_group_map_type == 0) 379 { 380 for (iGroup = 0; iGroup <= (int)picParam->num_slice_groups_minus1; iGroup++) 381 { 382 ue_v(stream, &(picParam->run_length_minus1[iGroup])); 383 } 384 } 385 else if (picParam->slice_group_map_type == 2) 386 { // MC_CHECK <= or < 387 for (iGroup = 0; iGroup < (int)picParam->num_slice_groups_minus1; iGroup++) 388 { 389 ue_v(stream, &(picParam->top_left[iGroup])); 390 ue_v(stream, &(picParam->bottom_right[iGroup])); 391 } 392 } 393 else if (picParam->slice_group_map_type == 3 || 394 picParam->slice_group_map_type == 4 || 395 picParam->slice_group_map_type == 5) 396 { 397 BitstreamRead1Bit(stream, (uint*)&(picParam->slice_group_change_direction_flag)); 398 ue_v(stream, &(picParam->slice_group_change_rate_minus1)); 399 } 400 else if (picParam->slice_group_map_type == 6) 401 { 402 ue_v(stream, &(picParam->pic_size_in_map_units_minus1)); 403 404 numBits = 0;/* ceil(log2(num_slice_groups_minus1+1)) bits */ 405 i = picParam->num_slice_groups_minus1; 406 while (i > 0) 407 { 408 numBits++; 409 i >>= 1; 410 } 411 412 i = picParam->seq_parameter_set_id; 413 if (decvid->seqParams[i] == NULL) 414 { 415 status = AVCDEC_FAIL; 416 goto clean_up; 417 } 418 419 420 PicWidthInMbs = decvid->seqParams[i]->pic_width_in_mbs_minus1 + 1; 421 PicHeightInMapUnits = decvid->seqParams[i]->pic_height_in_map_units_minus1 + 1 ; 422 PicSizeInMapUnits = PicWidthInMbs * PicHeightInMapUnits ; 423 424 /* information has to be consistent with the seq_param */ 425 if ((int)picParam->pic_size_in_map_units_minus1 != PicSizeInMapUnits - 1) 426 { 427 status = AVCDEC_FAIL; 428 goto clean_up; 429 } 430 431 if (picParam->slice_group_id) 432 { 433 avcHandle->CBAVC_Free(userData, (int)picParam->slice_group_id); 434 } 435 picParam->slice_group_id = (uint*)avcHandle->CBAVC_Malloc(userData, sizeof(uint) * PicSizeInMapUnits, DEFAULT_ATTR); 436 if (picParam->slice_group_id == NULL) 437 { 438 status = AVCDEC_MEMORY_FAIL; 439 goto clean_up; 440 } 441 442 for (i = 0; i < PicSizeInMapUnits; i++) 443 { 444 BitstreamReadBits(stream, numBits, &(picParam->slice_group_id[i])); 445 } 446 } 447 448 } 449 450 ue_v(stream, &(picParam->num_ref_idx_l0_active_minus1)); 451 if (picParam->num_ref_idx_l0_active_minus1 > 31) 452 { 453 status = AVCDEC_FAIL; /* out of range */ 454 goto clean_up; 455 } 456 457 ue_v(stream, &(picParam->num_ref_idx_l1_active_minus1)); 458 if (picParam->num_ref_idx_l1_active_minus1 > 31) 459 { 460 status = AVCDEC_FAIL; /* out of range */ 461 goto clean_up; 462 } 463 464 BitstreamRead1Bit(stream, (uint*)&(picParam->weighted_pred_flag)); 465 BitstreamReadBits(stream, 2, &(picParam->weighted_bipred_idc)); 466 if (picParam->weighted_bipred_idc > 2) 467 { 468 status = AVCDEC_FAIL; /* out of range */ 469 goto clean_up; 470 } 471 472 se_v(stream, &(picParam->pic_init_qp_minus26)); 473 if (picParam->pic_init_qp_minus26 < -26 || picParam->pic_init_qp_minus26 > 25) 474 { 475 status = AVCDEC_FAIL; /* out of range */ 476 goto clean_up; 477 } 478 479 se_v(stream, &(picParam->pic_init_qs_minus26)); 480 if (picParam->pic_init_qs_minus26 < -26 || picParam->pic_init_qs_minus26 > 25) 481 { 482 status = AVCDEC_FAIL; /* out of range */ 483 goto clean_up; 484 } 485 486 se_v(stream, &(picParam->chroma_qp_index_offset)); 487 if (picParam->chroma_qp_index_offset < -12 || picParam->chroma_qp_index_offset > 12) 488 { 489 status = AVCDEC_FAIL; /* out of range */ 490 status = AVCDEC_FAIL; /* out of range */ 491 goto clean_up; 492 } 493 494 BitstreamReadBits(stream, 3, &pic_parameter_set_id); 495 picParam->deblocking_filter_control_present_flag = pic_parameter_set_id >> 2; 496 picParam->constrained_intra_pred_flag = (pic_parameter_set_id >> 1) & 1; 497 picParam->redundant_pic_cnt_present_flag = pic_parameter_set_id & 1; 498 499 return AVCDEC_SUCCESS; 500 clean_up: 501 if (decvid->picParams[pic_parameter_set_id]) 502 { 503 if (picParam->slice_group_id) 504 { 505 avcHandle->CBAVC_Free(userData, (int)picParam->slice_group_id); 506 } 507 decvid->picParams[pic_parameter_set_id]->slice_group_id = NULL; 508 avcHandle->CBAVC_Free(userData, (int)decvid->picParams[pic_parameter_set_id]); 509 decvid->picParams[pic_parameter_set_id] = NULL; 510 return status; 511 } 512 return AVCDEC_SUCCESS; 513 } 514 515 516 /* FirstPartOfSliceHeader(); 517 RestOfSliceHeader() */ 518 /** see subclause 7.4.3 */ 519 AVCDec_Status DecodeSliceHeader(AVCDecObject *decvid, AVCCommonObj *video, AVCDecBitstream *stream) 520 { 521 AVCSliceHeader *sliceHdr = video->sliceHdr; 522 AVCPicParamSet *currPPS; 523 AVCSeqParamSet *currSPS; 524 AVCDec_Status status; 525 uint idr_pic_id; 526 int slice_type, temp, i; 527 528 ue_v(stream, &(sliceHdr->first_mb_in_slice)); 529 ue_v(stream, (uint*)&slice_type); 530 531 if (sliceHdr->first_mb_in_slice != 0) 532 { 533 if ((int)sliceHdr->slice_type >= 5 && slice_type != (int)sliceHdr->slice_type - 5) 534 { 535 return AVCDEC_FAIL; /* slice type doesn't follow the first slice in the picture */ 536 } 537 } 538 sliceHdr->slice_type = (AVCSliceType) slice_type; 539 if (slice_type > 4) 540 { 541 slice_type -= 5; 542 } 543 544 if (slice_type == 1 || slice_type > 2) 545 { 546 return AVCDEC_FAIL; 547 } 548 549 video->slice_type = (AVCSliceType) slice_type; 550 551 ue_v(stream, &(sliceHdr->pic_parameter_set_id)); 552 /* end FirstPartSliceHeader() */ 553 /* begin RestOfSliceHeader() */ 554 /* after getting pic_parameter_set_id, we have to load corresponding SPS and PPS */ 555 if (sliceHdr->pic_parameter_set_id > 255) 556 { 557 return AVCDEC_FAIL; 558 } 559 560 if (decvid->picParams[sliceHdr->pic_parameter_set_id] == NULL) 561 return AVCDEC_FAIL; /* PPS doesn't exist */ 562 563 currPPS = video->currPicParams = decvid->picParams[sliceHdr->pic_parameter_set_id]; 564 565 if (decvid->seqParams[currPPS->seq_parameter_set_id] == NULL) 566 return AVCDEC_FAIL; /* SPS doesn't exist */ 567 568 currSPS = video->currSeqParams = decvid->seqParams[currPPS->seq_parameter_set_id]; 569 570 if (currPPS->seq_parameter_set_id != video->seq_parameter_set_id) 571 { 572 video->seq_parameter_set_id = currPPS->seq_parameter_set_id; 573 status = (AVCDec_Status)AVCConfigureSequence(decvid->avcHandle, video, false); 574 if (status != AVCDEC_SUCCESS) 575 return status; 576 video->level_idc = currSPS->level_idc; 577 } 578 579 /* derived variables from SPS */ 580 video->MaxFrameNum = 1 << (currSPS->log2_max_frame_num_minus4 + 4); 581 // MC_OPTIMIZE 582 video->PicWidthInMbs = currSPS->pic_width_in_mbs_minus1 + 1; 583 video->PicWidthInSamplesL = video->PicWidthInMbs * 16 ; 584 video->PicWidthInSamplesC = video->PicWidthInMbs * 8 ; 585 video->PicHeightInMapUnits = currSPS->pic_height_in_map_units_minus1 + 1 ; 586 video->PicSizeInMapUnits = video->PicWidthInMbs * video->PicHeightInMapUnits ; 587 video->FrameHeightInMbs = (2 - currSPS->frame_mbs_only_flag) * video->PicHeightInMapUnits ; 588 589 /* derived from PPS */ 590 video->SliceGroupChangeRate = currPPS->slice_group_change_rate_minus1 + 1; 591 592 /* then we can continue decoding slice header */ 593 594 BitstreamReadBits(stream, currSPS->log2_max_frame_num_minus4 + 4, &(sliceHdr->frame_num)); 595 596 if (video->currFS == NULL && sliceHdr->frame_num != 0) 597 { 598 video->prevFrameNum = video->PrevRefFrameNum = sliceHdr->frame_num - 1; 599 } 600 601 if (!currSPS->frame_mbs_only_flag) 602 { 603 BitstreamRead1Bit(stream, &(sliceHdr->field_pic_flag)); 604 if (sliceHdr->field_pic_flag) 605 { 606 return AVCDEC_FAIL; 607 } 608 } 609 610 /* derived variables from slice header*/ 611 video->PicHeightInMbs = video->FrameHeightInMbs; 612 video->PicHeightInSamplesL = video->PicHeightInMbs * 16; 613 video->PicHeightInSamplesC = video->PicHeightInMbs * 8; 614 video->PicSizeInMbs = video->PicWidthInMbs * video->PicHeightInMbs; 615 616 if (sliceHdr->first_mb_in_slice >= video->PicSizeInMbs) 617 { 618 return AVCDEC_FAIL; 619 } 620 video->MaxPicNum = video->MaxFrameNum; 621 video->CurrPicNum = sliceHdr->frame_num; 622 623 624 if (video->nal_unit_type == AVC_NALTYPE_IDR) 625 { 626 if (sliceHdr->frame_num != 0) 627 { 628 return AVCDEC_FAIL; 629 } 630 ue_v(stream, &idr_pic_id); 631 } 632 633 sliceHdr->delta_pic_order_cnt_bottom = 0; /* default value */ 634 sliceHdr->delta_pic_order_cnt[0] = 0; /* default value */ 635 sliceHdr->delta_pic_order_cnt[1] = 0; /* default value */ 636 if (currSPS->pic_order_cnt_type == 0) 637 { 638 BitstreamReadBits(stream, currSPS->log2_max_pic_order_cnt_lsb_minus4 + 4, 639 &(sliceHdr->pic_order_cnt_lsb)); 640 video->MaxPicOrderCntLsb = 1 << (currSPS->log2_max_pic_order_cnt_lsb_minus4 + 4); 641 if (sliceHdr->pic_order_cnt_lsb > video->MaxPicOrderCntLsb - 1) 642 return AVCDEC_FAIL; /* out of range */ 643 644 if (currPPS->pic_order_present_flag) 645 { 646 se_v32bit(stream, &(sliceHdr->delta_pic_order_cnt_bottom)); 647 } 648 } 649 if (currSPS->pic_order_cnt_type == 1 && !currSPS->delta_pic_order_always_zero_flag) 650 { 651 se_v32bit(stream, &(sliceHdr->delta_pic_order_cnt[0])); 652 if (currPPS->pic_order_present_flag) 653 { 654 se_v32bit(stream, &(sliceHdr->delta_pic_order_cnt[1])); 655 } 656 } 657 658 sliceHdr->redundant_pic_cnt = 0; /* default value */ 659 if (currPPS->redundant_pic_cnt_present_flag) 660 { 661 // MC_CHECK 662 ue_v(stream, &(sliceHdr->redundant_pic_cnt)); 663 if (sliceHdr->redundant_pic_cnt > 127) /* out of range */ 664 return AVCDEC_FAIL; 665 666 if (sliceHdr->redundant_pic_cnt > 0) /* redundant picture */ 667 return AVCDEC_FAIL; /* not supported */ 668 } 669 sliceHdr->num_ref_idx_l0_active_minus1 = currPPS->num_ref_idx_l0_active_minus1; 670 sliceHdr->num_ref_idx_l1_active_minus1 = currPPS->num_ref_idx_l1_active_minus1; 671 672 if (slice_type == AVC_P_SLICE) 673 { 674 BitstreamRead1Bit(stream, &(sliceHdr->num_ref_idx_active_override_flag)); 675 if (sliceHdr->num_ref_idx_active_override_flag) 676 { 677 ue_v(stream, &(sliceHdr->num_ref_idx_l0_active_minus1)); 678 } 679 else /* the following condition is not allowed if the flag is zero */ 680 { 681 if ((slice_type == AVC_P_SLICE) && currPPS->num_ref_idx_l0_active_minus1 > 15) 682 { 683 return AVCDEC_FAIL; /* not allowed */ 684 } 685 } 686 } 687 688 689 if (sliceHdr->num_ref_idx_l0_active_minus1 > 15 || 690 sliceHdr->num_ref_idx_l1_active_minus1 > 15) 691 { 692 return AVCDEC_FAIL; /* not allowed */ 693 } 694 /* if MbaffFrameFlag =1, 695 max value of index is num_ref_idx_l0_active_minus1 for frame MBs and 696 2*sliceHdr->num_ref_idx_l0_active_minus1 + 1 for field MBs */ 697 698 /* ref_pic_list_reordering() */ 699 status = ref_pic_list_reordering(video, stream, sliceHdr, slice_type); 700 if (status != AVCDEC_SUCCESS) 701 { 702 return status; 703 } 704 705 706 if (video->nal_ref_idc != 0) 707 { 708 dec_ref_pic_marking(video, stream, sliceHdr); 709 } 710 se_v(stream, &(sliceHdr->slice_qp_delta)); 711 712 video->QPy = 26 + currPPS->pic_init_qp_minus26 + sliceHdr->slice_qp_delta; 713 if (video->QPy > 51 || video->QPy < 0) 714 { 715 video->QPy = AVC_CLIP3(0, 51, video->QPy); 716 // return AVCDEC_FAIL; 717 } 718 video->QPc = mapQPi2QPc[AVC_CLIP3(0, 51, video->QPy + video->currPicParams->chroma_qp_index_offset)]; 719 720 video->QPy_div_6 = (video->QPy * 43) >> 8; 721 video->QPy_mod_6 = video->QPy - 6 * video->QPy_div_6; 722 723 video->QPc_div_6 = (video->QPc * 43) >> 8; 724 video->QPc_mod_6 = video->QPc - 6 * video->QPc_div_6; 725 726 sliceHdr->slice_alpha_c0_offset_div2 = 0; 727 sliceHdr->slice_beta_offset_div_2 = 0; 728 sliceHdr->disable_deblocking_filter_idc = 0; 729 video->FilterOffsetA = video->FilterOffsetB = 0; 730 731 if (currPPS->deblocking_filter_control_present_flag) 732 { 733 ue_v(stream, &(sliceHdr->disable_deblocking_filter_idc)); 734 if (sliceHdr->disable_deblocking_filter_idc > 2) 735 { 736 return AVCDEC_FAIL; /* out of range */ 737 } 738 if (sliceHdr->disable_deblocking_filter_idc != 1) 739 { 740 se_v(stream, &(sliceHdr->slice_alpha_c0_offset_div2)); 741 if (sliceHdr->slice_alpha_c0_offset_div2 < -6 || 742 sliceHdr->slice_alpha_c0_offset_div2 > 6) 743 { 744 return AVCDEC_FAIL; 745 } 746 video->FilterOffsetA = sliceHdr->slice_alpha_c0_offset_div2 << 1; 747 748 se_v(stream, &(sliceHdr->slice_beta_offset_div_2)); 749 if (sliceHdr->slice_beta_offset_div_2 < -6 || 750 sliceHdr->slice_beta_offset_div_2 > 6) 751 { 752 return AVCDEC_FAIL; 753 } 754 video->FilterOffsetB = sliceHdr->slice_beta_offset_div_2 << 1; 755 } 756 } 757 758 if (currPPS->num_slice_groups_minus1 > 0 && currPPS->slice_group_map_type >= 3 759 && currPPS->slice_group_map_type <= 5) 760 { 761 /* Ceil(Log2(PicSizeInMapUnits/(float)SliceGroupChangeRate + 1)) */ 762 temp = video->PicSizeInMapUnits / video->SliceGroupChangeRate; 763 if (video->PicSizeInMapUnits % video->SliceGroupChangeRate) 764 { 765 temp++; 766 } 767 i = 0; 768 temp++; 769 while (temp) 770 { 771 temp >>= 1; 772 i++; 773 } 774 775 BitstreamReadBits(stream, i, &(sliceHdr->slice_group_change_cycle)); 776 video->MapUnitsInSliceGroup0 = 777 AVC_MIN(sliceHdr->slice_group_change_cycle * video->SliceGroupChangeRate, video->PicSizeInMapUnits); 778 } 779 780 return AVCDEC_SUCCESS; 781 } 782 783 784 AVCDec_Status fill_frame_num_gap(AVCHandle *avcHandle, AVCCommonObj *video) 785 { 786 AVCDec_Status status; 787 int CurrFrameNum; 788 int UnusedShortTermFrameNum; 789 int tmp1 = video->sliceHdr->delta_pic_order_cnt[0]; 790 int tmp2 = video->sliceHdr->delta_pic_order_cnt[1]; 791 int tmp3 = video->CurrPicNum; 792 int tmp4 = video->sliceHdr->adaptive_ref_pic_marking_mode_flag; 793 UnusedShortTermFrameNum = (video->prevFrameNum + 1) % video->MaxFrameNum; 794 CurrFrameNum = video->sliceHdr->frame_num; 795 796 video->sliceHdr->delta_pic_order_cnt[0] = 0; 797 video->sliceHdr->delta_pic_order_cnt[1] = 0; 798 while (CurrFrameNum != UnusedShortTermFrameNum) 799 { 800 video->CurrPicNum = UnusedShortTermFrameNum; 801 video->sliceHdr->frame_num = UnusedShortTermFrameNum; 802 803 status = (AVCDec_Status)DPBInitBuffer(avcHandle, video); 804 if (status != AVCDEC_SUCCESS) /* no buffer available */ 805 { 806 return status; 807 } 808 DecodePOC(video); 809 DPBInitPic(video, UnusedShortTermFrameNum); 810 811 812 video->currFS->PicOrderCnt = video->PicOrderCnt; 813 video->currFS->FrameNum = video->sliceHdr->frame_num; 814 815 /* initialize everything to zero */ 816 video->currFS->IsOutputted = 0x01; 817 video->currFS->IsReference = 3; 818 video->currFS->IsLongTerm = 0; 819 video->currFS->frame.isReference = TRUE; 820 video->currFS->frame.isLongTerm = FALSE; 821 822 video->sliceHdr->adaptive_ref_pic_marking_mode_flag = 0; 823 824 status = (AVCDec_Status)StorePictureInDPB(avcHandle, video); // MC_CHECK check the return status 825 if (status != AVCDEC_SUCCESS) 826 { 827 return AVCDEC_FAIL; 828 } 829 video->prevFrameNum = UnusedShortTermFrameNum; 830 UnusedShortTermFrameNum = (UnusedShortTermFrameNum + 1) % video->MaxFrameNum; 831 } 832 video->sliceHdr->frame_num = CurrFrameNum; 833 video->CurrPicNum = tmp3; 834 video->sliceHdr->delta_pic_order_cnt[0] = tmp1; 835 video->sliceHdr->delta_pic_order_cnt[1] = tmp2; 836 video->sliceHdr->adaptive_ref_pic_marking_mode_flag = tmp4; 837 return AVCDEC_SUCCESS; 838 } 839 840 /** see subclause 7.4.3.1 */ 841 AVCDec_Status ref_pic_list_reordering(AVCCommonObj *video, AVCDecBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type) 842 { 843 int i; 844 845 if (slice_type != AVC_I_SLICE) 846 { 847 BitstreamRead1Bit(stream, &(sliceHdr->ref_pic_list_reordering_flag_l0)); 848 if (sliceHdr->ref_pic_list_reordering_flag_l0) 849 { 850 i = 0; 851 do 852 { 853 ue_v(stream, &(sliceHdr->reordering_of_pic_nums_idc_l0[i])); 854 if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 || 855 sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1) 856 { 857 ue_v(stream, &(sliceHdr->abs_diff_pic_num_minus1_l0[i])); 858 if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 && 859 sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum / 2 - 1) 860 { 861 return AVCDEC_FAIL; /* out of range */ 862 } 863 if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1 && 864 sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum / 2 - 2) 865 { 866 return AVCDEC_FAIL; /* out of range */ 867 } 868 } 869 else if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 2) 870 { 871 ue_v(stream, &(sliceHdr->long_term_pic_num_l0[i])); 872 } 873 i++; 874 } 875 while (sliceHdr->reordering_of_pic_nums_idc_l0[i-1] != 3 876 && i <= (int)sliceHdr->num_ref_idx_l0_active_minus1 + 1) ; 877 } 878 } 879 return AVCDEC_SUCCESS; 880 } 881 882 /** see subclause 7.4.3.3 */ 883 AVCDec_Status dec_ref_pic_marking(AVCCommonObj *video, AVCDecBitstream *stream, AVCSliceHeader *sliceHdr) 884 { 885 int i; 886 if (video->nal_unit_type == AVC_NALTYPE_IDR) 887 { 888 BitstreamRead1Bit(stream, &(sliceHdr->no_output_of_prior_pics_flag)); 889 BitstreamRead1Bit(stream, &(sliceHdr->long_term_reference_flag)); 890 if (sliceHdr->long_term_reference_flag == 0) /* used for short-term */ 891 { 892 video->MaxLongTermFrameIdx = -1; /* no long-term frame indx */ 893 } 894 else /* used for long-term */ 895 { 896 video->MaxLongTermFrameIdx = 0; 897 video->LongTermFrameIdx = 0; 898 } 899 } 900 else 901 { 902 BitstreamRead1Bit(stream, &(sliceHdr->adaptive_ref_pic_marking_mode_flag)); 903 if (sliceHdr->adaptive_ref_pic_marking_mode_flag) 904 { 905 i = 0; 906 do 907 { 908 ue_v(stream, &(sliceHdr->memory_management_control_operation[i])); 909 if (sliceHdr->memory_management_control_operation[i] == 1 || 910 sliceHdr->memory_management_control_operation[i] == 3) 911 { 912 ue_v(stream, &(sliceHdr->difference_of_pic_nums_minus1[i])); 913 } 914 if (sliceHdr->memory_management_control_operation[i] == 2) 915 { 916 ue_v(stream, &(sliceHdr->long_term_pic_num[i])); 917 } 918 if (sliceHdr->memory_management_control_operation[i] == 3 || 919 sliceHdr->memory_management_control_operation[i] == 6) 920 { 921 ue_v(stream, &(sliceHdr->long_term_frame_idx[i])); 922 } 923 if (sliceHdr->memory_management_control_operation[i] == 4) 924 { 925 ue_v(stream, &(sliceHdr->max_long_term_frame_idx_plus1[i])); 926 } 927 i++; 928 } 929 while (sliceHdr->memory_management_control_operation[i-1] != 0 && i < MAX_DEC_REF_PIC_MARKING); 930 if (i >= MAX_DEC_REF_PIC_MARKING) 931 { 932 return AVCDEC_FAIL; /* we're screwed!!, not enough memory */ 933 } 934 } 935 } 936 937 return AVCDEC_SUCCESS; 938 } 939 940 /* see subclause 8.2.1 Decoding process for picture order count. */ 941 AVCDec_Status DecodePOC(AVCCommonObj *video) 942 { 943 AVCSeqParamSet *currSPS = video->currSeqParams; 944 AVCSliceHeader *sliceHdr = video->sliceHdr; 945 int i; 946 947 switch (currSPS->pic_order_cnt_type) 948 { 949 case 0: /* POC MODE 0 , subclause 8.2.1.1 */ 950 if (video->nal_unit_type == AVC_NALTYPE_IDR) 951 { 952 video->prevPicOrderCntMsb = 0; 953 video->prevPicOrderCntLsb = 0; 954 } 955 956 /* Calculate the MSBs of current picture */ 957 if (sliceHdr->pic_order_cnt_lsb < video->prevPicOrderCntLsb && 958 (video->prevPicOrderCntLsb - sliceHdr->pic_order_cnt_lsb) >= (video->MaxPicOrderCntLsb / 2)) 959 video->PicOrderCntMsb = video->prevPicOrderCntMsb + video->MaxPicOrderCntLsb; 960 else if (sliceHdr->pic_order_cnt_lsb > video->prevPicOrderCntLsb && 961 (sliceHdr->pic_order_cnt_lsb - video->prevPicOrderCntLsb) > (video->MaxPicOrderCntLsb / 2)) 962 video->PicOrderCntMsb = video->prevPicOrderCntMsb - video->MaxPicOrderCntLsb; 963 else 964 video->PicOrderCntMsb = video->prevPicOrderCntMsb; 965 966 /* JVT-I010 page 81 is different from JM7.3 */ 967 968 969 video->PicOrderCnt = video->TopFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb; 970 video->BottomFieldOrderCnt = video->TopFieldOrderCnt + sliceHdr->delta_pic_order_cnt_bottom; 971 972 break; 973 974 975 case 1: /* POC MODE 1, subclause 8.2.1.2 */ 976 /* calculate FrameNumOffset */ 977 if (video->nal_unit_type == AVC_NALTYPE_IDR) 978 { 979 video->prevFrameNumOffset = 0; 980 video->FrameNumOffset = 0; 981 } 982 else if (video->prevFrameNum > sliceHdr->frame_num) 983 { 984 video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum; 985 } 986 else 987 { 988 video->FrameNumOffset = video->prevFrameNumOffset; 989 } 990 /* calculate absFrameNum */ 991 if (currSPS->num_ref_frames_in_pic_order_cnt_cycle) 992 { 993 video->absFrameNum = video->FrameNumOffset + sliceHdr->frame_num; 994 } 995 else 996 { 997 video->absFrameNum = 0; 998 } 999 1000 if (video->absFrameNum > 0 && video->nal_ref_idc == 0) 1001 { 1002 video->absFrameNum--; 1003 } 1004 1005 /* derive picOrderCntCycleCnt and frameNumInPicOrderCntCycle */ 1006 if (video->absFrameNum > 0) 1007 { 1008 video->picOrderCntCycleCnt = (video->absFrameNum - 1) / currSPS->num_ref_frames_in_pic_order_cnt_cycle; 1009 video->frameNumInPicOrderCntCycle = (video->absFrameNum - 1) % currSPS->num_ref_frames_in_pic_order_cnt_cycle; 1010 } 1011 /* derive expectedDeltaPerPicOrderCntCycle */ 1012 video->expectedDeltaPerPicOrderCntCycle = 0; 1013 for (i = 0; i < (int)currSPS->num_ref_frames_in_pic_order_cnt_cycle; i++) 1014 { 1015 video->expectedDeltaPerPicOrderCntCycle += currSPS->offset_for_ref_frame[i]; 1016 } 1017 /* derive expectedPicOrderCnt */ 1018 if (video->absFrameNum) 1019 { 1020 video->expectedPicOrderCnt = video->picOrderCntCycleCnt * video->expectedDeltaPerPicOrderCntCycle; 1021 for (i = 0; i <= video->frameNumInPicOrderCntCycle; i++) 1022 { 1023 video->expectedPicOrderCnt += currSPS->offset_for_ref_frame[i]; 1024 } 1025 } 1026 else 1027 { 1028 video->expectedPicOrderCnt = 0; 1029 } 1030 1031 if (video->nal_ref_idc == 0) 1032 { 1033 video->expectedPicOrderCnt += currSPS->offset_for_non_ref_pic; 1034 } 1035 /* derive TopFieldOrderCnt and BottomFieldOrderCnt */ 1036 1037 video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0]; 1038 video->BottomFieldOrderCnt = video->TopFieldOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[1]; 1039 1040 video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt); 1041 1042 1043 break; 1044 1045 1046 case 2: /* POC MODE 2, subclause 8.2.1.3 */ 1047 if (video->nal_unit_type == AVC_NALTYPE_IDR) 1048 { 1049 video->FrameNumOffset = 0; 1050 } 1051 else if (video->prevFrameNum > sliceHdr->frame_num) 1052 { 1053 video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum; 1054 } 1055 else 1056 { 1057 video->FrameNumOffset = video->prevFrameNumOffset; 1058 } 1059 /* derive tempPicOrderCnt, we just use PicOrderCnt */ 1060 if (video->nal_unit_type == AVC_NALTYPE_IDR) 1061 { 1062 video->PicOrderCnt = 0; 1063 } 1064 else if (video->nal_ref_idc == 0) 1065 { 1066 video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num) - 1; 1067 } 1068 else 1069 { 1070 video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num); 1071 } 1072 video->TopFieldOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCnt; 1073 break; 1074 default: 1075 return AVCDEC_FAIL; 1076 } 1077 1078 return AVCDEC_SUCCESS; 1079 } 1080 1081 1082 AVCDec_Status DecodeSEI(AVCDecObject *decvid, AVCDecBitstream *stream) 1083 { 1084 OSCL_UNUSED_ARG(decvid); 1085 OSCL_UNUSED_ARG(stream); 1086 return AVCDEC_SUCCESS; 1087 } 1088 1089 AVCDec_Status sei_payload(AVCDecObject *decvid, AVCDecBitstream *stream, uint payloadType, uint payloadSize) 1090 { 1091 AVCDec_Status status = AVCDEC_SUCCESS; 1092 uint i; 1093 switch (payloadType) 1094 { 1095 case 0: 1096 /* buffering period SEI */ 1097 status = buffering_period(decvid, stream); 1098 break; 1099 case 1: 1100 /* picture timing SEI */ 1101 status = pic_timing(decvid, stream); 1102 break; 1103 case 2: 1104 1105 case 3: 1106 1107 case 4: 1108 1109 case 5: 1110 1111 case 8: 1112 1113 case 9: 1114 1115 case 10: 1116 1117 case 11: 1118 1119 case 12: 1120 1121 case 13: 1122 1123 case 14: 1124 1125 case 15: 1126 1127 case 16: 1128 1129 case 17: 1130 for (i = 0; i < payloadSize; i++) 1131 { 1132 BitstreamFlushBits(stream, 8); 1133 } 1134 break; 1135 case 6: 1136 /* recovery point SEI */ 1137 status = recovery_point(decvid, stream); 1138 break; 1139 case 7: 1140 /* decoded reference picture marking repetition SEI */ 1141 status = dec_ref_pic_marking_repetition(decvid, stream); 1142 break; 1143 1144 case 18: 1145 /* motion-constrained slice group set SEI */ 1146 status = motion_constrained_slice_group_set(decvid, stream); 1147 break; 1148 default: 1149 /* reserved_sei_message */ 1150 for (i = 0; i < payloadSize; i++) 1151 { 1152 BitstreamFlushBits(stream, 8); 1153 } 1154 break; 1155 } 1156 BitstreamByteAlign(stream); 1157 return status; 1158 } 1159 1160 AVCDec_Status buffering_period(AVCDecObject *decvid, AVCDecBitstream *stream) 1161 { 1162 AVCSeqParamSet *currSPS; 1163 uint seq_parameter_set_id; 1164 uint temp; 1165 uint i; 1166 ue_v(stream, &seq_parameter_set_id); 1167 if (seq_parameter_set_id > 31) 1168 { 1169 return AVCDEC_FAIL; 1170 } 1171 1172 // decvid->common->seq_parameter_set_id = seq_parameter_set_id; 1173 1174 currSPS = decvid->seqParams[seq_parameter_set_id]; 1175 if (currSPS->vui_parameters.nal_hrd_parameters_present_flag) 1176 { 1177 for (i = 0; i <= currSPS->vui_parameters.nal_hrd_parameters.cpb_cnt_minus1; i++) 1178 { 1179 /* initial_cpb_removal_delay[i] */ 1180 BitstreamReadBits(stream, currSPS->vui_parameters.nal_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1181 /*initial _cpb_removal_delay_offset[i] */ 1182 BitstreamReadBits(stream, currSPS->vui_parameters.nal_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1183 } 1184 } 1185 1186 if (currSPS->vui_parameters.vcl_hrd_parameters_present_flag) 1187 { 1188 for (i = 0; i <= currSPS->vui_parameters.vcl_hrd_parameters.cpb_cnt_minus1; i++) 1189 { 1190 /* initial_cpb_removal_delay[i] */ 1191 BitstreamReadBits(stream, currSPS->vui_parameters.vcl_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1192 /*initial _cpb_removal_delay_offset[i] */ 1193 BitstreamReadBits(stream, currSPS->vui_parameters.vcl_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1194 } 1195 } 1196 1197 return AVCDEC_SUCCESS; 1198 } 1199 AVCDec_Status pic_timing(AVCDecObject *decvid, AVCDecBitstream *stream) 1200 { 1201 AVCSeqParamSet *currSPS; 1202 uint temp, NumClockTs = 0, time_offset_length = 24, full_timestamp_flag; 1203 uint i; 1204 1205 currSPS = decvid->seqParams[decvid->common->seq_parameter_set_id]; 1206 1207 if (currSPS->vui_parameters.nal_hrd_parameters_present_flag) 1208 { 1209 BitstreamReadBits(stream, currSPS->vui_parameters.nal_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1210 BitstreamReadBits(stream, currSPS->vui_parameters.nal_hrd_parameters.dpb_output_delay_length_minus1 + 1, &temp); 1211 time_offset_length = currSPS->vui_parameters.nal_hrd_parameters.time_offset_length; 1212 } 1213 else if (currSPS->vui_parameters.vcl_hrd_parameters_present_flag) 1214 { 1215 BitstreamReadBits(stream, currSPS->vui_parameters.vcl_hrd_parameters.cpb_removal_delay_length_minus1 + 1, &temp); 1216 BitstreamReadBits(stream, currSPS->vui_parameters.vcl_hrd_parameters.dpb_output_delay_length_minus1 + 1, &temp); 1217 time_offset_length = currSPS->vui_parameters.vcl_hrd_parameters.time_offset_length; 1218 } 1219 1220 if (currSPS->vui_parameters.pic_struct_present_flag) 1221 { 1222 /* pic_struct */ 1223 BitstreamReadBits(stream, 4, &temp); 1224 1225 switch (temp) 1226 { 1227 case 0: 1228 case 1: 1229 case 2: 1230 NumClockTs = 1; 1231 break; 1232 case 3: 1233 case 4: 1234 case 7: 1235 NumClockTs = 2; 1236 break; 1237 case 5: 1238 case 6: 1239 case 8: 1240 NumClockTs = 3; 1241 break; 1242 default: 1243 NumClockTs = 0; 1244 break; 1245 } 1246 1247 for (i = 0; i < NumClockTs; i++) 1248 { 1249 /* clock_timestamp_flag[i] */ 1250 BitstreamRead1Bit(stream, &temp); 1251 if (temp) 1252 { 1253 /* ct_type */ 1254 BitstreamReadBits(stream, 2, &temp); 1255 /* nuit_field_based_flag */ 1256 BitstreamRead1Bit(stream, &temp); 1257 /* counting_type */ 1258 BitstreamReadBits(stream, 5, &temp); 1259 /* full_timestamp_flag */ 1260 BitstreamRead1Bit(stream, &temp); 1261 full_timestamp_flag = temp; 1262 /* discontinuity_flag */ 1263 BitstreamRead1Bit(stream, &temp); 1264 /* cnt_dropped_flag */ 1265 BitstreamRead1Bit(stream, &temp); 1266 /* n_frames */ 1267 BitstreamReadBits(stream, 8, &temp); 1268 1269 1270 if (full_timestamp_flag) 1271 { 1272 /* seconds_value */ 1273 BitstreamReadBits(stream, 6, &temp); 1274 /* minutes_value */ 1275 BitstreamReadBits(stream, 6, &temp); 1276 /* hours_value */ 1277 BitstreamReadBits(stream, 5, &temp); 1278 } 1279 else 1280 { 1281 /* seconds_flag */ 1282 BitstreamRead1Bit(stream, &temp); 1283 if (temp) 1284 { 1285 /* seconds_value */ 1286 BitstreamReadBits(stream, 6, &temp); 1287 /* minutes_flag */ 1288 BitstreamRead1Bit(stream, &temp); 1289 if (temp) 1290 { 1291 /* minutes_value */ 1292 BitstreamReadBits(stream, 6, &temp); 1293 1294 /* hourss_flag */ 1295 BitstreamRead1Bit(stream, &temp); 1296 1297 if (temp) 1298 { 1299 /* hours_value */ 1300 BitstreamReadBits(stream, 5, &temp); 1301 } 1302 1303 } 1304 } 1305 } 1306 1307 if (time_offset_length) 1308 { 1309 /* time_offset */ 1310 BitstreamReadBits(stream, time_offset_length, &temp); 1311 } 1312 else 1313 { 1314 /* time_offset */ 1315 temp = 0; 1316 } 1317 } 1318 } 1319 } 1320 return AVCDEC_SUCCESS; 1321 } 1322 AVCDec_Status recovery_point(AVCDecObject *decvid, AVCDecBitstream *stream) 1323 { 1324 OSCL_UNUSED_ARG(decvid); 1325 uint temp; 1326 /* recover_frame_cnt */ 1327 ue_v(stream, &temp); 1328 /* exact_match_flag */ 1329 BitstreamRead1Bit(stream, &temp); 1330 /* broken_link_flag */ 1331 BitstreamRead1Bit(stream, &temp); 1332 /* changing slic_group_idc */ 1333 BitstreamReadBits(stream, 2, &temp); 1334 return AVCDEC_SUCCESS; 1335 } 1336 AVCDec_Status dec_ref_pic_marking_repetition(AVCDecObject *decvid, AVCDecBitstream *stream) 1337 { 1338 AVCSeqParamSet *currSPS; 1339 uint temp; 1340 currSPS = decvid->seqParams[decvid->common->seq_parameter_set_id]; 1341 /* original_idr_flag */ 1342 BitstreamRead1Bit(stream, &temp); 1343 /* original_frame_num */ 1344 ue_v(stream, &temp); 1345 if (currSPS->frame_mbs_only_flag == 0) 1346 { 1347 /* original_field_pic_flag */ 1348 BitstreamRead1Bit(stream, &temp); 1349 if (temp) 1350 { 1351 /* original_bottom_field_flag */ 1352 BitstreamRead1Bit(stream, &temp); 1353 } 1354 } 1355 1356 /* dec_ref_pic_marking(video,stream,sliceHdr); */ 1357 1358 1359 return AVCDEC_SUCCESS; 1360 } 1361 AVCDec_Status motion_constrained_slice_group_set(AVCDecObject *decvid, AVCDecBitstream *stream) 1362 { 1363 OSCL_UNUSED_ARG(decvid); 1364 uint temp, i, numBits; 1365 /* num_slice_groups_in_set_minus1 */ 1366 ue_v(stream, &temp); 1367 1368 numBits = 0;/* ceil(log2(num_slice_groups_minus1+1)) bits */ 1369 i = temp; 1370 while (i > 0) 1371 { 1372 numBits++; 1373 i >>= 1; 1374 } 1375 for (i = 0; i <= temp; i++) 1376 { 1377 /* slice_group_id */ 1378 BitstreamReadBits(stream, numBits, &temp); 1379 } 1380 /* exact_sample_value_match_flag */ 1381 BitstreamRead1Bit(stream, &temp); 1382 /* pan_scan_rect_flag */ 1383 BitstreamRead1Bit(stream, &temp); 1384 if (temp) 1385 { 1386 /* pan_scan_rect_id */ 1387 ue_v(stream, &temp); 1388 } 1389 1390 return AVCDEC_SUCCESS; 1391 } 1392 1393
