amd_compressed_atc_texture: add miptree test

Submitted by Ilia Mirkin on March 2, 2015, 3:01 a.m.

Details

Message ID 1425265296-18188-1-git-send-email-imirkin@alum.mit.edu
State New
Headers show

Not browsing as part of any series.

Commit Message

Ilia Mirkin March 2, 2015, 3:01 a.m.
This echoes the ETC1 miptree test, and even uses the same image.

Signed-off-by: Ilia Mirkin <imirkin@alum.mit.edu>
---

I used The Compressonator tool from AMD, which generates DDS files,
so I also added *very* basic support for DDS files in piglit. It could
be extended by an interested party to actually support more formats/etc.

 tests/spec/CMakeLists.txt                          |   1 +
 .../CMakeLists.gles2.txt                           |   6 +
 .../spec/amd_compressed_atc_texture/CMakeLists.txt |   1 +
 tests/spec/amd_compressed_atc_texture/miptree.c    | 261 +++++++++++++++++++++
 .../waffles-compressed-atc-64x32-miptree.dds       | Bin 0 -> 1512 bytes
 .../waffles-decompressed-rgb-64x32-miptree.dds     | Bin 0 -> 8321 bytes
 tests/util/CMakeLists.txt                          |   1 +
 tests/util/piglit-dds.c                            | 220 +++++++++++++++++
 tests/util/piglit-dds.h                            |  72 ++++++
 9 files changed, 562 insertions(+)
 create mode 100644 tests/spec/amd_compressed_atc_texture/CMakeLists.gles2.txt
 create mode 100644 tests/spec/amd_compressed_atc_texture/CMakeLists.txt
 create mode 100644 tests/spec/amd_compressed_atc_texture/miptree.c
 create mode 100644 tests/spec/amd_compressed_atc_texture/waffles-compressed-atc-64x32-miptree.dds
 create mode 100644 tests/spec/amd_compressed_atc_texture/waffles-decompressed-rgb-64x32-miptree.dds
 create mode 100644 tests/util/piglit-dds.c
 create mode 100644 tests/util/piglit-dds.h

Patch hide | download patch | download mbox

diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt
index 7423589..dee56d6 100644
--- a/tests/spec/CMakeLists.txt
+++ b/tests/spec/CMakeLists.txt
@@ -1,3 +1,4 @@ 
+add_subdirectory (amd_compressed_atc_texture)
 add_subdirectory (amd_performance_monitor)
 add_subdirectory (amd_pinned_memory)
 add_subdirectory (arb_base_instance)
