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
getASTCFormatShortName(CompressedTexFormat format)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()) +
60 (tcu::isAstcSRGBFormat(format) ? "_srgb" : "");
61 }
62
AstcCase(tcu::TestContext & testCtx,CompressedTexFormat format)63 AstcCase::AstcCase(tcu::TestContext &testCtx, CompressedTexFormat format)
64 : tcu::TestCase(testCtx, getASTCFormatShortName(format).c_str(), "")
65 , m_format(format)
66 {
67 }
68
testDecompress(CompressedTexFormat format,TexDecompressionParams::AstcMode mode,size_t numBlocks,const uint8_t * data)69 void testDecompress(CompressedTexFormat format, TexDecompressionParams::AstcMode mode, size_t numBlocks,
70 const uint8_t *data)
71 {
72 const IVec3 blockPixelSize = getBlockPixelSize(format);
73 const TexDecompressionParams decompressionParams(mode);
74 const TextureFormat uncompressedFormat = getUncompressedFormat(format);
75 TextureLevel texture(uncompressedFormat, blockPixelSize.x() * (int)numBlocks, blockPixelSize.y());
76
77 decompress(texture.getAccess(), format, data, decompressionParams);
78 }
79
testDecompress(CompressedTexFormat format,size_t numBlocks,const uint8_t * data)80 void testDecompress(CompressedTexFormat format, size_t numBlocks, const uint8_t *data)
81 {
82 testDecompress(format, TexDecompressionParams::ASTCMODE_LDR, numBlocks, data);
83
84 if (!isAstcSRGBFormat(format))
85 testDecompress(format, TexDecompressionParams::ASTCMODE_HDR, numBlocks, data);
86 }
87
verifyBlocksValid(CompressedTexFormat format,TexDecompressionParams::AstcMode mode,size_t numBlocks,const uint8_t * data)88 void verifyBlocksValid(CompressedTexFormat format, TexDecompressionParams::AstcMode mode, size_t numBlocks,
89 const uint8_t *data)
90 {
91 for (size_t blockNdx = 0; blockNdx < numBlocks; blockNdx++)
92 {
93 if (!astc::isValidBlock(data + blockNdx * astc::BLOCK_SIZE_BYTES, format, mode))
94 TCU_FAIL("Invalid ASTC block was generated");
95 }
96 }
97
getNumBlocksFromBytes(size_t numBytes)98 inline size_t getNumBlocksFromBytes(size_t numBytes)
99 {
100 TCU_CHECK(numBytes % astc::BLOCK_SIZE_BYTES == 0);
101 return (numBytes / astc::BLOCK_SIZE_BYTES);
102 }
103
iterate(void)104 AstcCase::IterateResult AstcCase::iterate(void)
105 {
106 vector<uint8_t> generatedData;
107
108 // Verify that can generate & decode data with all BlockTestType's
109 for (int blockTestTypeNdx = 0; blockTestTypeNdx < astc::BLOCK_TEST_TYPE_LAST; blockTestTypeNdx++)
110 {
111 const astc::BlockTestType blockTestType = (astc::BlockTestType)blockTestTypeNdx;
112
113 if (astc::isBlockTestTypeHDROnly(blockTestType) && isAstcSRGBFormat(m_format))
114 continue;
115
116 generatedData.clear();
117 astc::generateBlockCaseTestData(generatedData, m_format, blockTestType);
118
119 testDecompress(m_format, getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
120
121 // All but random case should generate only valid blocks
122 if (blockTestType != astc::BLOCK_TEST_TYPE_RANDOM)
123 {
124 // \note CEMS generates HDR blocks as well
125 if (!astc::isBlockTestTypeHDROnly(blockTestType) && (blockTestType != astc::BLOCK_TEST_TYPE_CEMS))
126 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR,
127 getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
128
129 if (!isAstcSRGBFormat(m_format))
130 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR,
131 getNumBlocksFromBytes(generatedData.size()), &generatedData[0]);
132 }
133 }
134
135 // Verify generating void extent blocks (format-independent)
136 {
137 const size_t numBlocks = 1024;
138
139 generatedData.resize(numBlocks * astc::BLOCK_SIZE_BYTES);
140 astc::generateDefaultVoidExtentBlocks(&generatedData[0], numBlocks);
141
142 testDecompress(m_format, numBlocks, &generatedData[0]);
143
144 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR, numBlocks, &generatedData[0]);
145
146 if (!isAstcSRGBFormat(m_format))
147 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR, numBlocks, &generatedData[0]);
148 }
149
150 // Verify generating unused normal blocks
151 {
152 const size_t numBlocks = 1024;
153 const IVec3 blockPixelSize = getBlockPixelSize(m_format);
154
155 generatedData.resize(numBlocks * astc::BLOCK_SIZE_BYTES);
156 astc::generateDefaultNormalBlocks(&generatedData[0], numBlocks, blockPixelSize.x(), blockPixelSize.y());
157
158 testDecompress(m_format, numBlocks, &generatedData[0]);
159
160 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_LDR, numBlocks, &generatedData[0]);
161
162 if (!isAstcSRGBFormat(m_format))
163 verifyBlocksValid(m_format, TexDecompressionParams::ASTCMODE_HDR, numBlocks, &generatedData[0]);
164 }
165
166 // Verify generating random valid blocks
167 for (int astcModeNdx = 0; astcModeNdx < TexDecompressionParams::ASTCMODE_LAST; astcModeNdx++)
168 {
169 const TexDecompressionParams::AstcMode mode = (TexDecompressionParams::AstcMode)astcModeNdx;
170 const size_t numBlocks = 1024;
171
172 if (mode == tcu::TexDecompressionParams::ASTCMODE_HDR && isAstcFormat(m_format))
173 continue; // sRGB is not supported in HDR mode
174
175 generatedData.resize(numBlocks * astc::BLOCK_SIZE_BYTES);
176 astc::generateRandomValidBlocks(&generatedData[0], numBlocks, m_format, mode,
177 deInt32Hash(m_format) ^ deInt32Hash(mode));
178
179 testDecompress(m_format, numBlocks, &generatedData[0]);
180
181 verifyBlocksValid(m_format, mode, numBlocks, &generatedData[0]);
182 }
183
184 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "All checks passed");
185 return STOP;
186 }
187
188 } // namespace
189
createAstcTests(tcu::TestContext & testCtx)190 tcu::TestCaseGroup *createAstcTests(tcu::TestContext &testCtx)
191 {
192 de::MovePtr<tcu::TestCaseGroup> astcTests(new tcu::TestCaseGroup(testCtx, "astc", "Tests for ASTC Utilities"));
193
194 for (int formatNdx = 0; formatNdx < COMPRESSEDTEXFORMAT_LAST; formatNdx++)
195 {
196 const CompressedTexFormat format = (CompressedTexFormat)formatNdx;
197
198 if (isAstcFormat(format))
199 astcTests->addChild(new AstcCase(testCtx, format));
200 }
201
202 return astcTests.release();
203 }
204
205 } // namespace dit
206