inline HRESULT GetSurfaceInfo()

in Src/LoaderHelpers.h [480:637]

• 143 lines of code
• 52 McCabe index (conditional complexity)

        inline HRESULT GetSurfaceInfo(
            _In_ size_t width,
            _In_ size_t height,
            _In_ DXGI_FORMAT fmt,
            _Out_opt_ size_t* outNumBytes,
            _Out_opt_ size_t* outRowBytes,
            _Out_opt_ size_t* outNumRows) noexcept
        {
            uint64_t numBytes = 0;
            uint64_t rowBytes = 0;
            uint64_t numRows = 0;

            bool bc = false;
            bool packed = false;
            bool planar = false;
            size_t bpe = 0;
            switch (fmt)
            {
            case DXGI_FORMAT_BC1_TYPELESS:
            case DXGI_FORMAT_BC1_UNORM:
            case DXGI_FORMAT_BC1_UNORM_SRGB:
            case DXGI_FORMAT_BC4_TYPELESS:
            case DXGI_FORMAT_BC4_UNORM:
            case DXGI_FORMAT_BC4_SNORM:
                bc = true;
                bpe = 8;
                break;

            case DXGI_FORMAT_BC2_TYPELESS:
            case DXGI_FORMAT_BC2_UNORM:
            case DXGI_FORMAT_BC2_UNORM_SRGB:
            case DXGI_FORMAT_BC3_TYPELESS:
            case DXGI_FORMAT_BC3_UNORM:
            case DXGI_FORMAT_BC3_UNORM_SRGB:
            case DXGI_FORMAT_BC5_TYPELESS:
            case DXGI_FORMAT_BC5_UNORM:
            case DXGI_FORMAT_BC5_SNORM:
            case DXGI_FORMAT_BC6H_TYPELESS:
            case DXGI_FORMAT_BC6H_UF16:
            case DXGI_FORMAT_BC6H_SF16:
            case DXGI_FORMAT_BC7_TYPELESS:
            case DXGI_FORMAT_BC7_UNORM:
            case DXGI_FORMAT_BC7_UNORM_SRGB:
                bc = true;
                bpe = 16;
                break;

            case DXGI_FORMAT_R8G8_B8G8_UNORM:
            case DXGI_FORMAT_G8R8_G8B8_UNORM:
            case DXGI_FORMAT_YUY2:
                packed = true;
                bpe = 4;
                break;

            case DXGI_FORMAT_Y210:
            case DXGI_FORMAT_Y216:
                packed = true;
                bpe = 8;
                break;

            case DXGI_FORMAT_NV12:
            case DXGI_FORMAT_420_OPAQUE:
        #if (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
            case DXGI_FORMAT_P208:
        #endif
                planar = true;
                bpe = 2;
                break;

            case DXGI_FORMAT_P010:
            case DXGI_FORMAT_P016:
                planar = true;
                bpe = 4;
                break;

        #if (defined(_XBOX_ONE) && defined(_TITLE)) || defined(_GAMING_XBOX)

            case DXGI_FORMAT_D16_UNORM_S8_UINT:
            case DXGI_FORMAT_R16_UNORM_X8_TYPELESS:
            case DXGI_FORMAT_X16_TYPELESS_G8_UINT:
                planar = true;
                bpe = 4;
                break;

        #endif

            default:
                break;
            }

            if (bc)
            {
                uint64_t numBlocksWide = 0;
                if (width > 0)
                {
                    numBlocksWide = std::max<uint64_t>(1u, (uint64_t(width) + 3u) / 4u);
                }
                uint64_t numBlocksHigh = 0;
                if (height > 0)
                {
                    numBlocksHigh = std::max<uint64_t>(1u, (uint64_t(height) + 3u) / 4u);
                }
                rowBytes = numBlocksWide * bpe;
                numRows = numBlocksHigh;
                numBytes = rowBytes * numBlocksHigh;
            }
            else if (packed)
            {
                rowBytes = ((uint64_t(width) + 1u) >> 1) * bpe;
                numRows = uint64_t(height);
                numBytes = rowBytes * height;
            }
            else if (fmt == DXGI_FORMAT_NV11)
            {
                rowBytes = ((uint64_t(width) + 3u) >> 2) * 4u;
                numRows = uint64_t(height) * 2u; // Direct3D makes this simplifying assumption, although it is larger than the 4:1:1 data
                numBytes = rowBytes * numRows;
            }
            else if (planar)
            {
                rowBytes = ((uint64_t(width) + 1u) >> 1) * bpe;
                numBytes = (rowBytes * uint64_t(height)) + ((rowBytes * uint64_t(height) + 1u) >> 1);
                numRows = height + ((uint64_t(height) + 1u) >> 1);
            }
            else
            {
                size_t bpp = BitsPerPixel(fmt);
                if (!bpp)
                    return E_INVALIDARG;

                rowBytes = (uint64_t(width) * bpp + 7u) / 8u; // round up to nearest byte
                numRows = uint64_t(height);
                numBytes = rowBytes * height;
            }

        #if defined(_M_IX86) || defined(_M_ARM) || defined(_M_HYBRID_X86_ARM64)
            static_assert(sizeof(size_t) == 4, "Not a 32-bit platform!");
            if (numBytes > UINT32_MAX || rowBytes > UINT32_MAX || numRows > UINT32_MAX)
                return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
        #else
            static_assert(sizeof(size_t) == 8, "Not a 64-bit platform!");
        #endif

            if (outNumBytes)
            {
                *outNumBytes = static_cast<size_t>(numBytes);
            }
            if (outRowBytes)
            {
                *outRowBytes = static_cast<size_t>(rowBytes);
            }
            if (outNumRows)
            {
                *outNumRows = static_cast<size_t>(numRows);
            }

            return S_OK;
        }