1 /* 2 * Copyright (C) 2009 The Android Open Source Project 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 express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /*------------------------------------------------------------------------------ 18 19 Table of contents 20 21 1. Include headers 22 2. External compiler flags 23 3. Module defines 24 4. Local function prototypes 25 5. Functions 26 h264bsdInit 27 h264bsdDecode 28 h264bsdShutdown 29 h264bsdCurrentImage 30 h264bsdNextOutputPicture 31 h264bsdPicWidth 32 h264bsdPicHeight 33 h264bsdFlushBuffer 34 h264bsdCheckValidParamSets 35 h264bsdVideoRange 36 h264bsdMatrixCoefficients 37 h264bsdCroppingParams 38 39 ------------------------------------------------------------------------------*/ 40 41 /*------------------------------------------------------------------------------ 42 1. Include headers 43 ------------------------------------------------------------------------------*/ 44 45 #include "h264bsd_decoder.h" 46 #include "h264bsd_nal_unit.h" 47 #include "h264bsd_byte_stream.h" 48 #include "h264bsd_seq_param_set.h" 49 #include "h264bsd_pic_param_set.h" 50 #include "h264bsd_slice_header.h" 51 #include "h264bsd_slice_data.h" 52 #include "h264bsd_neighbour.h" 53 #include "h264bsd_util.h" 54 #include "h264bsd_dpb.h" 55 #include "h264bsd_deblocking.h" 56 #include "h264bsd_conceal.h" 57 58 /*------------------------------------------------------------------------------ 59 2. External compiler flags 60 -------------------------------------------------------------------------------- 61 62 -------------------------------------------------------------------------------- 63 3. Module defines 64 ------------------------------------------------------------------------------*/ 65 66 /*------------------------------------------------------------------------------ 67 4. Local function prototypes 68 ------------------------------------------------------------------------------*/ 69 70 /*------------------------------------------------------------------------------ 71 72 Function name: h264bsdInit 73 74 Functional description: 75 Initialize the decoder. 76 77 Inputs: 78 noOutputReordering flag to indicate the decoder that it does not 79 have to perform reordering of display images. 80 81 Outputs: 82 pStorage pointer to initialized storage structure 83 84 Returns: 85 none 86 87 ------------------------------------------------------------------------------*/ 88 89 u32 h264bsdInit(storage_t *pStorage, u32 noOutputReordering) 90 { 91 92 /* Variables */ 93 u32 size; 94 /* Code */ 95 96 ASSERT(pStorage); 97 98 h264bsdInitStorage(pStorage); 99 100 /* allocate mbLayer to be next multiple of 64 to enable use of 101 * specific NEON optimized "memset" for clearing the structure */ 102 size = (sizeof(macroblockLayer_t) + 63) & ~0x3F; 103 104 pStorage->mbLayer = (macroblockLayer_t*)H264SwDecMalloc(size, 1); 105 if (!pStorage->mbLayer) 106 return HANTRO_NOK; 107 108 if (noOutputReordering) 109 pStorage->noReordering = HANTRO_TRUE; 110 111 return HANTRO_OK; 112 } 113 114 /*------------------------------------------------------------------------------ 115 116 Function: h264bsdDecode 117 118 Functional description: 119 Decode a NAL unit. This function calls other modules to perform 120 tasks like 121 * extract and decode NAL unit from the byte stream 122 * decode parameter sets 123 * decode slice header and slice data 124 * conceal errors in the picture 125 * perform deblocking filtering 126 127 This function contains top level control logic of the decoder. 128 129 Inputs: 130 pStorage pointer to storage data structure 131 byteStrm pointer to stream buffer given by application 132 len length of the buffer in bytes 133 picId identifier for a picture, assigned by the 134 application 135 136 Outputs: 137 readBytes number of bytes read from the stream is stored 138 here 139 140 Returns: 141 H264BSD_RDY decoding finished, nothing special 142 H264BSD_PIC_RDY decoding of a picture finished 143 H264BSD_HDRS_RDY param sets activated, information like 144 picture dimensions etc can be read 145 H264BSD_ERROR error in decoding 146 H264BSD_PARAM_SET_ERROR serius error in decoding, failed to 147 activate param sets 148 149 ------------------------------------------------------------------------------*/ 150 151 u32 h264bsdDecode(storage_t *pStorage, u8 *byteStrm, u32 len, u32 picId, 152 u32 *readBytes) 153 { 154 155 /* Variables */ 156 157 u32 tmp, ppsId, spsId; 158 i32 picOrderCnt; 159 nalUnit_t nalUnit; 160 seqParamSet_t seqParamSet; 161 picParamSet_t picParamSet; 162 strmData_t strm; 163 u32 accessUnitBoundaryFlag = HANTRO_FALSE; 164 u32 picReady = HANTRO_FALSE; 165 166 /* Code */ 167 168 ASSERT(pStorage); 169 ASSERT(byteStrm); 170 ASSERT(len); 171 ASSERT(readBytes); 172 173 /* if previous buffer was not finished and same pointer given -> skip NAL 174 * unit extraction */ 175 if (pStorage->prevBufNotFinished && byteStrm == pStorage->prevBufPointer) 176 { 177 strm = pStorage->strm[0]; 178 strm.pStrmCurrPos = strm.pStrmBuffStart; 179 strm.strmBuffReadBits = strm.bitPosInWord = 0; 180 *readBytes = pStorage->prevBytesConsumed; 181 } 182 else 183 { 184 tmp = h264bsdExtractNalUnit(byteStrm, len, &strm, readBytes); 185 if (tmp != HANTRO_OK) 186 { 187 EPRINT("BYTE_STREAM"); 188 return(H264BSD_ERROR); 189 } 190 /* store stream */ 191 pStorage->strm[0] = strm; 192 pStorage->prevBytesConsumed = *readBytes; 193 pStorage->prevBufPointer = byteStrm; 194 } 195 pStorage->prevBufNotFinished = HANTRO_FALSE; 196 197 tmp = h264bsdDecodeNalUnit(&strm, &nalUnit); 198 if (tmp != HANTRO_OK) 199 { 200 EPRINT("NAL_UNIT"); 201 return(H264BSD_ERROR); 202 } 203 204 /* Discard unspecified, reserved, SPS extension and auxiliary picture slices */ 205 if(nalUnit.nalUnitType == 0 || nalUnit.nalUnitType >= 13) 206 { 207 DEBUG(("DISCARDED NAL (UNSPECIFIED, REGISTERED, SPS ext or AUX slice)\n")); 208 return(H264BSD_RDY); 209 } 210 211 tmp = h264bsdCheckAccessUnitBoundary( 212 &strm, 213 &nalUnit, 214 pStorage, 215 &accessUnitBoundaryFlag); 216 if (tmp != HANTRO_OK) 217 { 218 EPRINT("ACCESS UNIT BOUNDARY CHECK"); 219 if (tmp == PARAM_SET_ERROR) 220 return(H264BSD_PARAM_SET_ERROR); 221 else 222 return(H264BSD_ERROR); 223 } 224 225 if ( accessUnitBoundaryFlag ) 226 { 227 DEBUG(("Access unit boundary\n")); 228 /* conceal if picture started and param sets activated */ 229 if (pStorage->picStarted && pStorage->activeSps != NULL) 230 { 231 DEBUG(("CONCEALING...")); 232 233 /* return error if second phase of 234 * initialization is not completed */ 235 if (pStorage->pendingActivation) 236 { 237 EPRINT("Pending activation not completed"); 238 return (H264BSD_ERROR); 239 } 240 241 if (!pStorage->validSliceInAccessUnit) 242 { 243 pStorage->currImage->data = 244 h264bsdAllocateDpbImage(pStorage->dpb); 245 h264bsdInitRefPicList(pStorage->dpb); 246 tmp = h264bsdConceal(pStorage, pStorage->currImage, P_SLICE); 247 } 248 else 249 tmp = h264bsdConceal(pStorage, pStorage->currImage, 250 pStorage->sliceHeader->sliceType); 251 252 picReady = HANTRO_TRUE; 253 254 /* current NAL unit should be decoded on next activation -> set 255 * readBytes to 0 */ 256 *readBytes = 0; 257 pStorage->prevBufNotFinished = HANTRO_TRUE; 258 DEBUG(("...DONE\n")); 259 } 260 else 261 { 262 pStorage->validSliceInAccessUnit = HANTRO_FALSE; 263 } 264 pStorage->skipRedundantSlices = HANTRO_FALSE; 265 } 266 267 if (!picReady) 268 { 269 switch (nalUnit.nalUnitType) 270 { 271 case NAL_SEQ_PARAM_SET: 272 DEBUG(("SEQ PARAM SET\n")); 273 tmp = h264bsdDecodeSeqParamSet(&strm, &seqParamSet); 274 if (tmp != HANTRO_OK) 275 { 276 EPRINT("SEQ_PARAM_SET"); 277 FREE(seqParamSet.offsetForRefFrame); 278 FREE(seqParamSet.vuiParameters); 279 return(H264BSD_ERROR); 280 } 281 tmp = h264bsdStoreSeqParamSet(pStorage, &seqParamSet); 282 break; 283 284 case NAL_PIC_PARAM_SET: 285 DEBUG(("PIC PARAM SET\n")); 286 tmp = h264bsdDecodePicParamSet(&strm, &picParamSet); 287 if (tmp != HANTRO_OK) 288 { 289 EPRINT("PIC_PARAM_SET"); 290 FREE(picParamSet.runLength); 291 FREE(picParamSet.topLeft); 292 FREE(picParamSet.bottomRight); 293 FREE(picParamSet.sliceGroupId); 294 return(H264BSD_ERROR); 295 } 296 tmp = h264bsdStorePicParamSet(pStorage, &picParamSet); 297 break; 298 299 case NAL_CODED_SLICE_IDR: 300 DEBUG(("IDR ")); 301 /* fall through */ 302 case NAL_CODED_SLICE: 303 DEBUG(("SLICE HEADER\n")); 304 305 /* picture successfully finished and still decoding same old 306 * access unit -> no need to decode redundant slices */ 307 if (pStorage->skipRedundantSlices) 308 return(H264BSD_RDY); 309 310 pStorage->picStarted = HANTRO_TRUE; 311 312 if (h264bsdIsStartOfPicture(pStorage)) 313 { 314 pStorage->numConcealedMbs = 0; 315 pStorage->currentPicId = picId; 316 317 tmp = h264bsdCheckPpsId(&strm, &ppsId); 318 ASSERT(tmp == HANTRO_OK); 319 /* store old activeSpsId and return headers ready 320 * indication if activeSps changes */ 321 spsId = pStorage->activeSpsId; 322 tmp = h264bsdActivateParamSets(pStorage, ppsId, 323 IS_IDR_NAL_UNIT(&nalUnit) ? 324 HANTRO_TRUE : HANTRO_FALSE); 325 if (tmp != HANTRO_OK) 326 { 327 EPRINT("Param set activation"); 328 pStorage->activePpsId = MAX_NUM_PIC_PARAM_SETS; 329 pStorage->activePps = NULL; 330 pStorage->activeSpsId = MAX_NUM_SEQ_PARAM_SETS; 331 pStorage->activeSps = NULL; 332 pStorage->pendingActivation = HANTRO_FALSE; 333 334 if(tmp == MEMORY_ALLOCATION_ERROR) 335 { 336 return H264BSD_MEMALLOC_ERROR; 337 } 338 else 339 return(H264BSD_PARAM_SET_ERROR); 340 } 341 342 if (spsId != pStorage->activeSpsId) 343 { 344 seqParamSet_t *oldSPS = NULL; 345 seqParamSet_t *newSPS = pStorage->activeSps; 346 u32 noOutputOfPriorPicsFlag = 1; 347 348 if(pStorage->oldSpsId < MAX_NUM_SEQ_PARAM_SETS) 349 { 350 oldSPS = pStorage->sps[pStorage->oldSpsId]; 351 } 352 353 *readBytes = 0; 354 pStorage->prevBufNotFinished = HANTRO_TRUE; 355 356 357 if(nalUnit.nalUnitType == NAL_CODED_SLICE_IDR) 358 { 359 tmp = 360 h264bsdCheckPriorPicsFlag(&noOutputOfPriorPicsFlag, 361 &strm, newSPS, 362 pStorage->activePps, 363 nalUnit.nalUnitType); 364 } 365 else 366 { 367 tmp = HANTRO_NOK; 368 } 369 370 if((tmp != HANTRO_OK) || 371 (noOutputOfPriorPicsFlag != 0) || 372 (pStorage->dpb->noReordering) || 373 (oldSPS == NULL) || 374 (oldSPS->picWidthInMbs != newSPS->picWidthInMbs) || 375 (oldSPS->picHeightInMbs != newSPS->picHeightInMbs) || 376 (oldSPS->maxDpbSize != newSPS->maxDpbSize)) 377 { 378 pStorage->dpb->flushed = 0; 379 } 380 else 381 { 382 h264bsdFlushDpb(pStorage->dpb); 383 } 384 385 pStorage->oldSpsId = pStorage->activeSpsId; 386 387 return(H264BSD_HDRS_RDY); 388 } 389 } 390 391 /* return error if second phase of 392 * initialization is not completed */ 393 if (pStorage->pendingActivation) 394 { 395 EPRINT("Pending activation not completed"); 396 return (H264BSD_ERROR); 397 } 398 tmp = h264bsdDecodeSliceHeader(&strm, pStorage->sliceHeader + 1, 399 pStorage->activeSps, pStorage->activePps, &nalUnit); 400 if (tmp != HANTRO_OK) 401 { 402 EPRINT("SLICE_HEADER"); 403 return(H264BSD_ERROR); 404 } 405 if (h264bsdIsStartOfPicture(pStorage)) 406 { 407 if (!IS_IDR_NAL_UNIT(&nalUnit)) 408 { 409 tmp = h264bsdCheckGapsInFrameNum(pStorage->dpb, 410 pStorage->sliceHeader[1].frameNum, 411 nalUnit.nalRefIdc != 0 ? 412 HANTRO_TRUE : HANTRO_FALSE, 413 pStorage->activeSps-> 414 gapsInFrameNumValueAllowedFlag); 415 if (tmp != HANTRO_OK) 416 { 417 EPRINT("Gaps in frame num"); 418 return(H264BSD_ERROR); 419 } 420 } 421 pStorage->currImage->data = 422 h264bsdAllocateDpbImage(pStorage->dpb); 423 } 424 425 /* store slice header to storage if successfully decoded */ 426 pStorage->sliceHeader[0] = pStorage->sliceHeader[1]; 427 pStorage->validSliceInAccessUnit = HANTRO_TRUE; 428 pStorage->prevNalUnit[0] = nalUnit; 429 430 h264bsdComputeSliceGroupMap(pStorage, 431 pStorage->sliceHeader->sliceGroupChangeCycle); 432 433 h264bsdInitRefPicList(pStorage->dpb); 434 tmp = h264bsdReorderRefPicList(pStorage->dpb, 435 &pStorage->sliceHeader->refPicListReordering, 436 pStorage->sliceHeader->frameNum, 437 pStorage->sliceHeader->numRefIdxL0Active); 438 if (tmp != HANTRO_OK) 439 { 440 EPRINT("Reordering"); 441 return(H264BSD_ERROR); 442 } 443 444 DEBUG(("SLICE DATA, FIRST %d\n", 445 pStorage->sliceHeader->firstMbInSlice)); 446 tmp = h264bsdDecodeSliceData(&strm, pStorage, 447 pStorage->currImage, pStorage->sliceHeader); 448 if (tmp != HANTRO_OK) 449 { 450 EPRINT("SLICE_DATA"); 451 h264bsdMarkSliceCorrupted(pStorage, 452 pStorage->sliceHeader->firstMbInSlice); 453 return(H264BSD_ERROR); 454 } 455 456 if (h264bsdIsEndOfPicture(pStorage)) 457 { 458 picReady = HANTRO_TRUE; 459 pStorage->skipRedundantSlices = HANTRO_TRUE; 460 } 461 break; 462 463 case NAL_SEI: 464 DEBUG(("SEI MESSAGE, NOT DECODED")); 465 break; 466 467 default: 468 DEBUG(("NOT IMPLEMENTED YET %d\n",nalUnit.nalUnitType)); 469 } 470 } 471 472 if (picReady) 473 { 474 h264bsdFilterPicture(pStorage->currImage, pStorage->mb); 475 476 h264bsdResetStorage(pStorage); 477 478 picOrderCnt = h264bsdDecodePicOrderCnt(pStorage->poc, 479 pStorage->activeSps, pStorage->sliceHeader, pStorage->prevNalUnit); 480 481 if (pStorage->validSliceInAccessUnit) 482 { 483 if (pStorage->prevNalUnit->nalRefIdc) 484 { 485 tmp = h264bsdMarkDecRefPic(pStorage->dpb, 486 &pStorage->sliceHeader->decRefPicMarking, 487 pStorage->currImage, pStorage->sliceHeader->frameNum, 488 picOrderCnt, 489 IS_IDR_NAL_UNIT(pStorage->prevNalUnit) ? 490 HANTRO_TRUE : HANTRO_FALSE, 491 pStorage->currentPicId, pStorage->numConcealedMbs); 492 } 493 /* non-reference picture, just store for possible display 494 * reordering */ 495 else 496 { 497 tmp = h264bsdMarkDecRefPic(pStorage->dpb, NULL, 498 pStorage->currImage, pStorage->sliceHeader->frameNum, 499 picOrderCnt, 500 IS_IDR_NAL_UNIT(pStorage->prevNalUnit) ? 501 HANTRO_TRUE : HANTRO_FALSE, 502 pStorage->currentPicId, pStorage->numConcealedMbs); 503 } 504 } 505 506 pStorage->picStarted = HANTRO_FALSE; 507 pStorage->validSliceInAccessUnit = HANTRO_FALSE; 508 509 return(H264BSD_PIC_RDY); 510 } 511 else 512 return(H264BSD_RDY); 513 514 } 515 516 /*------------------------------------------------------------------------------ 517 518 Function: h264bsdShutdown 519 520 Functional description: 521 Shutdown a decoder instance. Function frees all the memories 522 allocated for the decoder instance. 523 524 Inputs: 525 pStorage pointer to storage data structure 526 527 Returns: 528 none 529 530 531 ------------------------------------------------------------------------------*/ 532 533 void h264bsdShutdown(storage_t *pStorage) 534 { 535 536 /* Variables */ 537 538 u32 i; 539 540 /* Code */ 541 542 ASSERT(pStorage); 543 544 for (i = 0; i < MAX_NUM_SEQ_PARAM_SETS; i++) 545 { 546 if (pStorage->sps[i]) 547 { 548 FREE(pStorage->sps[i]->offsetForRefFrame); 549 FREE(pStorage->sps[i]->vuiParameters); 550 FREE(pStorage->sps[i]); 551 } 552 } 553 554 for (i = 0; i < MAX_NUM_PIC_PARAM_SETS; i++) 555 { 556 if (pStorage->pps[i]) 557 { 558 FREE(pStorage->pps[i]->runLength); 559 FREE(pStorage->pps[i]->topLeft); 560 FREE(pStorage->pps[i]->bottomRight); 561 FREE(pStorage->pps[i]->sliceGroupId); 562 FREE(pStorage->pps[i]); 563 } 564 } 565 566 FREE(pStorage->mbLayer); 567 FREE(pStorage->mb); 568 FREE(pStorage->sliceGroupMap); 569 570 h264bsdFreeDpb(pStorage->dpb); 571 572 } 573 574 /*------------------------------------------------------------------------------ 575 576 Function: h264bsdNextOutputPicture 577 578 Functional description: 579 Get next output picture in display order. 580 581 Inputs: 582 pStorage pointer to storage data structure 583 584 Outputs: 585 picId identifier of the picture will be stored here 586 isIdrPic IDR flag of the picture will be stored here 587 numErrMbs number of concealed macroblocks in the picture 588 will be stored here 589 590 Returns: 591 pointer to the picture data 592 NULL if no pictures available for display 593 594 ------------------------------------------------------------------------------*/ 595 596 u8* h264bsdNextOutputPicture(storage_t *pStorage, u32 *picId, u32 *isIdrPic, 597 u32 *numErrMbs) 598 { 599 600 /* Variables */ 601 602 dpbOutPicture_t *pOut; 603 604 /* Code */ 605 606 ASSERT(pStorage); 607 608 pOut = h264bsdDpbOutputPicture(pStorage->dpb); 609 610 if (pOut != NULL) 611 { 612 *picId = pOut->picId; 613 *isIdrPic = pOut->isIdr; 614 *numErrMbs = pOut->numErrMbs; 615 return (pOut->data); 616 } 617 else 618 return(NULL); 619 620 } 621 622 /*------------------------------------------------------------------------------ 623 624 Function: h264bsdPicWidth 625 626 Functional description: 627 Get width of the picture in macroblocks 628 629 Inputs: 630 pStorage pointer to storage data structure 631 632 Outputs: 633 none 634 635 Returns: 636 picture width 637 0 if parameters sets not yet activated 638 639 ------------------------------------------------------------------------------*/ 640 641 u32 h264bsdPicWidth(storage_t *pStorage) 642 { 643 644 /* Variables */ 645 646 /* Code */ 647 648 ASSERT(pStorage); 649 650 if (pStorage->activeSps) 651 return(pStorage->activeSps->picWidthInMbs); 652 else 653 return(0); 654 655 } 656 657 /*------------------------------------------------------------------------------ 658 659 Function: h264bsdPicHeight 660 661 Functional description: 662 Get height of the picture in macroblocks 663 664 Inputs: 665 pStorage pointer to storage data structure 666 667 Outputs: 668 none 669 670 Returns: 671 picture width 672 0 if parameters sets not yet activated 673 674 ------------------------------------------------------------------------------*/ 675 676 u32 h264bsdPicHeight(storage_t *pStorage) 677 { 678 679 /* Variables */ 680 681 /* Code */ 682 683 ASSERT(pStorage); 684 685 if (pStorage->activeSps) 686 return(pStorage->activeSps->picHeightInMbs); 687 else 688 return(0); 689 690 } 691 692 /*------------------------------------------------------------------------------ 693 694 Function: h264bsdFlushBuffer 695 696 Functional description: 697 Flush the decoded picture buffer, see dpb.c for details 698 699 Inputs: 700 pStorage pointer to storage data structure 701 702 ------------------------------------------------------------------------------*/ 703 704 void h264bsdFlushBuffer(storage_t *pStorage) 705 { 706 707 /* Variables */ 708 709 /* Code */ 710 711 ASSERT(pStorage); 712 713 h264bsdFlushDpb(pStorage->dpb); 714 715 } 716 717 /*------------------------------------------------------------------------------ 718 719 Function: h264bsdCheckValidParamSets 720 721 Functional description: 722 Check if any valid parameter set combinations (SPS/PPS) exists. 723 724 Inputs: 725 pStorage pointer to storage structure 726 727 Returns: 728 1 at least one valid SPS/PPS combination found 729 0 no valid param set combinations found 730 731 732 ------------------------------------------------------------------------------*/ 733 734 u32 h264bsdCheckValidParamSets(storage_t *pStorage) 735 { 736 737 /* Variables */ 738 739 /* Code */ 740 741 ASSERT(pStorage); 742 743 return(h264bsdValidParamSets(pStorage) == HANTRO_OK ? 1 : 0); 744 745 } 746 747 /*------------------------------------------------------------------------------ 748 749 Function: h264bsdVideoRange 750 751 Functional description: 752 Get value of video_full_range_flag received in the VUI data. 753 754 Inputs: 755 pStorage pointer to storage structure 756 757 Returns: 758 1 video_full_range_flag received and value is 1 759 0 otherwise 760 761 ------------------------------------------------------------------------------*/ 762 763 u32 h264bsdVideoRange(storage_t *pStorage) 764 { 765 766 /* Variables */ 767 768 /* Code */ 769 770 ASSERT(pStorage); 771 772 if (pStorage->activeSps && pStorage->activeSps->vuiParametersPresentFlag && 773 pStorage->activeSps->vuiParameters && 774 pStorage->activeSps->vuiParameters->videoSignalTypePresentFlag && 775 pStorage->activeSps->vuiParameters->videoFullRangeFlag) 776 return(1); 777 else /* default value of video_full_range_flag is 0 */ 778 return(0); 779 780 } 781 782 /*------------------------------------------------------------------------------ 783 784 Function: h264bsdMatrixCoefficients 785 786 Functional description: 787 Get value of matrix_coefficients received in the VUI data 788 789 Inputs: 790 pStorage pointer to storage structure 791 792 Outputs: 793 value of matrix_coefficients if received 794 2 otherwise (this is the default value) 795 796 ------------------------------------------------------------------------------*/ 797 798 u32 h264bsdMatrixCoefficients(storage_t *pStorage) 799 { 800 801 /* Variables */ 802 803 /* Code */ 804 805 ASSERT(pStorage); 806 807 if (pStorage->activeSps && pStorage->activeSps->vuiParametersPresentFlag && 808 pStorage->activeSps->vuiParameters && 809 pStorage->activeSps->vuiParameters->videoSignalTypePresentFlag && 810 pStorage->activeSps->vuiParameters->colourDescriptionPresentFlag) 811 return(pStorage->activeSps->vuiParameters->matrixCoefficients); 812 else /* default unspecified */ 813 return(2); 814 815 } 816 817 /*------------------------------------------------------------------------------ 818 819 Function: hh264bsdCroppingParams 820 821 Functional description: 822 Get cropping parameters of the active SPS 823 824 Inputs: 825 pStorage pointer to storage structure 826 827 Outputs: 828 croppingFlag flag indicating if cropping params present is 829 stored here 830 leftOffset cropping left offset in pixels is stored here 831 width width of the image after cropping is stored here 832 topOffset cropping top offset in pixels is stored here 833 height height of the image after cropping is stored here 834 835 Returns: 836 none 837 838 ------------------------------------------------------------------------------*/ 839 840 void h264bsdCroppingParams(storage_t *pStorage, u32 *croppingFlag, 841 u32 *leftOffset, u32 *width, u32 *topOffset, u32 *height) 842 { 843 844 /* Variables */ 845 846 /* Code */ 847 848 ASSERT(pStorage); 849 850 if (pStorage->activeSps && pStorage->activeSps->frameCroppingFlag) 851 { 852 *croppingFlag = 1; 853 *leftOffset = 2 * pStorage->activeSps->frameCropLeftOffset; 854 *width = 16 * pStorage->activeSps->picWidthInMbs - 855 2 * (pStorage->activeSps->frameCropLeftOffset + 856 pStorage->activeSps->frameCropRightOffset); 857 *topOffset = 2 * pStorage->activeSps->frameCropTopOffset; 858 *height = 16 * pStorage->activeSps->picHeightInMbs - 859 2 * (pStorage->activeSps->frameCropTopOffset + 860 pStorage->activeSps->frameCropBottomOffset); 861 } 862 else 863 { 864 *croppingFlag = 0; 865 *leftOffset = 0; 866 *width = 0; 867 *topOffset = 0; 868 *height = 0; 869 } 870 871 } 872 873 /*------------------------------------------------------------------------------ 874 875 Function: h264bsdSampleAspectRatio 876 877 Functional description: 878 Get aspect ratio received in the VUI data 879 880 Inputs: 881 pStorage pointer to storage structure 882 883 Outputs: 884 sarWidth sample aspect ratio height 885 sarHeight sample aspect ratio width 886 887 ------------------------------------------------------------------------------*/ 888 889 void h264bsdSampleAspectRatio(storage_t *pStorage, u32 *sarWidth, u32 *sarHeight) 890 { 891 892 /* Variables */ 893 u32 w = 1; 894 u32 h = 1; 895 /* Code */ 896 897 ASSERT(pStorage); 898 899 900 if (pStorage->activeSps && 901 pStorage->activeSps->vuiParametersPresentFlag && 902 pStorage->activeSps->vuiParameters && 903 pStorage->activeSps->vuiParameters->aspectRatioPresentFlag ) 904 { 905 switch (pStorage->activeSps->vuiParameters->aspectRatioIdc) 906 { 907 case ASPECT_RATIO_UNSPECIFIED: w = 0; h = 0; break; 908 case ASPECT_RATIO_1_1: w = 1; h = 1; break; 909 case ASPECT_RATIO_12_11: w = 12; h = 11; break; 910 case ASPECT_RATIO_10_11: w = 10; h = 11; break; 911 case ASPECT_RATIO_16_11: w = 16; h = 11; break; 912 case ASPECT_RATIO_40_33: w = 40; h = 33; break; 913 case ASPECT_RATIO_24_11: w = 24; h = 11; break; 914 case ASPECT_RATIO_20_11: w = 20; h = 11; break; 915 case ASPECT_RATIO_32_11: w = 32; h = 11; break; 916 case ASPECT_RATIO_80_33: w = 80; h = 33; break; 917 case ASPECT_RATIO_18_11: w = 18; h = 11; break; 918 case ASPECT_RATIO_15_11: w = 15; h = 11; break; 919 case ASPECT_RATIO_64_33: w = 64; h = 33; break; 920 case ASPECT_RATIO_160_99: w = 160; h = 99; break; 921 case ASPECT_RATIO_EXTENDED_SAR: 922 w = pStorage->activeSps->vuiParameters->sarWidth; 923 h = pStorage->activeSps->vuiParameters->sarHeight; 924 if ((w == 0) || (h == 0)) 925 w = h = 0; 926 break; 927 default: 928 w = 0; 929 h = 0; 930 break; 931 } 932 } 933 934 /* set aspect ratio*/ 935 *sarWidth = w; 936 *sarHeight = h; 937 938 } 939 940 /*------------------------------------------------------------------------------ 941 942 Function: h264bsdProfile 943 944 Functional description: 945 Get profile information from active SPS 946 947 Inputs: 948 pStorage pointer to storage structure 949 950 Outputs: 951 profile current profile 952 953 ------------------------------------------------------------------------------*/ 954 u32 h264bsdProfile(storage_t *pStorage) 955 { 956 if (pStorage->activeSps) 957 return pStorage->activeSps->profileIdc; 958 else 959 return 0; 960 } 961 962
