1 //
2 // Copyright 2015 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 // ETCTextureTest:
7 // Tests for ETC lossy decode formats.
8 //
9
10 #include "test_utils/ANGLETest.h"
11
12 using namespace angle;
13
14 namespace
15 {
16
17 class ETCTextureTest : public ANGLETest
18 {
19 protected:
ETCTextureTest()20 ETCTextureTest() : mTexture(0u)
21 {
22 setWindowWidth(128);
23 setWindowHeight(128);
24 setConfigRedBits(8);
25 setConfigGreenBits(8);
26 setConfigBlueBits(8);
27 setConfigAlphaBits(8);
28 }
29
testSetUp()30 void testSetUp() override
31 {
32 glGenTextures(1, &mTexture);
33 ASSERT_GL_NO_ERROR();
34 }
35
testTearDown()36 void testTearDown() override { glDeleteTextures(1, &mTexture); }
37
38 GLuint mTexture;
39 };
40
41 // Tests a texture with ETC1 lossy decode format
TEST_P(ETCTextureTest,ETC1Validation)42 TEST_P(ETCTextureTest, ETC1Validation)
43 {
44 bool supported = IsGLExtensionEnabled("GL_ANGLE_lossy_etc_decode");
45
46 glBindTexture(GL_TEXTURE_2D, mTexture);
47
48 GLubyte pixel[8] = {0x0, 0x0, 0xf8, 0x2, 0x43, 0xff, 0x4, 0x12};
49 glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, 4, 4, 0,
50 sizeof(pixel), pixel);
51 if (supported)
52 {
53 EXPECT_GL_NO_ERROR();
54
55 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_ETC1_RGB8_LOSSY_DECODE_ANGLE,
56 sizeof(pixel), pixel);
57 EXPECT_GL_NO_ERROR();
58
59 glCompressedTexImage2D(GL_TEXTURE_2D, 1, GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, 2, 2, 0,
60 sizeof(pixel), pixel);
61 EXPECT_GL_NO_ERROR();
62
63 glCompressedTexImage2D(GL_TEXTURE_2D, 2, GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, 1, 1, 0,
64 sizeof(pixel), pixel);
65 EXPECT_GL_NO_ERROR();
66 }
67 else
68 {
69 EXPECT_GL_ERROR(GL_INVALID_ENUM);
70 }
71 }
72
73 // Tests a texture with ETC2 RGB8 lossy decode format
TEST_P(ETCTextureTest,ETC2RGB8Validation)74 TEST_P(ETCTextureTest, ETC2RGB8Validation)
75 {
76 bool supported = IsGLExtensionEnabled("GL_ANGLE_lossy_etc_decode");
77
78 glBindTexture(GL_TEXTURE_2D, mTexture);
79
80 GLubyte pixel[] = {
81 0x00, 0x00, 0xf8, 0x02, 0x43, 0xff, 0x04, 0x12, // Individual/differential block
82 0x1c, 0x65, 0xc6, 0x62, 0xff, 0xf0, 0xff, 0x00, // T block
83 0x62, 0xf2, 0xe3, 0x32, 0xff, 0x0f, 0xff, 0x00, // H block
84 0x71, 0x88, 0xfb, 0xee, 0x87, 0x07, 0x11, 0x1f // Planar block
85 };
86 glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, 8, 8, 0,
87 sizeof(pixel), pixel);
88 if (supported)
89 {
90 EXPECT_GL_NO_ERROR();
91
92 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8,
93 GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, sizeof(pixel), pixel);
94 EXPECT_GL_NO_ERROR();
95
96 const GLsizei imageSize = 8;
97
98 glCompressedTexImage2D(GL_TEXTURE_2D, 1, GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, 4, 4,
99 0, imageSize, pixel);
100 EXPECT_GL_NO_ERROR();
101
102 glCompressedTexImage2D(GL_TEXTURE_2D, 2, GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, 2, 2,
103 0, imageSize, pixel);
104 EXPECT_GL_NO_ERROR();
105
106 glCompressedTexImage2D(GL_TEXTURE_2D, 3, GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE, 1, 1,
107 0, imageSize, pixel);
108 EXPECT_GL_NO_ERROR();
109 }
110 else
111 {
112 EXPECT_GL_ERROR(GL_INVALID_ENUM);
113 }
114 }
115
116 // Tests a texture with ETC2 SRGB8 lossy decode format
TEST_P(ETCTextureTest,ETC2SRGB8Validation)117 TEST_P(ETCTextureTest, ETC2SRGB8Validation)
118 {
119 bool supported = IsGLExtensionEnabled("GL_ANGLE_lossy_etc_decode");
120
121 glBindTexture(GL_TEXTURE_2D, mTexture);
122
123 GLubyte pixel[] = {
124 0x00, 0x00, 0xf8, 0x02, 0x43, 0xff, 0x04, 0x12, // Individual/differential block
125 0x1c, 0x65, 0xc6, 0x62, 0xff, 0xf0, 0xff, 0x00, // T block
126 0x62, 0xf2, 0xe3, 0x32, 0xff, 0x0f, 0xff, 0x00, // H block
127 0x71, 0x88, 0xfb, 0xee, 0x87, 0x07, 0x11, 0x1f // Planar block
128 };
129 glCompressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, 8, 8, 0,
130 sizeof(pixel), pixel);
131 if (supported)
132 {
133 EXPECT_GL_NO_ERROR();
134
135 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8,
136 GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, sizeof(pixel),
137 pixel);
138 EXPECT_GL_NO_ERROR();
139
140 const GLsizei imageSize = 8;
141
142 glCompressedTexImage2D(GL_TEXTURE_2D, 1, GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, 4, 4,
143 0, imageSize, pixel);
144 EXPECT_GL_NO_ERROR();
145
146 glCompressedTexImage2D(GL_TEXTURE_2D, 2, GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, 2, 2,
147 0, imageSize, pixel);
148 EXPECT_GL_NO_ERROR();
149
150 glCompressedTexImage2D(GL_TEXTURE_2D, 3, GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE, 1, 1,
151 0, imageSize, pixel);
152 EXPECT_GL_NO_ERROR();
153 }
154 else
155 {
156 EXPECT_GL_ERROR(GL_INVALID_ENUM);
157 }
158 }
159
160 // Tests a texture with ETC2 RGB8 punchthrough A1 lossy decode format
TEST_P(ETCTextureTest,ETC2RGB8A1Validation)161 TEST_P(ETCTextureTest, ETC2RGB8A1Validation)
162 {
163 bool supported = IsGLExtensionEnabled("GL_ANGLE_lossy_etc_decode");
164
165 glBindTexture(GL_TEXTURE_2D, mTexture);
166
167 GLubyte pixel[] = {
168 0x80, 0x98, 0x59, 0x02, 0x6e, 0xe7, 0x44, 0x47, // Individual/differential block
169 0xeb, 0x85, 0x68, 0x30, 0x77, 0x73, 0x44, 0x44, // T block
170 0xb4, 0x05, 0xab, 0x92, 0xf8, 0x8c, 0x07, 0x73, // H block
171 0xbb, 0x90, 0x15, 0xba, 0x8a, 0x8c, 0xd5, 0x5f // Planar block
172 };
173 glCompressedTexImage2D(GL_TEXTURE_2D, 0,
174 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 8, 8, 0,
175 sizeof(pixel), pixel);
176 if (supported)
177 {
178 EXPECT_GL_NO_ERROR();
179
180 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8,
181 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE,
182 sizeof(pixel), pixel);
183 EXPECT_GL_NO_ERROR();
184
185 const GLsizei imageSize = 8;
186
187 glCompressedTexImage2D(GL_TEXTURE_2D, 1,
188 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 4, 4,
189 0, imageSize, pixel);
190 EXPECT_GL_NO_ERROR();
191
192 glCompressedTexImage2D(GL_TEXTURE_2D, 2,
193 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 2, 2,
194 0, imageSize, pixel);
195 EXPECT_GL_NO_ERROR();
196
197 glCompressedTexImage2D(GL_TEXTURE_2D, 3,
198 GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 1, 1,
199 0, imageSize, pixel);
200 EXPECT_GL_NO_ERROR();
201 }
202 else
203 {
204 EXPECT_GL_ERROR(GL_INVALID_ENUM);
205 }
206 }
207
208 // Tests a texture with ETC2 SRGB8 punchthrough A1 lossy decode format
TEST_P(ETCTextureTest,ETC2SRGB8A1Validation)209 TEST_P(ETCTextureTest, ETC2SRGB8A1Validation)
210 {
211 bool supported = IsGLExtensionEnabled("GL_ANGLE_lossy_etc_decode");
212
213 glBindTexture(GL_TEXTURE_2D, mTexture);
214
215 GLubyte pixel[] = {
216 0x80, 0x98, 0x59, 0x02, 0x6e, 0xe7, 0x44, 0x47, // Individual/differential block
217 0xeb, 0x85, 0x68, 0x30, 0x77, 0x73, 0x44, 0x44, // T block
218 0xb4, 0x05, 0xab, 0x92, 0xf8, 0x8c, 0x07, 0x73, // H block
219 0xbb, 0x90, 0x15, 0xba, 0x8a, 0x8c, 0xd5, 0x5f // Planar block
220 };
221 glCompressedTexImage2D(GL_TEXTURE_2D, 0,
222 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 8, 8, 0,
223 sizeof(pixel), pixel);
224 if (supported)
225 {
226 EXPECT_GL_NO_ERROR();
227
228 glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 8, 8,
229 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE,
230 sizeof(pixel), pixel);
231 EXPECT_GL_NO_ERROR();
232
233 const GLsizei imageSize = 8;
234
235 glCompressedTexImage2D(GL_TEXTURE_2D, 1,
236 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 4,
237 4, 0, imageSize, pixel);
238 EXPECT_GL_NO_ERROR();
239
240 glCompressedTexImage2D(GL_TEXTURE_2D, 2,
241 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 2,
242 2, 0, imageSize, pixel);
243 EXPECT_GL_NO_ERROR();
244
245 glCompressedTexImage2D(GL_TEXTURE_2D, 3,
246 GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE, 1,
247 1, 0, imageSize, pixel);
248 EXPECT_GL_NO_ERROR();
249 }
250 else
251 {
252 EXPECT_GL_ERROR(GL_INVALID_ENUM);
253 }
254 }
255
256 ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(ETCTextureTest);
257 } // anonymous namespace
258