1/* 2 * Copyright © 2014 Advanced Micro Devices, Inc. 3 * All Rights Reserved. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining 6 * a copy of this software and associated documentation files (the 7 * "Software"), to deal in the Software without restriction, including 8 * without limitation the rights to use, copy, modify, merge, publish, 9 * distribute, sub license, and/or sell copies of the Software, and to 10 * permit persons to whom the Software is furnished to do so, subject to 11 * the following conditions: 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 14 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 15 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 16 * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS 17 * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 20 * USE OR OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * The above copyright notice and this permission notice (including the 23 * next paragraph) shall be included in all copies or substantial portions 24 * of the Software. 25 */ 26 27/** 28*************************************************************************************************** 29* @file addrinterface.cpp 30* @brief Contains the addrlib interface functions 31*************************************************************************************************** 32*/ 33#include "addrinterface.h" 34#include "addrlib.h" 35 36#include "addrcommon.h" 37 38/////////////////////////////////////////////////////////////////////////////////////////////////// 39// Create/Destroy/Config functions 40/////////////////////////////////////////////////////////////////////////////////////////////////// 41 42/** 43*************************************************************************************************** 44* AddrCreate 45* 46* @brief 47* Create address lib object 48* 49* @return 50* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 51*************************************************************************************************** 52*/ 53ADDR_E_RETURNCODE ADDR_API AddrCreate( 54 const ADDR_CREATE_INPUT* pAddrCreateIn, ///< [in] infomation for creating address lib object 55 ADDR_CREATE_OUTPUT* pAddrCreateOut) ///< [out] address lib handle 56{ 57 ADDR_E_RETURNCODE returnCode = ADDR_OK; 58 59 returnCode = AddrLib::Create(pAddrCreateIn, pAddrCreateOut); 60 61 return returnCode; 62} 63 64 65 66/** 67*************************************************************************************************** 68* AddrDestroy 69* 70* @brief 71* Destroy address lib object 72* 73* @return 74* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 75*************************************************************************************************** 76*/ 77ADDR_E_RETURNCODE ADDR_API AddrDestroy( 78 ADDR_HANDLE hLib) ///< [in] address lib handle 79{ 80 ADDR_E_RETURNCODE returnCode = ADDR_OK; 81 82 if (hLib) 83 { 84 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 85 pLib->Destroy(); 86 } 87 else 88 { 89 returnCode = ADDR_ERROR; 90 } 91 92 return returnCode; 93} 94 95 96 97/////////////////////////////////////////////////////////////////////////////////////////////////// 98// Surface functions 99/////////////////////////////////////////////////////////////////////////////////////////////////// 100 101/** 102*************************************************************************************************** 103* AddrComputeSurfaceInfo 104* 105* @brief 106* Calculate surface width/height/depth/alignments and suitable tiling mode 107* 108* @return 109* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 110*************************************************************************************************** 111*/ 112ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceInfo( 113 ADDR_HANDLE hLib, ///< [in] address lib handle 114 const ADDR_COMPUTE_SURFACE_INFO_INPUT* pIn, ///< [in] surface information 115 ADDR_COMPUTE_SURFACE_INFO_OUTPUT* pOut) ///< [out] surface parameters and alignments 116{ 117 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 118 119 ADDR_E_RETURNCODE returnCode = ADDR_OK; 120 121 if (pLib != NULL) 122 { 123 returnCode = pLib->ComputeSurfaceInfo(pIn, pOut); 124 } 125 else 126 { 127 returnCode = ADDR_ERROR; 128 } 129 130 return returnCode; 131} 132 133 134 135/** 136*************************************************************************************************** 137* AddrComputeSurfaceAddrFromCoord 138* 139* @brief 140* Compute surface address according to coordinates 141* 142* @return 143* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 144*************************************************************************************************** 145*/ 146ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceAddrFromCoord( 147 ADDR_HANDLE hLib, ///< [in] address lib handle 148 const ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_INPUT* pIn, ///< [in] surface info and coordinates 149 ADDR_COMPUTE_SURFACE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] surface address 150{ 151 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 152 153 ADDR_E_RETURNCODE returnCode = ADDR_OK; 154 155 if (pLib != NULL) 156 { 157 returnCode = pLib->ComputeSurfaceAddrFromCoord(pIn, pOut); 158 } 159 else 160 { 161 returnCode = ADDR_ERROR; 162 } 163 164 return returnCode; 165} 166 167/** 168*************************************************************************************************** 169* AddrComputeSurfaceCoordFromAddr 170* 171* @brief 172* Compute coordinates according to surface address 173* 174* @return 175* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 176*************************************************************************************************** 177*/ 178ADDR_E_RETURNCODE ADDR_API AddrComputeSurfaceCoordFromAddr( 179 ADDR_HANDLE hLib, ///< [in] address lib handle 180 const ADDR_COMPUTE_SURFACE_COORDFROMADDR_INPUT* pIn, ///< [in] surface info and address 181 ADDR_COMPUTE_SURFACE_COORDFROMADDR_OUTPUT* pOut) ///< [out] coordinates 182{ 183 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 184 185 ADDR_E_RETURNCODE returnCode = ADDR_OK; 186 187 if (pLib != NULL) 188 { 189 returnCode = pLib->ComputeSurfaceCoordFromAddr(pIn, pOut); 190 } 191 else 192 { 193 returnCode = ADDR_ERROR; 194 } 195 196 return returnCode; 197} 198 199 200 201/////////////////////////////////////////////////////////////////////////////////////////////////// 202// HTile functions 203/////////////////////////////////////////////////////////////////////////////////////////////////// 204 205/** 206*************************************************************************************************** 207* AddrComputeHtileInfo 208* 209* @brief 210* Compute Htile pitch, height, base alignment and size in bytes 211* 212* @return 213* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 214*************************************************************************************************** 215*/ 216ADDR_E_RETURNCODE ADDR_API AddrComputeHtileInfo( 217 ADDR_HANDLE hLib, ///< [in] address lib handle 218 const ADDR_COMPUTE_HTILE_INFO_INPUT* pIn, ///< [in] Htile information 219 ADDR_COMPUTE_HTILE_INFO_OUTPUT* pOut) ///< [out] Htile pitch, height and size in bytes 220{ 221 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 222 223 ADDR_E_RETURNCODE returnCode = ADDR_OK; 224 225 if (pLib != NULL) 226 { 227 returnCode = pLib->ComputeHtileInfo(pIn, pOut); 228 } 229 else 230 { 231 returnCode = ADDR_ERROR; 232 } 233 234 return returnCode; 235} 236 237/** 238*************************************************************************************************** 239* AddrComputeHtileAddrFromCoord 240* 241* @brief 242* Compute Htile address according to coordinates (of depth buffer) 243* 244* @return 245* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 246*************************************************************************************************** 247*/ 248ADDR_E_RETURNCODE ADDR_API AddrComputeHtileAddrFromCoord( 249 ADDR_HANDLE hLib, ///< [in] address lib handle 250 const ADDR_COMPUTE_HTILE_ADDRFROMCOORD_INPUT* pIn, ///< [in] Htile info and coordinates 251 ADDR_COMPUTE_HTILE_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Htile address 252{ 253 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 254 255 ADDR_E_RETURNCODE returnCode = ADDR_OK; 256 257 if (pLib != NULL) 258 { 259 returnCode = pLib->ComputeHtileAddrFromCoord(pIn, pOut); 260 } 261 else 262 { 263 returnCode = ADDR_ERROR; 264 } 265 266 return returnCode; 267} 268 269/** 270*************************************************************************************************** 271* AddrComputeHtileCoordFromAddr 272* 273* @brief 274* Compute coordinates within depth buffer (1st pixel of a micro tile) according to 275* Htile address 276* 277* @return 278* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 279*************************************************************************************************** 280*/ 281ADDR_E_RETURNCODE ADDR_API AddrComputeHtileCoordFromAddr( 282 ADDR_HANDLE hLib, ///< [in] address lib handle 283 const ADDR_COMPUTE_HTILE_COORDFROMADDR_INPUT* pIn, ///< [in] Htile info and address 284 ADDR_COMPUTE_HTILE_COORDFROMADDR_OUTPUT* pOut) ///< [out] Htile coordinates 285{ 286 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 287 288 ADDR_E_RETURNCODE returnCode = ADDR_OK; 289 290 if (pLib != NULL) 291 { 292 returnCode = pLib->ComputeHtileCoordFromAddr(pIn, pOut); 293 } 294 else 295 { 296 returnCode = ADDR_ERROR; 297 } 298 299 return returnCode; 300} 301 302 303 304/////////////////////////////////////////////////////////////////////////////////////////////////// 305// C-mask functions 306/////////////////////////////////////////////////////////////////////////////////////////////////// 307 308/** 309*************************************************************************************************** 310* AddrComputeCmaskInfo 311* 312* @brief 313* Compute Cmask pitch, height, base alignment and size in bytes from color buffer 314* info 315* 316* @return 317* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 318*************************************************************************************************** 319*/ 320ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskInfo( 321 ADDR_HANDLE hLib, ///< [in] address lib handle 322 const ADDR_COMPUTE_CMASK_INFO_INPUT* pIn, ///< [in] Cmask pitch and height 323 ADDR_COMPUTE_CMASK_INFO_OUTPUT* pOut) ///< [out] Cmask pitch, height and size in bytes 324{ 325 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 326 327 ADDR_E_RETURNCODE returnCode = ADDR_OK; 328 329 if (pLib != NULL) 330 { 331 returnCode = pLib->ComputeCmaskInfo(pIn, pOut); 332 } 333 else 334 { 335 returnCode = ADDR_ERROR; 336 } 337 338 return returnCode; 339} 340 341/** 342*************************************************************************************************** 343* AddrComputeCmaskAddrFromCoord 344* 345* @brief 346* Compute Cmask address according to coordinates (of MSAA color buffer) 347* 348* @return 349* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 350*************************************************************************************************** 351*/ 352ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskAddrFromCoord( 353 ADDR_HANDLE hLib, ///< [in] address lib handle 354 const ADDR_COMPUTE_CMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Cmask info and coordinates 355 ADDR_COMPUTE_CMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Cmask address 356{ 357 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 358 359 ADDR_E_RETURNCODE returnCode = ADDR_OK; 360 361 if (pLib != NULL) 362 { 363 returnCode = pLib->ComputeCmaskAddrFromCoord(pIn, pOut); 364 } 365 else 366 { 367 returnCode = ADDR_ERROR; 368 } 369 370 return returnCode; 371} 372 373/** 374*************************************************************************************************** 375* AddrComputeCmaskCoordFromAddr 376* 377* @brief 378* Compute coordinates within color buffer (1st pixel of a micro tile) according to 379* Cmask address 380* 381* @return 382* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 383*************************************************************************************************** 384*/ 385ADDR_E_RETURNCODE ADDR_API AddrComputeCmaskCoordFromAddr( 386 ADDR_HANDLE hLib, ///< [in] address lib handle 387 const ADDR_COMPUTE_CMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Cmask info and address 388 ADDR_COMPUTE_CMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Cmask coordinates 389{ 390 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 391 392 ADDR_E_RETURNCODE returnCode = ADDR_OK; 393 394 if (pLib != NULL) 395 { 396 returnCode = pLib->ComputeCmaskCoordFromAddr(pIn, pOut); 397 } 398 else 399 { 400 returnCode = ADDR_ERROR; 401 } 402 403 return returnCode; 404} 405 406 407 408/////////////////////////////////////////////////////////////////////////////////////////////////// 409// F-mask functions 410/////////////////////////////////////////////////////////////////////////////////////////////////// 411 412/** 413*************************************************************************************************** 414* AddrComputeFmaskInfo 415* 416* @brief 417* Compute Fmask pitch/height/depth/alignments and size in bytes 418* 419* @return 420* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 421*************************************************************************************************** 422*/ 423ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskInfo( 424 ADDR_HANDLE hLib, ///< [in] address lib handle 425 const ADDR_COMPUTE_FMASK_INFO_INPUT* pIn, ///< [in] Fmask information 426 ADDR_COMPUTE_FMASK_INFO_OUTPUT* pOut) ///< [out] Fmask pitch and height 427{ 428 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 429 430 ADDR_E_RETURNCODE returnCode = ADDR_OK; 431 432 if (pLib != NULL) 433 { 434 returnCode = pLib->ComputeFmaskInfo(pIn, pOut); 435 } 436 else 437 { 438 returnCode = ADDR_ERROR; 439 } 440 441 return returnCode; 442} 443 444/** 445*************************************************************************************************** 446* AddrComputeFmaskAddrFromCoord 447* 448* @brief 449* Compute Fmask address according to coordinates (x,y,slice,sample,plane) 450* 451* @return 452* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 453*************************************************************************************************** 454*/ 455ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskAddrFromCoord( 456 ADDR_HANDLE hLib, ///< [in] address lib handle 457 const ADDR_COMPUTE_FMASK_ADDRFROMCOORD_INPUT* pIn, ///< [in] Fmask info and coordinates 458 ADDR_COMPUTE_FMASK_ADDRFROMCOORD_OUTPUT* pOut) ///< [out] Fmask address 459{ 460 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 461 462 ADDR_E_RETURNCODE returnCode = ADDR_OK; 463 464 if (pLib != NULL) 465 { 466 returnCode = pLib->ComputeFmaskAddrFromCoord(pIn, pOut); 467 } 468 else 469 { 470 returnCode = ADDR_ERROR; 471 } 472 473 return returnCode; 474} 475 476/** 477*************************************************************************************************** 478* AddrComputeFmaskCoordFromAddr 479* 480* @brief 481* Compute coordinates (x,y,slice,sample,plane) according to Fmask address 482* 483* @return 484* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 485*************************************************************************************************** 486*/ 487ADDR_E_RETURNCODE ADDR_API AddrComputeFmaskCoordFromAddr( 488 ADDR_HANDLE hLib, ///< [in] address lib handle 489 const ADDR_COMPUTE_FMASK_COORDFROMADDR_INPUT* pIn, ///< [in] Fmask info and address 490 ADDR_COMPUTE_FMASK_COORDFROMADDR_OUTPUT* pOut) ///< [out] Fmask coordinates 491{ 492 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 493 494 ADDR_E_RETURNCODE returnCode = ADDR_OK; 495 496 if (pLib != NULL) 497 { 498 returnCode = pLib->ComputeFmaskCoordFromAddr(pIn, pOut); 499 } 500 else 501 { 502 returnCode = ADDR_ERROR; 503 } 504 505 return returnCode; 506} 507 508 509 510/////////////////////////////////////////////////////////////////////////////////////////////////// 511// DCC key functions 512/////////////////////////////////////////////////////////////////////////////////////////////////// 513 514/** 515*************************************************************************************************** 516* AddrComputeDccInfo 517* 518* @brief 519* Compute DCC key size, base alignment based on color surface size, tile info or tile index 520* 521*************************************************************************************************** 522*/ 523ADDR_E_RETURNCODE ADDR_API AddrComputeDccInfo( 524 ADDR_HANDLE hLib, ///< [in] handle of addrlib 525 const ADDR_COMPUTE_DCCINFO_INPUT* pIn, ///< [in] input 526 ADDR_COMPUTE_DCCINFO_OUTPUT* pOut) ///< [out] output 527{ 528 ADDR_E_RETURNCODE returnCode; 529 530 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 531 532 if (pLib != NULL) 533 { 534 returnCode = pLib->ComputeDccInfo(pIn, pOut); 535 } 536 else 537 { 538 returnCode = ADDR_ERROR; 539 } 540 541 return returnCode; 542} 543 544 545 546/////////////////////////////////////////////////////////////////////////////// 547// Below functions are element related or helper functions 548/////////////////////////////////////////////////////////////////////////////// 549 550/** 551*************************************************************************************************** 552* AddrGetVersion 553* 554* @brief 555* Get AddrLib version number. Client may check this return value against ADDRLIB_VERSION 556* defined in addrinterface.h to see if there is a mismatch. 557*************************************************************************************************** 558*/ 559UINT_32 ADDR_API AddrGetVersion(ADDR_HANDLE hLib) 560{ 561 UINT_32 version = 0; 562 563 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 564 565 ADDR_ASSERT(pLib != NULL); 566 567 if (pLib) 568 { 569 version = pLib->GetVersion(); 570 } 571 572 return version; 573} 574 575/** 576*************************************************************************************************** 577* AddrUseTileIndex 578* 579* @brief 580* Return TRUE if tileIndex is enabled in this address library 581*************************************************************************************************** 582*/ 583BOOL_32 ADDR_API AddrUseTileIndex(ADDR_HANDLE hLib) 584{ 585 BOOL_32 useTileIndex = FALSE; 586 587 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 588 589 ADDR_ASSERT(pLib != NULL); 590 591 if (pLib) 592 { 593 useTileIndex = pLib->UseTileIndex(0); 594 } 595 596 return useTileIndex; 597} 598 599/** 600*************************************************************************************************** 601* AddrUseCombinedSwizzle 602* 603* @brief 604* Return TRUE if combined swizzle is enabled in this address library 605*************************************************************************************************** 606*/ 607BOOL_32 ADDR_API AddrUseCombinedSwizzle(ADDR_HANDLE hLib) 608{ 609 BOOL_32 useCombinedSwizzle = FALSE; 610 611 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 612 613 ADDR_ASSERT(pLib != NULL); 614 615 if (pLib) 616 { 617 useCombinedSwizzle = pLib->UseCombinedSwizzle(); 618 } 619 620 return useCombinedSwizzle; 621} 622 623/** 624*************************************************************************************************** 625* AddrExtractBankPipeSwizzle 626* 627* @brief 628* Extract Bank and Pipe swizzle from base256b 629* @return 630* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 631*************************************************************************************************** 632*/ 633ADDR_E_RETURNCODE ADDR_API AddrExtractBankPipeSwizzle( 634 ADDR_HANDLE hLib, ///< [in] addrlib handle 635 const ADDR_EXTRACT_BANKPIPE_SWIZZLE_INPUT* pIn, ///< [in] input structure 636 ADDR_EXTRACT_BANKPIPE_SWIZZLE_OUTPUT* pOut) ///< [out] output structure 637{ 638 ADDR_E_RETURNCODE returnCode = ADDR_OK; 639 640 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 641 642 if (pLib != NULL) 643 { 644 returnCode = pLib->ExtractBankPipeSwizzle(pIn, pOut); 645 } 646 else 647 { 648 returnCode = ADDR_ERROR; 649 } 650 651 return returnCode; 652} 653 654/** 655*************************************************************************************************** 656* AddrCombineBankPipeSwizzle 657* 658* @brief 659* Combine Bank and Pipe swizzle 660* @return 661* ADDR_E_RETURNCODE 662*************************************************************************************************** 663*/ 664ADDR_E_RETURNCODE ADDR_API AddrCombineBankPipeSwizzle( 665 ADDR_HANDLE hLib, 666 const ADDR_COMBINE_BANKPIPE_SWIZZLE_INPUT* pIn, 667 ADDR_COMBINE_BANKPIPE_SWIZZLE_OUTPUT* pOut) 668{ 669 ADDR_E_RETURNCODE returnCode = ADDR_OK; 670 671 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 672 673 if (pLib != NULL) 674 { 675 returnCode = pLib->CombineBankPipeSwizzle(pIn, pOut); 676 } 677 else 678 { 679 returnCode = ADDR_ERROR; 680 } 681 682 return returnCode; 683} 684 685/** 686*************************************************************************************************** 687* AddrComputeSliceSwizzle 688* 689* @brief 690* Compute a swizzle for slice from a base swizzle 691* @return 692* ADDR_OK if no error 693*************************************************************************************************** 694*/ 695ADDR_E_RETURNCODE ADDR_API AddrComputeSliceSwizzle( 696 ADDR_HANDLE hLib, 697 const ADDR_COMPUTE_SLICESWIZZLE_INPUT* pIn, 698 ADDR_COMPUTE_SLICESWIZZLE_OUTPUT* pOut) 699{ 700 ADDR_E_RETURNCODE returnCode = ADDR_OK; 701 702 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 703 704 if (pLib != NULL) 705 { 706 returnCode = pLib->ComputeSliceTileSwizzle(pIn, pOut); 707 } 708 else 709 { 710 returnCode = ADDR_ERROR; 711 } 712 713 return returnCode; 714} 715 716/** 717*************************************************************************************************** 718* AddrComputeBaseSwizzle 719* 720* @brief 721* Return a Combined Bank and Pipe swizzle base on surface based on surface type/index 722* @return 723* ADDR_OK if no error 724*************************************************************************************************** 725*/ 726ADDR_E_RETURNCODE ADDR_API AddrComputeBaseSwizzle( 727 ADDR_HANDLE hLib, 728 const ADDR_COMPUTE_BASE_SWIZZLE_INPUT* pIn, 729 ADDR_COMPUTE_BASE_SWIZZLE_OUTPUT* pOut) 730{ 731 ADDR_E_RETURNCODE returnCode = ADDR_OK; 732 733 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 734 735 if (pLib != NULL) 736 { 737 returnCode = pLib->ComputeBaseSwizzle(pIn, pOut); 738 } 739 else 740 { 741 returnCode = ADDR_ERROR; 742 } 743 744 return returnCode; 745} 746 747/** 748*************************************************************************************************** 749* ElemFlt32ToDepthPixel 750* 751* @brief 752* Convert a FLT_32 value to a depth/stencil pixel value 753* 754* @return 755* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 756* 757*************************************************************************************************** 758*/ 759ADDR_E_RETURNCODE ADDR_API ElemFlt32ToDepthPixel( 760 ADDR_HANDLE hLib, ///< [in] addrlib handle 761 const ELEM_FLT32TODEPTHPIXEL_INPUT* pIn, ///< [in] per-component value 762 ELEM_FLT32TODEPTHPIXEL_OUTPUT* pOut) ///< [out] final pixel value 763{ 764 ADDR_E_RETURNCODE returnCode = ADDR_OK; 765 766 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 767 768 if (pLib != NULL) 769 { 770 pLib->Flt32ToDepthPixel(pIn, pOut); 771 } 772 else 773 { 774 returnCode = ADDR_ERROR; 775 } 776 777 return returnCode; 778} 779 780/** 781*************************************************************************************************** 782* ElemFlt32ToColorPixel 783* 784* @brief 785* Convert a FLT_32 value to a red/green/blue/alpha pixel value 786* 787* @return 788* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 789* 790*************************************************************************************************** 791*/ 792ADDR_E_RETURNCODE ADDR_API ElemFlt32ToColorPixel( 793 ADDR_HANDLE hLib, ///< [in] addrlib handle 794 const ELEM_FLT32TOCOLORPIXEL_INPUT* pIn, ///< [in] format, surface number and swap value 795 ELEM_FLT32TOCOLORPIXEL_OUTPUT* pOut) ///< [out] final pixel value 796{ 797 ADDR_E_RETURNCODE returnCode = ADDR_OK; 798 799 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 800 801 if (pLib != NULL) 802 { 803 pLib->Flt32ToColorPixel(pIn, pOut); 804 } 805 else 806 { 807 returnCode = ADDR_ERROR; 808 } 809 810 return returnCode; 811} 812 813/** 814*************************************************************************************************** 815* ElemGetExportNorm 816* 817* @brief 818* Helper function to check one format can be EXPORT_NUM, 819* which is a register CB_COLOR_INFO.SURFACE_FORMAT. 820* FP16 can be reported as EXPORT_NORM for rv770 in r600 821* family 822* 823*************************************************************************************************** 824*/ 825BOOL_32 ADDR_API ElemGetExportNorm( 826 ADDR_HANDLE hLib, ///< [in] addrlib handle 827 const ELEM_GETEXPORTNORM_INPUT* pIn) ///< [in] input structure 828{ 829 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 830 BOOL_32 enabled = FALSE; 831 832 ADDR_E_RETURNCODE returnCode = ADDR_OK; 833 834 if (pLib != NULL) 835 { 836 enabled = pLib->GetExportNorm(pIn); 837 } 838 else 839 { 840 returnCode = ADDR_ERROR; 841 } 842 843 ADDR_ASSERT(returnCode == ADDR_OK); 844 845 return enabled; 846} 847 848/** 849*************************************************************************************************** 850* AddrConvertTileInfoToHW 851* 852* @brief 853* Convert tile info from real value to hardware register value 854* 855* @return 856* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 857*************************************************************************************************** 858*/ 859ADDR_E_RETURNCODE ADDR_API AddrConvertTileInfoToHW( 860 ADDR_HANDLE hLib, ///< [in] address lib handle 861 const ADDR_CONVERT_TILEINFOTOHW_INPUT* pIn, ///< [in] tile info with real value 862 ADDR_CONVERT_TILEINFOTOHW_OUTPUT* pOut) ///< [out] tile info with HW register value 863{ 864 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 865 866 ADDR_E_RETURNCODE returnCode = ADDR_OK; 867 868 if (pLib != NULL) 869 { 870 returnCode = pLib->ConvertTileInfoToHW(pIn, pOut); 871 } 872 else 873 { 874 returnCode = ADDR_ERROR; 875 } 876 877 return returnCode; 878} 879 880/** 881*************************************************************************************************** 882* AddrConvertTileIndex 883* 884* @brief 885* Convert tile index to tile mode/type/info 886* 887* @return 888* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 889*************************************************************************************************** 890*/ 891ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex( 892 ADDR_HANDLE hLib, ///< [in] address lib handle 893 const ADDR_CONVERT_TILEINDEX_INPUT* pIn, ///< [in] input - tile index 894 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info 895{ 896 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 897 898 ADDR_E_RETURNCODE returnCode = ADDR_OK; 899 900 if (pLib != NULL) 901 { 902 returnCode = pLib->ConvertTileIndex(pIn, pOut); 903 } 904 else 905 { 906 returnCode = ADDR_ERROR; 907 } 908 909 return returnCode; 910} 911 912/** 913*************************************************************************************************** 914* AddrConvertTileIndex1 915* 916* @brief 917* Convert tile index to tile mode/type/info 918* 919* @return 920* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 921*************************************************************************************************** 922*/ 923ADDR_E_RETURNCODE ADDR_API AddrConvertTileIndex1( 924 ADDR_HANDLE hLib, ///< [in] address lib handle 925 const ADDR_CONVERT_TILEINDEX1_INPUT* pIn, ///< [in] input - tile index 926 ADDR_CONVERT_TILEINDEX_OUTPUT* pOut) ///< [out] tile mode/type/info 927{ 928 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 929 930 ADDR_E_RETURNCODE returnCode = ADDR_OK; 931 932 if (pLib != NULL) 933 { 934 returnCode = pLib->ConvertTileIndex1(pIn, pOut); 935 } 936 else 937 { 938 returnCode = ADDR_ERROR; 939 } 940 941 return returnCode; 942} 943 944/** 945*************************************************************************************************** 946* AddrGetTileIndex 947* 948* @brief 949* Get tile index from tile mode/type/info 950* 951* @return 952* ADDR_OK if successful, otherwise an error code of ADDR_E_RETURNCODE 953* 954* @note 955* Only meaningful for SI (and above) 956*************************************************************************************************** 957*/ 958ADDR_E_RETURNCODE ADDR_API AddrGetTileIndex( 959 ADDR_HANDLE hLib, 960 const ADDR_GET_TILEINDEX_INPUT* pIn, 961 ADDR_GET_TILEINDEX_OUTPUT* pOut) 962{ 963 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 964 965 ADDR_E_RETURNCODE returnCode = ADDR_OK; 966 967 if (pLib != NULL) 968 { 969 returnCode = pLib->GetTileIndex(pIn, pOut); 970 } 971 else 972 { 973 returnCode = ADDR_ERROR; 974 } 975 976 return returnCode; 977} 978 979/** 980*************************************************************************************************** 981* AddrComputePrtInfo 982* 983* @brief 984* Interface function for ComputePrtInfo 985* 986*************************************************************************************************** 987*/ 988ADDR_E_RETURNCODE ADDR_API AddrComputePrtInfo( 989 ADDR_HANDLE hLib, 990 const ADDR_PRT_INFO_INPUT* pIn, 991 ADDR_PRT_INFO_OUTPUT* pOut) 992{ 993 ADDR_E_RETURNCODE returnCode = ADDR_OK; 994 995 AddrLib* pLib = AddrLib::GetAddrLib(hLib); 996 997 if (pLib != NULL) 998 { 999 returnCode = pLib->ComputePrtInfo(pIn, pOut); 1000 } 1001 else 1002 { 1003 returnCode = ADDR_ERROR; 1004 } 1005 1006 return returnCode; 1007} 1008 1009