modules/internal/ditAstcTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Internal Test Module
   3  * ---------------------------------
   4  *
   5  * Copyright 2016 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief ASTC tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "ditAstcTests.hpp"
  25
  26 #include "tcuCompressedTexture.hpp"
  27 #include "tcuAstcUtil.hpp"
  28
  29 #include "deUniquePtr.hpp"
  30 #include "deStringUtil.hpp"
  31
  32 namespace dit
  33 {
  34
  35 using std::string;
  36 using std::vector;
  37 using namespace tcu;
  38
  39 namespace
  40 {
  41
  42 class AstcCase : public tcu::TestCase
  43 {
  44 public:
  45                                                                 AstcCase                (tcu::TestContext& testCtx, CompressedTexFormat format);
  46
  47         IterateResult                           iterate                 (void);
  48
  49 private:
  50         const CompressedTexFormat       m_format;
  51 };
  52
  53 static const string getASTCFormatShortName (CompressedTexFormat format)
  54 {
  55         DE_ASSERT(isAstcFormat(format));
  56         const IVec3 blockSize = getBlockPixelSize(format);
  57         DE_ASSERT(blockSize.z() == 1);
  58
  59         return de::toString(blockSize.x()) + "x" + de::toString(blockSize.y()) + (tcu::isAstcSRGBFormat(format) ? "_srgb" : "");
  60 }
  61
  62 AstcCase::AstcCase (tcu::TestContext& testCtx, CompressedTexFormat format)
  63         : tcu::TestCase (testCtx, getASTCFormatShortName(format).c_str(), "")
  64         , m_format              (format)
  65 {
  66 }
  67
  68 void testDecompress (CompressedTexFormat format, size_t numBlocks, const deUint8* data)
  69 {
  70         const IVec3                     blockPixelSize          = getBlockPixelSize(format);
  71
  72         for (int astcModeNdx = 0; astcModeNdx < TexDecompressionParams::ASTCMODE_LAST; astcModeNdx++)
  73         {
  74                 const TexDecompressionParams    decompressionParams             ((TexDecompressionParams::AstcMode)astcModeNdx);
  75                 const TextureFormat                             uncompressedFormat              = getUncompressedFormat(format);
  76                 TextureLevel                                    texture                                 (uncompressedFormat, blockPixelSize.x()*(int)numBlocks, blockPixelSize.y());
  77
  78                 decompress(texture.getAccess(), format, data, decompressionParams);
  79         }
  80 }
  81
  82 void verifyBlocksValid (CompressedTexFormat format, TexDecompressionParams::AstcMode mode, size_t numBlocks, const deUint8* data)
  83 {
  84         for (size_t blockNdx = 0; blockNdx < numBlocks; blockNdx++)
  85                 TCU_CHECK(astc::isValidBlock(data + blockNdx*astc::BLOCK_SIZE_BYTES, format, mode));
  86 }
  87
  88 inline size_t getNumBlocksFromBytes (size_t numBytes)
  89 {
  90         TCU_CHECK(numBytes % astc::BLOCK_SIZE_BYTES == 0);
  91         return (numBytes / astc::BLOCK_SIZE_BYTES);
  92 }
  93
  94 AstcCase::IterateResult AstcCase::iterate (void)
  95 {
  96         vector<deUint8> generatedData;
  97
  98         // Verify that can generate & decode data with all BlockTestType's
  99         for (int blockTestTypeNdx = 0; blockTestTypeNdx < astc::BLOCK_TEST_TYPE_LAST; blockTestTypeNdx++)
 100         {
 101                 const astc::BlockTestType       blockTestType   = (const astc::BlockTestType)blockTestTypeNdx;
 102
 103                 if (astc::isBlockTestTypeHDROnly(blockTestType) && isAstcSRGBFormat(m_format))
 104                         continue;
 105
 106                 generatedData.clear();
 107                 astc::generateBlockCaseTestData(generatedData, m_format, blockTestType);
 108
 109                 testDecompress(m_format, getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
 110
 111                 // All but random case should generate only valid blocks
 112                 if (blockTestType != astc::BLOCK_TEST_TYPE_RANDOM)
 113                 {
 114                         verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR, getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
 115
 116                         if (!astc::isBlockTestTypeHDROnly(blockTestType))
 117                                 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR, getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
 118                 }
 119         }
 120
 121         // Verify generating void extent blocks (format-independent)
 122         {
 123                 const size_t            numBlocks               = 1024;
 124
 125                 generatedData.resize(numBlocks*astc::BLOCK_SIZE_BYTES);
 126                 astc::generateDummyVoidExtentBlocks(&generatedData[0], numBlocks);
 127
 128                 testDecompress(m_format, numBlocks, &generatedData[0]);
 129
 130                 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR, numBlocks, &generatedData[0]);
 131                 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR, numBlocks, &generatedData[0]);
 132         }
 133
 134         // Verify generating dummy normal blocks
 135         {
 136                 const size_t            numBlocks                       = 1024;
 137                 const IVec3                     blockPixelSize          = getBlockPixelSize(m_format);
 138
 139                 generatedData.resize(numBlocks*astc::BLOCK_SIZE_BYTES);
 140                 astc::generateDummyNormalBlocks(&generatedData[0], numBlocks, blockPixelSize.x(), blockPixelSize.y());
 141
 142                 testDecompress(m_format, numBlocks, &generatedData[0]);
 143
 144                 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR, numBlocks, &generatedData[0]);
 145                 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR, numBlocks, &generatedData[0]);
 146         }
 147
 148         // Verify generating random valid blocks
 149         for (int astcModeNdx = 0; astcModeNdx < TexDecompressionParams::ASTCMODE_LAST; astcModeNdx++)
 150         {
 151                 const TexDecompressionParams::AstcMode  mode            = (TexDecompressionParams::AstcMode)astcModeNdx;
 152                 const size_t                                                    numBlocks       = 1024;
 153
 154                 generatedData.resize(numBlocks*astc::BLOCK_SIZE_BYTES);
 155                 astc::generateRandomValidBlocks(&generatedData[0], numBlocks, m_format, mode, deInt32Hash(m_format) ^ deInt32Hash(mode));
 156
 157                 testDecompress(m_format, numBlocks, &generatedData[0]);
 158
 159                 verifyBlocksValid(m_format, mode, numBlocks, &generatedData[0]);
 160         }
 161
 162         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "All checks passed");
 163         return STOP;
 164 }
 165
 166 } // anonymous
 167
 168 tcu::TestCaseGroup* createAstcTests (tcu::TestContext& testCtx)
 169 {
 170         de::MovePtr<tcu::TestCaseGroup> astcTests       (new tcu::TestCaseGroup(testCtx, "astc", "Tests for ASTC Utilities"));
 171
 172         for (int formatNdx = 0; formatNdx < COMPRESSEDTEXFORMAT_LAST; formatNdx++)
 173         {
 174                 const CompressedTexFormat       format  = (CompressedTexFormat)formatNdx;
 175
 176                 if (isAstcFormat(format))
 177                         astcTests->addChild(new AstcCase(testCtx, format));
 178         }
 179
 180         return astcTests.release();
 181 }
 182
 183 } // dit