diff --git a/tests/spec/amd_compressed_atc_texture/CMakeLists.gles2.txt b/tests/spec/amd_compressed_atc_texture/CMakeLists.gles2.txt
new file mode 100644
index 0000000..0509e44
--- /dev/null
+++ b/tests/spec/amd_compressed_atc_texture/CMakeLists.gles2.txt
@@ -0,0 +1,6 @@ 
+include_directories(
+	${GLEXT_INCLUDE_DIR}
+	${OPENGL_INCLUDE_PATH}
+)
+link_libraries(piglitutil_${piglit_target_api})
+piglit_add_executable(amd_compressed_atc_texture-miptree miptree.c)
diff --git a/tests/spec/amd_compressed_atc_texture/CMakeLists.txt b/tests/spec/amd_compressed_atc_texture/CMakeLists.txt
new file mode 100644
index 0000000..144a306
--- /dev/null
+++ b/tests/spec/amd_compressed_atc_texture/CMakeLists.txt
@@ -0,0 +1 @@ 
+piglit_include_target_api()
diff --git a/tests/spec/amd_compressed_atc_texture/miptree.c b/tests/spec/amd_compressed_atc_texture/miptree.c
new file mode 100644
index 0000000..c533dac
--- /dev/null
+++ b/tests/spec/amd_compressed_atc_texture/miptree.c
@@ -0,0 +1,261 @@ 
+/*
+ * Copyright 2012 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file
+ * \brief Test texturing from an ATC miptree of a real image.
+ *
+ * Copied from identical ETC1 test.
+ *
+ * This test uses two data files. The file waffles-compressed-atc-64x32.dds
+ * contains a full miptree in GL_ATC_RGB_AMD format of a 2D texture of
+ * waffles and fruit [1].  The base level size is 64x32 pixels. The file
+ * waffles-decompressed-rgb-64x32.ktx contains a parallel miptree in GL_RGB
+ * format. Each of its RGB images was obtained by decompressing the corresponding
+ * ATC image with AMD-supplied Compressonator [2].
+ *
+ * This test draws each miplevel i of the ATC texture such that the image's
+ * lower left corner is at (x=0, y=sum(height of miplevel j for j=0 to i-1)),
+ * and it draws each miplevel of the RGB texture to the right of its
+ * corresponding ETC1 image. Then it compares that the images are identical.
+ *
+ * [1] The reference image is located at http://people.freedesktop.org/~chadversary/permalink/2012-07-09/1574cff2-d091-4421-a3cf-b56c7943d060.jpg.
+ * [2] http://developer.amd.com/tools-and-sdks/archive/legacy-cpu-gpu-tools/the-compressonator/
+ */
+
+#include "piglit-util-gl.h"
+#include "piglit-dds.h"
+
+#define num_levels 7
+#define level0_width 64
+#define level0_height 32
+
+#define num_vertices 4
+
+static const int window_width = 2 * level0_width;
+static const int window_height = 2 * level0_height;
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+	config.supports_gl_es_version = 20;
+
+	config.window_width = window_width;
+	config.window_height = window_height;
+	config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+
+static GLuint prog;
+
+/* Texture objects. */
+static GLuint compressed_tex;
+static GLuint decompressed_tex;
+
+/**
+ * The \a filename is relative to the current test's source directory.
+ *
+ * A new texture is created and returned in \a tex_name.
+ */
+static void
+load_texture(const char *filename, GLuint *tex_name)
+{
+	struct piglit_dds *dds;
+	const struct piglit_dds_info *info;
+	char filepath[4096];
+	int i;
+
+	piglit_join_paths(filepath, sizeof(filepath), 5,
+	                  piglit_source_dir(),
+	                  "tests",
+	                  "spec",
+	                  "amd_compressed_atc_texture",
+	                  filename);
+
+	dds = piglit_dds_read_file(filepath);
+	if (dds == NULL)
+		piglit_report_result(PIGLIT_FAIL);
+
+	info = piglit_dds_get_info(dds);
+	assert(info->num_miplevels == num_levels);
+	assert(info->pixel_width == level0_width);
+	assert(info->pixel_height== level0_height);
+
+	glGenTextures(1, tex_name);
+	glBindTexture(GL_TEXTURE_2D, *tex_name);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+	for (i = 0; i < info->num_miplevels; i++) {
+		const struct piglit_dds_image *img = piglit_dds_get_image(dds, i);
+		if (info->gl_internal_format == GL_RGB)
+			glTexImage2D(GL_TEXTURE_2D, i,
+				     info->gl_internal_format,
+				     img->pixel_width,
+				     img->pixel_height,
+				     0,
+				     GL_RGB, GL_UNSIGNED_BYTE,
+				     img->data);
+		else
+			glCompressedTexImage2D(GL_TEXTURE_2D, i,
+					       info->gl_internal_format,
+					       img->pixel_width,
+					       img->pixel_height,
+					       0,
+					       img->size,
+					       img->data);
+		if (glGetError())
+			piglit_report_result(PIGLIT_FAIL);
+	}
+
+	piglit_dds_destroy(dds);
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+	static const char compressed_filename[] = "waffles-compressed-atc-64x32-miptree.dds";
+	static const char decompressed_filename[] = "waffles-decompressed-rgb-64x32-miptree.dds";
+
+	const char vs_source[] =
+		"#version 100\n"
+		"\n"
+		"uniform vec2 window_pixel_size;\n"
+		"uniform vec2 level_pixel_size;\n"
+		"uniform vec2 pixel_offset;\n"
+		"\n"
+		"// vertex is some corner of the unit square [0,1]^2 \n"
+		"attribute vec2 vertex;\n"
+		"varying vec2 tex_coord;\n"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"    vec2 pos = vertex;\n"
+		"    pos *= level_pixel_size;\n"
+		"    pos += pixel_offset;\n"
+		"    pos /= 0.5 * window_pixel_size;\n"
+		"    pos -= vec2(1, 1);\n"
+		"    gl_Position = vec4(pos.xy, 0.0, 1.0);\n"
+		"\n"
+		"    tex_coord = vertex;\n"
+		"}\n";
+
+	const char fs_source[] =
+		"#version 100\n"
+		"precision highp float;\n"
+		"\n"
+		"uniform sampler2D tex;\n"
+		"varying vec2 tex_coord;\n"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"    vec4 t = texture2D(tex, tex_coord);\n"
+		"    gl_FragColor = vec4(t.rgb, 1.0);\n"
+		"}\n";
+
+	/* Draw a square triangle strip. */
+	const GLfloat vertices[2 * num_vertices] = {
+		0, 0,
+		1, 0,
+		1, 1,
+		0, 1,
+	};
+
+	GLint vertex_loc;
+	GLuint vertex_buf;
+
+	piglit_require_extension("GL_AMD_compressed_ATC_texture");
+
+	load_texture(compressed_filename, &compressed_tex);
+	load_texture(decompressed_filename, &decompressed_tex);
+
+	glClearColor(1.0, 0.0, 0.0, 1.0);
+	glViewport(0, 0, window_width, window_height);
+
+	prog = piglit_build_simple_program(vs_source, fs_source);
+	glUseProgram(prog);
+
+	vertex_loc = glGetAttribLocation(prog, "vertex");
+	glGenBuffers(1, &vertex_buf);
+	glBindBuffer(GL_ARRAY_BUFFER, vertex_buf);
+	glEnableVertexAttribArray(vertex_loc);
+	glVertexAttribPointer(vertex_loc, 2, GL_FLOAT, GL_FALSE, 0, NULL);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
+	             GL_STATIC_DRAW);
+
+	glUniform1i(glGetUniformLocation(prog, "tex"), 0);
+	glActiveTexture(GL_TEXTURE0);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+
+	glUniform2f(glGetUniformLocation(prog, "window_pixel_size"),
+	            window_width, window_height);
+}
+
+static void
+minify(int *x)
+{
+	assert(*x > 0);
+
+	if (*x > 1)
+		*x >>= 1;
+}
+
+enum piglit_result
+piglit_display(void)
+{
+	GLint pixel_offset_loc = glGetUniformLocation(prog, "pixel_offset");
+	GLint level_pixel_size_loc = glGetUniformLocation(prog, "level_pixel_size");
+
+	int level = 0;
+	int level_width = level0_width;
+	int level_height = level0_height;
+	int y_offset = 0;
+
+	bool pass = true;
+
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	for (level = 0; level < num_levels; ++level) {
+		glUniform2f(level_pixel_size_loc,
+		            (float) level_width,
+		            (float) level_height);
+
+		/* Draw miplevel of compressed texture. */
+		glBindTexture(GL_TEXTURE_2D, compressed_tex);
+		glUniform2f(pixel_offset_loc, 0, y_offset);
+		glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices);
+
+		/* Draw miplevel of decompressed texture. */
+		glBindTexture(GL_TEXTURE_2D, decompressed_tex);
+		glUniform2f(pixel_offset_loc, level0_width, y_offset);
+		glDrawArrays(GL_TRIANGLE_FAN, 0, num_vertices);
+
+		y_offset += level_height;
+		minify(&level_width);
+		minify(&level_height);
+	}
+
+	pass = piglit_probe_rect_halves_equal_rgba(0, 0, window_width, window_height);
+	piglit_present_results();
+
+	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
diff --git a/tests/spec/amd_compressed_atc_texture/waffles-compressed-atc-64x32-miptree.dds b/tests/spec/amd_compressed_atc_texture/waffles-compressed-atc-64x32-miptree.dds
new file mode 100644
index 0000000000000000000000000000000000000000..de29f5c69ea8984176239460020d68123f4f7e6b
GIT binary patch
literal 1512
zcma)6Z%k8H6h9AbVXd*<2Bcddv_dz)Zt#Uf7qzb~;BdwiM^R+zr1%FausLTInHEfS
z8k41(;j*b11^*zLW*M4&P>Pd=%ox`XRF};3wWFoL<j?fAudu#%b|1!NiC=b-dw=ho
zd+#~#p7T4mwDd#GmjIBel!1mIO$IC!Ct`aJ|9jSuof0yPRc7(?B}r4#FWHz@2ER!1
zJkyGp!9RK=A|T>_v5M#cV!t{ktnzLnibtJdOaEv(hoT^=SB?%SU@o;ahH4c+UH*`e
zB3Gk1|K|O+y#O{1gUBaXbdYn%vmiPrBKkMXBZEmch5!uFh&aUQ**sQSH&{g-ii?Zw
zI|7^|N0C}yz58KG<xKaHmG>rtv8&ZTZ=Mn+My;T29ug48yS@7x(4f@0Y+3J*0yJW2
z+1K%8vPV|1Cx9sMi5Kx-pu3q70~W0o*HKL$ZR{tp0e04%;V?<V68$X>dns_PP)^m>
zS_b}D=Iz5CDs!7=q!$lS5^Y6~0C1b7txjIxgP}wFqdec=k`dkKLa0w%H`f%#sDAvr
zV&82p!G^;Exi<>QfB)lJJiysArBbu<x?g~L+Nl~H#N<q<z1TTuC~8q_Rb5vsAVE|9
zmDs>Q@Ed2tdQ35{ZXPMU!oKmU;=OkLr5|UYwji|P?vwD?>`x)u8S^-#R+Dux9@ypT
zsMvRl1B);CiQ_Cc(AH)W^PUj+<nugZ(zfWA`*OKly(I10rWt??TYABb0RYyRSALD~
zFIB6L+`DlRd>1T|I9OQBHBL<OGv#W^I?hI0B;AsdH={tsBIU*a2T+A$o7K^D3x#Pr
zzT?_}M*E(}9GjR!mxI9*k>@-bo0#}>zOG<Ubmhsssg;m&C`)Ij{XyTwlHE7ho{p-z
zbnl@2_lJ@5#q}|kr0mZ2Zr+n4g<RuTu_7TxbvL}mDM8-g{q#4^7Ys!btpRQvAe3lj
zI1DH8tevD;aM;pUZH}IMw(Q>LYdSfcWtNPq0vxF`jH~)NPYS?DalxR0_`i^MEDRLl
z-TYmTt*{ll^4=akQC5iCG<U-&guflxZjPZtF73*yA6B~&!}<b$U(n+|PWTgMlLC^w
zihc5dmiYI`rA@li4?;~&qb$2~+9PD9ypsL;UIhgpBS@NXV6Beuns$Yb89O<el4E1Z
zlVKEs@}ou>$r8FM8W+daqaAQ(nJgkF2AfqDAyM3yty$3%6crq+VX)1|<CuyetC%yC
z&Y)xKdN{mjoxO4^g_o4;Y|TGZS!LNzKO^zjrP`a$k1ZP`u6Gy?=&<l~Im0E%L6Hwt
zF~9#s|JmzAe-6W8RX-L<J8E_scg6o=al)4OR@@|4c+#o`LSHs0*3Uq8{`!>M*IjM&
zR<?4O0btgvrdw#5ZqFZQH%aV{cKyQ1_|&l9Y#oasMqSaS4V-T{%!~QLq>wZ(x_sKa
zp!Sq0Yv-AC)xoJcx;|DK6x=qeee#y+`#zm<BL|bSd_^PS*C|B*mdD%^oUn{%F~mU&
z)s<i5m(9((b4z3q=*79*ifCBqi{fa_foV{-v1@dU$OCzy_Tcon^#E&i*$k-zy;R#d
z4K7wVQYQN8g@r2_EUJ|#CCgXGvscY_H}08lQ?^TUe2_Zdiwi0<A6ib;OcZL*a2JJ^
u)TRRRKD<l$E>#B5AOZSn8DeO-$23}#`Cw>fXlCt}livG802E#l0RI6`11H)5

literal 0
HcmV?d00001

diff --git a/tests/spec/amd_compressed_atc_texture/waffles-decompressed-rgb-64x32-miptree.dds b/tests/spec/amd_compressed_atc_texture/waffles-decompressed-rgb-64x32-miptree.dds
new file mode 100644
index 0000000000000000000000000000000000000000..b0444b132b703b7ca3e01220a81c8c3afec7aa11
GIT binary patch
literal 8321
zcmb`Me{hra8Nj*yv;5();CbW4Z3o#gxhS5-9rIof{E@jG20@HtY80JD<wv)1ECND+
z354Gjjv9+#WwY8kkhG(aLZz)jH8MLZ6&H0qI%dam!d#Fl?}U2UCw-D9Z$pD~TkgZR
zPv3s?yr1X!e)Hx{xcTNgMlBvPWXLz1UmG%tpEvUFRsLlkUzZ>M@i>Z^H|Ay={Xa89
zh6w$?Ih^^w<|gqYV_BKc`!eS;nSY(loXx|*3y`1IXM1F9kJQODJUk<07;e)H2$8l_
zER$LGQQt#dXU&A=-qh+e{DR^13yXrk$(ks(oP&oVsq+#0Di6^wdPd!wABj2gfHvf+
zNLcD`c4f2#<o({q<CPtZzx>6Tui($QX}kLKtMs<Wsl>1N+y8?3!WX;Tp@iLE`=1RG
zR)K#1kq=a`1ls>>V0eF5voEJ)&t5A2fB0LLg*@hhbY8|88yg_E3IqLF0-?yiumq)?
z?Z??d+JAdspHm{X&RIhAm7`PlB|Onsj$qgm4F70LoB!qX<i@`Xp}*v8#o3q62=2IL
z7^dR#mxqp6f^{yVlu*cIU#IpZ&=N{Mq3{Ql4^(yha7Q!pj4)wEEg&!c<DU5wB^3Fi
z4ddQCdjbE(&NE-`kNp4Uk32}{gKsB+&MU|(mu^3CS<7i)2{4BVAN1jW&FUIq%sq>4
zSia{c)g8jR_^B`V*M=7bg*KOr=s!D0{pmcr2#}X0V04CB6i0ctmZ1Ho1aEsv5p#AC
z_{vkd1SKVG+FEQju)PDMdaVMMmC6%oOW(Ju?Z?w=!M!!E7)xS`!xvR9*>KF&kP$}K
zoi$rCIa<<Yo-60RW%%QQFPh%f`Dxm+;J@}?*>>ElO4$7?pKTWG{v)QZA33i|xcJV9
z!|*~ju=!s!zg_*^d-_B^8?>aSb$&LZ`*X(etGfNQ77*aSy6Lp|_hklLs|)1}?0@~c
zXC8m~lo?HVYmy57!lLH)fA&Ds=?DleR~V%K_&d#zFm%Ff@n;;hwAuGw20YctA^sT1
zDyV#RAzISNM|v|L@-m9QECJi0;B1fj{oguzIvndpTc8A$Cs2O^l_wB?Mizq3Q-V~1
zf1w0lR7;@$>W{YItg&c2=9B=^`9b{$T>@T%!B`qDo6|69K}A_(Qt)g`D6Wcx;BW;U
z4i5~y=zefI{erjAnz=9S3MPdy_w2bQ)WK+&<qlT>JoDn<FvCNq*IqoY&DffDHCV#%
zNc*@o?V+9w5YTfa(wz~~z5TDofp7P+2x5*r_i~2QrMO(4BLCqteyjdch28(w%HtwW
zAm(;|sRDoGi~NT@Qt$M~Cht53>K|!3oh9#|IC(ZRm^>wjzub=^f9;fqSOrG>wFGHC
z{=+7%k<Q!wuUgPV|Dz`}QUas5(gK<fwB0qWV)%`VL7PwiX*=c)GXnSn@{}OWN1m(P
z0RIyAmPP*3fBeVXHWU9V=4@aU@E3XdZ(I^n=>K=8Yy?VR|4;%W{%jtQ641sUvP;n4
zf8<#L<Q2>X_21d~DgLxwO4xb4FMB~B?BUzmaqX<NM*qX<a6)ie0Q4TrR~z@Niw&PJ
z$KmwBC1X~CdwR#WCsaG#HOiIqcKTb>f^VBO>Y+oPa2J8wTc&vY5ycyBSzP@`An-;y
zge`wa1*%dTUimn6&Vq)2W+JH!<KbTPtwC?s&-a%q)Sp1i?f%HC|A+_M!0<&t{V~U%
zDrPO+Qp&$jLf)S$@NanU6ZIE)?lASEQqdxORey&gpwN8G-E9_(uSl>2l)#8KIJ_~y
zACf&Op!wlV^+K-mG~d?$`LUzOtH1rm_`?2|PrR2Mbk*o91eSodUp{#{o2O|1h`eke
zF_)3fYYAw}{$UBk|Eb!2_{;sOjNLscrK8tUr1LV`{b~E4`^R6Mxbmlu8EzjqU8XSN
zx=HS`vg;$Of^~6lZ%vGxwccsC!Ql=L3v6}OSy>u0!tknpm<<+;UEj_UxXO}n>(d`H
zx<e@l)_$BgXTAT0^|!t(l#sFU`I)rtiuB18yt?E0Bd@huy;gzzXN_$6`A1{@PLXE>
zv<3IWS^3G)ErR%um>49;ncMt_l^=72Ixv?K7{y;k@n3)F6Z{jI0d##~ebkpNq{zP}
z5|%0sH8*v=)0r#5=8v||^a#><d;dpHx=Z{iL8_qn$e-^|+eIG#(R1rTN{IGYGaFBc
zKb@z9LH!F$knjFyr;Z~}=kX^HbE?P&=d8wto$Ho`)m(z{k8aiy3Y+KQGTA>;g2+=v
zQUB3ake5pkBRdCwAiy8QpZ&uUoWFn2Pp6Ws0{+N@ECJ1rRYhei(k}eED&gzLFoRBB
z0(r*Vu}T>|X(=@_jtxF%Y)uu|VHtT`8<O9d`OLSbg!szGWd^Q(V2!UfdEJs112x^7
zUq5l+&!@95#_T;LU(sZdSFwzhtHWghUqek*_mK{(H!U>%en-{v5cs?%_-zFJK1JkZ
z{NB`v`Wqg<g1MG(@vQBG_?I8WUrL|~`~i7N5dYkjB)?CxmE`wx^ZwoVV~#%o+FHWQ
zz!Z@$<^OEO6Lx=JMN08*=muE=+AgpP+|m!7`0HF1H2>+85$*u-ml172`d_#V4)n)7
z;P(Q}*CoJzV`K@?aFrj_ANki>_g~mwsxVh26`GHKt_0-EkCyUB9&$TJJ|)@wk&kX#
zDgGiaRp75%Wl(>16z1$7<jLm?Muc@+>Vw;oioZIggxaj&t`m3HeCUfNIrxJG`yHMT
z7=f71S@iTlvn<9~)7a?^$Ax|EJ%#2=3H{@W#S3p9f34ePFhbyVUuag4@s^tg?DK%n
z3l$5?7C#b*1PesNA-#5?ttH$Wi4E#6@{AOs!UW@2cj~X=PYEFMYhF5BN*@2vtTGUP
zv^{Q@l%UNg5P#(D{tZ=8l_%iR+St-ACHMnnAXTUs0i72p!G7Ex+x<(K@2Rgt6nX7G
zO904If>7iy%@=>n4<Br{%Zq>R4X)Rs`N&HZ-e3eKF4}(Ux&v$*#qKOIs{qn@HczT2
zb$;8|EL-X|J;*E4e;HMt0RP!{O^GfEfpne{;+2u}&2xqDxgh_2{`u#XBl2C)_S#);
zmuLLSdNUC5zHPynm5qks1J~W_b{{^*#a*zyOu5qc|DS>!vb_ZC=OXj`xl2h7B<B>8
z-}6S{6y8YeLiy#>*<krMztTl=ffGq)&Ce;M1oE$JXfNqsI)9)lL2@a9;QHs=1x`V7
zfku%Zq)Ybx==%skce+5LCk>G&_uhT~CeNHE7<Jo57(RFJu-iAes?*?YwG=bl4YO-f
zEhj0W@R0oBcnW_0T$|ty)fmozKz_;WaQT7!WR_8r6G-xW{=z9pd;NkP0%;X{{_KaT
zd<lGv#a~Jw?U+S}u6e3U^RGYfale1zyD~D%mjeWvyvU#Y0)<F&$#3{$Ag2&>lK1B?
z_?z>p3_h$ljnU(7aXQVBH{1sVP9yTosr52)oe$Kd;ie5qw=bgTi<%%7Z{b5n=dr&s
z+V{5R=M<!M-#1_Lll;<o?c9))mQ%ph3ttbes!yD>*4MQ&Hokje-OC>WL8;F*<R5$6
zY~+FD=7uWZ6p~r)_Q?+<XC%KQC%=8~VJ@iu{)RnIEL)+;2_(Oal9{uBm`i`epX5dP
z=?@%y`yC*y&oqT;3tj-j?a$&XQ^qcR!`zk<JmI*~x_`g6*Gi{h<Lc#2yXw+C-5|Gx
z^1dUZ<PX;-f$Qz~W%~rf7acuoH~Be{B!8^-O#*v<()xW~^26pe%k-X8GDp`gZ{A%u
z;m#GDLi6k8oy_EyDpdZ(whvUkV$%~OS2Q^R`AIIfk&;=e5OX<&Hiv-x$fx@s<fjC`
z-<M^u{1k$=-lM9I1~0|ma(Tm7&3nOYw;0{tQ0oV03Kx`t*H|V$x_T#kfAj0i2j=^$
zQug_~4jvI?CdnngK85*u3Qw?Hk(oS;fV9Z)6kvYEfm3pdtEcjb!<)lfV|Z))zuF6H
z*RF*6-MgXi<$tdw^KY6Rg+&!@GMT_WZC_IpPhl(z_yZLQnas#!eTwAdS)66dlN*^S
zFkfM^5N}H|pP8~EGLvU<Q2)=xQ&v+^z1Lq>-ulK7N((=i01g5N`4ezlj>yOnCJTC;
gXK{q5$g|>Y9S>HvvO@@D9}++?+7fL@gsT((23cn6xc~qF

literal 0
HcmV?d00001

diff --git a/tests/util/CMakeLists.txt b/tests/util/CMakeLists.txt
index 45fd25f..0b2147f 100644
--- a/tests/util/CMakeLists.txt
+++ b/tests/util/CMakeLists.txt
@@ -35,6 +35,7 @@  set(UTIL_GL_INCLUDES
 set(UTIL_GL_SOURCES
 	fdo-bitmap.c
 	minmax-test.c
+	piglit-dds.c
 	piglit-dispatch.c
 	piglit-dispatch-init.c
 	piglit-fbo.cpp
diff --git a/tests/util/piglit-dds.c b/tests/util/piglit-dds.c
new file mode 100644
index 0000000..c5c7960
--- /dev/null
+++ b/tests/util/piglit-dds.c
@@ -0,0 +1,220 @@ 
+#include <assert.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "piglit-dds.h"
+#include "piglit-util-gl.h"
+
+
+// DDS values taken from http://www.mindcontrol.org/~hplus/graphics/dds-info/
+
+//  little-endian, of course
+
+//  DDS_header.dwFlags
+#define DDSD_CAPS                   0x00000001
+#define DDSD_HEIGHT                 0x00000002
+#define DDSD_WIDTH                  0x00000004
+#define DDSD_PITCH                  0x00000008
+#define DDSD_PIXELFORMAT            0x00001000
+#define DDSD_MIPMAPCOUNT            0x00020000
+#define DDSD_LINEARSIZE             0x00080000
+#define DDSD_DEPTH                  0x00800000
+
+//  DDS_header.sPixelFormat.dwFlags
+#define DDPF_ALPHAPIXELS            0x00000001
+#define DDPF_FOURCC                 0x00000004
+#define DDPF_INDEXED                0x00000020
+#define DDPF_RGB                    0x00000040
+
+//  DDS_header.sCaps.dwCaps1
+#define DDSCAPS_COMPLEX             0x00000008
+#define DDSCAPS_TEXTURE             0x00001000
+#define DDSCAPS_MIPMAP              0x00400000
+
+//  DDS_header.sCaps.dwCaps2
+#define DDSCAPS2_CUBEMAP            0x00000200
+#define DDSCAPS2_CUBEMAP_POSITIVEX  0x00000400
+#define DDSCAPS2_CUBEMAP_NEGATIVEX  0x00000800
+#define DDSCAPS2_CUBEMAP_POSITIVEY  0x00001000
+#define DDSCAPS2_CUBEMAP_NEGATIVEY  0x00002000
+#define DDSCAPS2_CUBEMAP_POSITIVEZ  0x00004000
+#define DDSCAPS2_CUBEMAP_NEGATIVEZ  0x00008000
+#define DDSCAPS2_VOLUME             0x00200000
+
+union DDS_header {
+	struct {
+		unsigned int    dwMagic;
+		unsigned int    dwSize;
+		unsigned int    dwFlags;
+		unsigned int    dwHeight;
+		unsigned int    dwWidth;
+		unsigned int    dwPitchOrLinearSize;
+		unsigned int    dwDepth;
+		unsigned int    dwMipMapCount;
+		unsigned int    dwReserved1[ 11 ];
+
+		//  DDPIXELFORMAT
+		struct {
+			unsigned int    dwSize;
+			unsigned int    dwFlags;
+			unsigned int    dwFourCC;
+			unsigned int    dwRGBBitCount;
+			unsigned int    dwRBitMask;
+			unsigned int    dwGBitMask;
+			unsigned int    dwBBitMask;
+			unsigned int    dwAlphaBitMask;
+		}               sPixelFormat;
+
+		//  DDCAPS2
+		struct {
+			unsigned int    dwCaps1;
+			unsigned int    dwCaps2;
+			unsigned int    dwDDSX;
+			unsigned int    dwReserved;
+		}               sCaps;
+		unsigned int    dwReserved2;
+	};
+	char data[ 128 ];
+};
+
+#define FOURCC(a, b, c, d)  ((a) << 0 | (b) << 8 | (c) << 16 | (d) << 24)
+
+#define DDS_MAGIC   FOURCC('D', 'D', 'S', ' ')
+#define ATC_RGB     FOURCC('A', 'T', 'C', ' ')
+#define ATC_RGBA_E  FOURCC('A', 'T', 'C', 'A')
+#define ATC_RGBA_I  FOURCC('A', 'T', 'C', 'I')
+
+struct piglit_dds {
+	struct piglit_dds_info info;
+	void *data;
+	size_t size;
+
+	struct piglit_dds_image *images;
+};
+
+void
+piglit_dds_destroy(struct piglit_dds *self)
+{
+	free(self->images);
+	free(self->data);
+	free(self);
+}
+
+struct piglit_dds *
+piglit_dds_read_file(const char *filename)
+{
+	struct piglit_dds *ret = calloc(1, sizeof(struct piglit_dds));
+	FILE *f;
+	bool success = false;
+	int read, i, shift = 0, factor = 0;
+	union DDS_header *header;
+
+	if (!ret)
+		goto err_ret;
+
+	f = fopen(filename, "rb");
+
+	if (!f)
+		goto err_file;
+
+	if (fseek(f, 0, SEEK_END))
+		goto err_read;
+	ret->size = ftell(f);
+	if (fseek(f, 0, SEEK_SET))
+		goto err_read;
+
+	ret->data = malloc(ret->size);
+	if (!ret->data)
+		goto err_read;
+
+	read = fread(ret->data, 1, ret->size, f);
+	if (read < ret->size)
+		goto err_read;
+
+	header = ret->data;
+
+	if (header->dwMagic != DDS_MAGIC)
+		goto err_read;
+
+	ret->info.num_miplevels = header->dwMipMapCount;
+	ret->info.pixel_width = header->dwWidth;
+	ret->info.pixel_height = header->dwHeight;
+	switch (header->sPixelFormat.dwFourCC) {
+	case 0:
+		ret->info.gl_internal_format = GL_RGB;
+		factor = 3;
+		/* And the actual data is GL_BGR, which doesn't exist
+		 * in gles2, so we have to do it by hand.
+		 */
+		for (i = 128; i < ret->size; i += 3) {
+			uint8_t *texel = ret->data + i;
+			uint8_t tmp = texel[0];
+			texel[0] = texel[2];
+			texel[2] = tmp;
+		}
+		break;
+	case ATC_RGB:
+		ret->info.gl_internal_format = GL_ATC_RGB_AMD;
+		shift = 1;
+		break;
+	case ATC_RGBA_I:
+		ret->info.gl_internal_format = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;
+		break;
+	case ATC_RGBA_E:
+		ret->info.gl_internal_format = GL_ATC_RGBA_EXPLICIT_ALPHA_AMD;
+		break;
+	default:
+		goto err_read;
+	}
+
+	ret->images = calloc(ret->info.num_miplevels, sizeof(struct piglit_dds_image));
+	for (i = 0; i < ret->info.num_miplevels; i++) {
+		struct piglit_dds_image *img = &ret->images[i];
+		if (i == 0) {
+			img->data = ret->data + 128;
+			img->pixel_width = ret->info.pixel_width;
+			img->pixel_height = ret->info.pixel_height;
+		} else {
+			struct piglit_dds_image *prev = &ret->images[i - 1];
+			img->data = prev->data + prev->size;
+			img->pixel_width = MAX2(1, prev->pixel_width >> 1);
+			img->pixel_height = MAX2(1, prev->pixel_height >> 1);
+		}
+		if (header->sPixelFormat.dwFourCC)
+			img->size = ALIGN(img->pixel_width, 4) * ALIGN(img->pixel_height, 4);
+		else
+			img->size = img->pixel_width * img->pixel_height;
+		if (shift > 0)
+			img->size >>= shift;
+		if (factor > 0)
+			img->size *= factor;
+	}
+
+	success = true;
+
+err_read:
+	fclose(f);
+	if (success)
+		return ret;
+	if (ret->data)
+		free(ret->data);
+err_file:
+	free(ret);
+err_ret:
+	return NULL;
+}
+
+const struct piglit_dds_info *
+piglit_dds_get_info(struct piglit_dds *self)
+{
+	return &self->info;
+}
+
+const struct piglit_dds_image *
+piglit_dds_get_image(struct piglit_dds *self,
+                     int miplevel)
+{
+	assert(miplevel < self->info.num_miplevels);
+	return &self->images[miplevel];
+}
diff --git a/tests/util/piglit-dds.h b/tests/util/piglit-dds.h
new file mode 100644
index 0000000..8f4c9ae
--- /dev/null
+++ b/tests/util/piglit-dds.h
@@ -0,0 +1,72 @@ 
+/*
+ * Copyright 2015 Ilia Mirkin
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+/**
+ * \file
+ *
+ * \brief Utilities for the DDS file format
+ *
+ * The DDS file format specifies a simple format for storing texture
+ * miptrees.
+ */
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct piglit_dds;
+
+struct piglit_dds_info {
+  uint32_t gl_internal_format;
+  uint32_t num_miplevels;
+
+  uint32_t pixel_width;
+  uint32_t pixel_height;
+};
+
+struct piglit_dds_image {
+  const void *data;
+  size_t size;
+
+  uint32_t pixel_width;
+  uint32_t pixel_height;
+};
+
+void
+piglit_dds_destroy(struct piglit_dds *self);
+
+struct piglit_dds *
+piglit_dds_read_file(const char *filename);
+
+const struct piglit_dds_info *
+piglit_dds_get_info(struct piglit_dds *self);
+
+const struct piglit_dds_image *
+piglit_dds_get_image(struct piglit_dds *self,
+                     int miplevel);
+
+#ifdef __cplusplus
+}
+#endif