Merge branch '215-fix-opaque-type-indexing' into 'master'
[platform/upstream/VK-GL-CTS.git] / 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