Merge branch '7.8'
[mesa.git] / src / gallium / state_trackers / python / st_sample.c
1 /**************************************************************************
2 *
3 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "pipe/p_compiler.h"
30 #include "pipe/p_format.h"
31 #include "pipe/p_state.h"
32 #include "util/u_inlines.h"
33 #include "util/u_format.h"
34 #include "util/u_tile.h"
35 #include "util/u_math.h"
36 #include "util/u_memory.h"
37
38 #include "st_device.h"
39 #include "st_sample.h"
40
41
42 /**
43 * Use our own pseudo random generator to ensure consistent runs among
44 * multiple runs and platforms.
45 *
46 * @sa http://en.wikipedia.org/wiki/Linear_congruential_generator
47 */
48 static uint32_t st_random(void) {
49 static uint64_t seed = UINT64_C(0xbb9a063afb0a739d);
50
51 seed = UINT64_C(134775813) * seed + UINT64_C(1);
52
53 return (uint32_t)(seed >> 32);
54 }
55
56
57 /**
58 * We don't want to include the patent-encumbered DXT code here, so instead
59 * we store several uncompressed/compressed data pairs for hardware testing
60 * purposes.
61 */
62 struct dxt_data
63 {
64 uint8_t rgba[16*4];
65 uint8_t raw[16];
66 };
67
68
69 static const struct dxt_data
70 dxt1_rgb_data[] = {
71 {
72 {
73 0x99, 0xb0, 0x8e, 0xff,
74 0x5d, 0x62, 0x89, 0xff,
75 0x99, 0xb0, 0x8e, 0xff,
76 0x99, 0xb0, 0x8e, 0xff,
77 0xd6, 0xff, 0x94, 0xff,
78 0x5d, 0x62, 0x89, 0xff,
79 0x99, 0xb0, 0x8e, 0xff,
80 0xd6, 0xff, 0x94, 0xff,
81 0x5d, 0x62, 0x89, 0xff,
82 0x5d, 0x62, 0x89, 0xff,
83 0x99, 0xb0, 0x8e, 0xff,
84 0x21, 0x14, 0x84, 0xff,
85 0x5d, 0x62, 0x89, 0xff,
86 0x21, 0x14, 0x84, 0xff,
87 0x21, 0x14, 0x84, 0xff,
88 0x99, 0xb0, 0x8e, 0xff
89 },
90 {0xf2, 0xd7, 0xb0, 0x20, 0xae, 0x2c, 0x6f, 0x97}
91 },
92 {
93 {
94 0xb5, 0xcf, 0x9c, 0xff,
95 0x83, 0x8c, 0x8b, 0xff,
96 0x21, 0x08, 0x6b, 0xff,
97 0x83, 0x8c, 0x8b, 0xff,
98 0x52, 0x4a, 0x7b, 0xff,
99 0x83, 0x8c, 0x8b, 0xff,
100 0x83, 0x8c, 0x8b, 0xff,
101 0xb5, 0xcf, 0x9c, 0xff,
102 0x21, 0x08, 0x6b, 0xff,
103 0xb5, 0xcf, 0x9c, 0xff,
104 0x83, 0x8c, 0x8b, 0xff,
105 0x52, 0x4a, 0x7b, 0xff,
106 0xb5, 0xcf, 0x9c, 0xff,
107 0x83, 0x8c, 0x8b, 0xff,
108 0x52, 0x4a, 0x7b, 0xff,
109 0x83, 0x8c, 0x8b, 0xff
110 },
111 {0x73, 0xb6, 0x4d, 0x20, 0x98, 0x2b, 0xe1, 0xb8}
112 },
113 {
114 {
115 0x00, 0x2c, 0xff, 0xff,
116 0x94, 0x8d, 0x7b, 0xff,
117 0x4a, 0x5c, 0xbd, 0xff,
118 0x4a, 0x5c, 0xbd, 0xff,
119 0x4a, 0x5c, 0xbd, 0xff,
120 0x94, 0x8d, 0x7b, 0xff,
121 0x94, 0x8d, 0x7b, 0xff,
122 0x94, 0x8d, 0x7b, 0xff,
123 0xde, 0xbe, 0x39, 0xff,
124 0x94, 0x8d, 0x7b, 0xff,
125 0xde, 0xbe, 0x39, 0xff,
126 0xde, 0xbe, 0x39, 0xff,
127 0xde, 0xbe, 0x39, 0xff,
128 0xde, 0xbe, 0x39, 0xff,
129 0xde, 0xbe, 0x39, 0xff,
130 0x94, 0x8d, 0x7b, 0xff
131 },
132 {0xe7, 0xdd, 0x7f, 0x01, 0xf9, 0xab, 0x08, 0x80}
133 },
134 {
135 {
136 0x6b, 0x24, 0x21, 0xff,
137 0x7b, 0x4f, 0x5d, 0xff,
138 0x7b, 0x4f, 0x5d, 0xff,
139 0x8b, 0x7a, 0x99, 0xff,
140 0x7b, 0x4f, 0x5d, 0xff,
141 0x7b, 0x4f, 0x5d, 0xff,
142 0x6b, 0x24, 0x21, 0xff,
143 0x8b, 0x7a, 0x99, 0xff,
144 0x9c, 0xa6, 0xd6, 0xff,
145 0x6b, 0x24, 0x21, 0xff,
146 0x7b, 0x4f, 0x5d, 0xff,
147 0x8b, 0x7a, 0x99, 0xff,
148 0x6b, 0x24, 0x21, 0xff,
149 0x8b, 0x7a, 0x99, 0xff,
150 0x7b, 0x4f, 0x5d, 0xff,
151 0x9c, 0xa6, 0xd6, 0xff
152 },
153 {0x3a, 0x9d, 0x24, 0x69, 0xbd, 0x9f, 0xb4, 0x39}
154 }
155 };
156
157
158 static const struct dxt_data
159 dxt1_rgba_data[] = {
160 {
161 {
162 0x00, 0x00, 0x00, 0x00,
163 0x4e, 0xaa, 0x90, 0xff,
164 0x4e, 0xaa, 0x90, 0xff,
165 0x00, 0x00, 0x00, 0x00,
166 0x4e, 0xaa, 0x90, 0xff,
167 0x29, 0xff, 0xff, 0xff,
168 0x00, 0x00, 0x00, 0x00,
169 0x4e, 0xaa, 0x90, 0xff,
170 0x73, 0x55, 0x21, 0xff,
171 0x00, 0x00, 0x00, 0x00,
172 0x00, 0x00, 0x00, 0x00,
173 0x4e, 0xaa, 0x90, 0xff,
174 0x4e, 0xaa, 0x90, 0xff,
175 0x00, 0x00, 0x00, 0x00,
176 0x00, 0x00, 0x00, 0x00,
177 0x4e, 0xaa, 0x90, 0xff
178 },
179 {0xff, 0x2f, 0xa4, 0x72, 0xeb, 0xb2, 0xbd, 0xbe}
180 },
181 {
182 {
183 0xb5, 0xe3, 0x63, 0xff,
184 0x00, 0x00, 0x00, 0x00,
185 0x6b, 0x24, 0x84, 0xff,
186 0xb5, 0xe3, 0x63, 0xff,
187 0x00, 0x00, 0x00, 0x00,
188 0xb5, 0xe3, 0x63, 0xff,
189 0x00, 0x00, 0x00, 0x00,
190 0x00, 0x00, 0x00, 0x00,
191 0x00, 0x00, 0x00, 0x00,
192 0x00, 0x00, 0x00, 0x00,
193 0x6b, 0x24, 0x84, 0xff,
194 0x6b, 0x24, 0x84, 0xff,
195 0x00, 0x00, 0x00, 0x00,
196 0xb5, 0xe3, 0x63, 0xff,
197 0x90, 0x83, 0x73, 0xff,
198 0xb5, 0xe3, 0x63, 0xff
199 },
200 {0x30, 0x69, 0x0c, 0xb7, 0x4d, 0xf7, 0x0f, 0x67}
201 },
202 {
203 {
204 0x00, 0x00, 0x00, 0x00,
205 0xc6, 0x86, 0x8c, 0xff,
206 0xc6, 0x86, 0x8c, 0xff,
207 0x21, 0x65, 0x42, 0xff,
208 0x21, 0x65, 0x42, 0xff,
209 0x21, 0x65, 0x42, 0xff,
210 0x21, 0x65, 0x42, 0xff,
211 0x00, 0x00, 0x00, 0x00,
212 0x00, 0x00, 0x00, 0x00,
213 0x21, 0x65, 0x42, 0xff,
214 0xc6, 0x86, 0x8c, 0xff,
215 0x00, 0x00, 0x00, 0x00,
216 0x00, 0x00, 0x00, 0x00,
217 0x00, 0x00, 0x00, 0x00,
218 0x00, 0x00, 0x00, 0x00,
219 0xc6, 0x86, 0x8c, 0xff
220 },
221 {0x28, 0x23, 0x31, 0xc4, 0x17, 0xc0, 0xd3, 0x7f}
222 },
223 {
224 {
225 0x00, 0x00, 0x00, 0x00,
226 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00,
228 0xc6, 0xe3, 0x9c, 0xff,
229 0x7b, 0x1c, 0x52, 0xff,
230 0x00, 0x00, 0x00, 0x00,
231 0x00, 0x00, 0x00, 0x00,
232 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00,
234 0x7b, 0x1c, 0x52, 0xff,
235 0x00, 0x00, 0x00, 0x00,
236 0x7b, 0x1c, 0x52, 0xff,
237 0xa0, 0x7f, 0x77, 0xff,
238 0xc6, 0xe3, 0x9c, 0xff,
239 0x00, 0x00, 0x00, 0x00,
240 0xa0, 0x7f, 0x77, 0xff
241 },
242 {0xea, 0x78, 0x13, 0xc7, 0x7f, 0xfc, 0x33, 0xb6}
243 },
244 };
245
246
247 static const struct dxt_data
248 dxt3_rgba_data[] = {
249 {
250 {
251 0x6d, 0xc6, 0x96, 0x77,
252 0x6d, 0xc6, 0x96, 0xee,
253 0x6d, 0xc6, 0x96, 0xaa,
254 0x8c, 0xff, 0xb5, 0x44,
255 0x6d, 0xc6, 0x96, 0xff,
256 0x6d, 0xc6, 0x96, 0x88,
257 0x31, 0x55, 0x5a, 0x66,
258 0x6d, 0xc6, 0x96, 0x99,
259 0x31, 0x55, 0x5a, 0xbb,
260 0x31, 0x55, 0x5a, 0x55,
261 0x31, 0x55, 0x5a, 0x11,
262 0x6d, 0xc6, 0x96, 0xcc,
263 0x6d, 0xc6, 0x96, 0xcc,
264 0x6d, 0xc6, 0x96, 0x11,
265 0x31, 0x55, 0x5a, 0x44,
266 0x31, 0x55, 0x5a, 0x88
267 },
268 {0xe7, 0x4a, 0x8f, 0x96, 0x5b, 0xc1, 0x1c, 0x84, 0xf6, 0x8f, 0xab, 0x32, 0x2a, 0x9a, 0x95, 0x5a}
269 },
270 {
271 {
272 0xad, 0xeb, 0x73, 0x99,
273 0x97, 0xaa, 0x86, 0x66,
274 0x6b, 0x28, 0xad, 0x99,
275 0xad, 0xeb, 0x73, 0x99,
276 0x6b, 0x28, 0xad, 0x22,
277 0xad, 0xeb, 0x73, 0xff,
278 0x97, 0xaa, 0x86, 0x55,
279 0x6b, 0x28, 0xad, 0x55,
280 0x6b, 0x28, 0xad, 0x44,
281 0xad, 0xeb, 0x73, 0x33,
282 0x6b, 0x28, 0xad, 0xee,
283 0x6b, 0x28, 0xad, 0x99,
284 0x97, 0xaa, 0x86, 0x66,
285 0xad, 0xeb, 0x73, 0xbb,
286 0x97, 0xaa, 0x86, 0x99,
287 0xad, 0xeb, 0x73, 0xbb
288 },
289 {0x69, 0x99, 0xf2, 0x55, 0x34, 0x9e, 0xb6, 0xb9, 0x4e, 0xaf, 0x55, 0x69, 0x18, 0x61, 0x51, 0x22}
290 },
291 {
292 {
293 0x63, 0xd7, 0xd6, 0x00,
294 0x57, 0x62, 0x5d, 0xdd,
295 0x57, 0x62, 0x5d, 0xcc,
296 0x57, 0x62, 0x5d, 0xbb,
297 0x52, 0x28, 0x21, 0xaa,
298 0x57, 0x62, 0x5d, 0xcc,
299 0x57, 0x62, 0x5d, 0xcc,
300 0x57, 0x62, 0x5d, 0x66,
301 0x57, 0x62, 0x5d, 0x22,
302 0x57, 0x62, 0x5d, 0xdd,
303 0x63, 0xd7, 0xd6, 0xee,
304 0x57, 0x62, 0x5d, 0x33,
305 0x63, 0xd7, 0xd6, 0x55,
306 0x52, 0x28, 0x21, 0x55,
307 0x57, 0x62, 0x5d, 0x11,
308 0x5d, 0x9c, 0x99, 0xee
309 },
310 {0xd0, 0xbc, 0xca, 0x6c, 0xd2, 0x3e, 0x55, 0xe1, 0xba, 0x66, 0x44, 0x51, 0xfc, 0xfd, 0xcf, 0xb4}
311 },
312 {
313 {
314 0x94, 0x6f, 0x60, 0x22,
315 0x94, 0x6f, 0x60, 0x22,
316 0xc5, 0xab, 0x76, 0x11,
317 0xc5, 0xab, 0x76, 0xee,
318 0x63, 0x34, 0x4a, 0xdd,
319 0x63, 0x34, 0x4a, 0x33,
320 0x94, 0x6f, 0x60, 0x77,
321 0xf7, 0xe7, 0x8c, 0x00,
322 0x94, 0x6f, 0x60, 0x33,
323 0x63, 0x34, 0x4a, 0xaa,
324 0x94, 0x6f, 0x60, 0x77,
325 0x63, 0x34, 0x4a, 0xcc,
326 0x94, 0x6f, 0x60, 0xaa,
327 0xf7, 0xe7, 0x8c, 0x99,
328 0x63, 0x34, 0x4a, 0x44,
329 0xc5, 0xab, 0x76, 0xaa
330 },
331 {0x22, 0xe1, 0x3d, 0x07, 0xa3, 0xc7, 0x9a, 0xa4, 0x31, 0xf7, 0xa9, 0x61, 0xaf, 0x35, 0x77, 0x93}
332 },
333 };
334
335
336 static const struct dxt_data
337 dxt5_rgba_data[] = {
338 {
339 {
340 0x6d, 0xc6, 0x96, 0x74,
341 0x6d, 0xc6, 0x96, 0xf8,
342 0x6d, 0xc6, 0x96, 0xb6,
343 0x8c, 0xff, 0xb5, 0x53,
344 0x6d, 0xc6, 0x96, 0xf8,
345 0x6d, 0xc6, 0x96, 0x95,
346 0x31, 0x55, 0x5a, 0x53,
347 0x6d, 0xc6, 0x96, 0x95,
348 0x31, 0x55, 0x5a, 0xb6,
349 0x31, 0x55, 0x5a, 0x53,
350 0x31, 0x55, 0x5a, 0x11,
351 0x6d, 0xc6, 0x96, 0xd7,
352 0x6d, 0xc6, 0x96, 0xb6,
353 0x6d, 0xc6, 0x96, 0x11,
354 0x31, 0x55, 0x5a, 0x32,
355 0x31, 0x55, 0x5a, 0x95
356 },
357 {0xf8, 0x11, 0xc5, 0x0c, 0x9a, 0x73, 0xb4, 0x9c, 0xf6, 0x8f, 0xab, 0x32, 0x2a, 0x9a, 0x95, 0x5a}
358 },
359 {
360 {
361 0xad, 0xeb, 0x73, 0xa1,
362 0x97, 0xaa, 0x86, 0x65,
363 0x6b, 0x28, 0xad, 0xa1,
364 0xad, 0xeb, 0x73, 0xa1,
365 0x6b, 0x28, 0xad, 0x2a,
366 0xad, 0xeb, 0x73, 0xfb,
367 0x97, 0xaa, 0x86, 0x47,
368 0x6b, 0x28, 0xad, 0x65,
369 0x6b, 0x28, 0xad, 0x47,
370 0xad, 0xeb, 0x73, 0x47,
371 0x6b, 0x28, 0xad, 0xdd,
372 0x6b, 0x28, 0xad, 0xa1,
373 0x97, 0xaa, 0x86, 0x65,
374 0xad, 0xeb, 0x73, 0xbf,
375 0x97, 0xaa, 0x86, 0xa1,
376 0xad, 0xeb, 0x73, 0xbf
377 },
378 {0xfb, 0x2a, 0x34, 0x19, 0xdc, 0xbf, 0xe8, 0x71, 0x4e, 0xaf, 0x55, 0x69, 0x18, 0x61, 0x51, 0x22}
379 },
380 {
381 {
382 0x63, 0xd7, 0xd6, 0x00,
383 0x57, 0x62, 0x5d, 0xf5,
384 0x57, 0x62, 0x5d, 0xd2,
385 0x57, 0x62, 0x5d, 0xaf,
386 0x52, 0x28, 0x21, 0xaf,
387 0x57, 0x62, 0x5d, 0xd2,
388 0x57, 0x62, 0x5d, 0xd2,
389 0x57, 0x62, 0x5d, 0x69,
390 0x57, 0x62, 0x5d, 0x23,
391 0x57, 0x62, 0x5d, 0xd2,
392 0x63, 0xd7, 0xd6, 0xf5,
393 0x57, 0x62, 0x5d, 0x46,
394 0x63, 0xd7, 0xd6, 0x46,
395 0x52, 0x28, 0x21, 0x69,
396 0x57, 0x62, 0x5d, 0x23,
397 0x5d, 0x9c, 0x99, 0xf5
398 },
399 {0xf5, 0x00, 0x81, 0x36, 0xa9, 0x17, 0xec, 0x1e, 0xba, 0x66, 0x44, 0x51, 0xfc, 0xfd, 0xcf, 0xb4}
400 },
401 {
402 {
403 0x94, 0x6f, 0x60, 0x25,
404 0x94, 0x6f, 0x60, 0x25,
405 0xc5, 0xab, 0x76, 0x05,
406 0xc5, 0xab, 0x76, 0xe8,
407 0x63, 0x34, 0x4a, 0xe8,
408 0x63, 0x34, 0x4a, 0x25,
409 0x94, 0x6f, 0x60, 0x86,
410 0xf7, 0xe7, 0x8c, 0x05,
411 0x94, 0x6f, 0x60, 0x25,
412 0x63, 0x34, 0x4a, 0xa7,
413 0x94, 0x6f, 0x60, 0x66,
414 0x63, 0x34, 0x4a, 0xc7,
415 0x94, 0x6f, 0x60, 0xa7,
416 0xf7, 0xe7, 0x8c, 0xa7,
417 0x63, 0x34, 0x4a, 0x45,
418 0xc5, 0xab, 0x76, 0xa7
419 },
420 {0xe8, 0x05, 0x7f, 0x80, 0x33, 0x5f, 0xb5, 0x79, 0x31, 0xf7, 0xa9, 0x61, 0xaf, 0x35, 0x77, 0x93}
421 },
422 };
423
424
425 static INLINE void
426 st_sample_dxt_pixel_block(enum pipe_format format,
427 uint8_t *raw,
428 float *rgba, unsigned rgba_stride,
429 unsigned w, unsigned h)
430 {
431 const struct dxt_data *data;
432 unsigned n;
433 unsigned i;
434 unsigned x, y, ch;
435
436 switch(format) {
437 case PIPE_FORMAT_DXT1_RGB:
438 data = dxt1_rgb_data;
439 n = sizeof(dxt1_rgb_data)/sizeof(dxt1_rgb_data[0]);
440 break;
441 case PIPE_FORMAT_DXT1_RGBA:
442 data = dxt1_rgba_data;
443 n = sizeof(dxt1_rgba_data)/sizeof(dxt1_rgba_data[0]);
444 break;
445 case PIPE_FORMAT_DXT3_RGBA:
446 data = dxt3_rgba_data;
447 n = sizeof(dxt3_rgba_data)/sizeof(dxt3_rgba_data[0]);
448 break;
449 case PIPE_FORMAT_DXT5_RGBA:
450 data = dxt5_rgba_data;
451 n = sizeof(dxt5_rgba_data)/sizeof(dxt5_rgba_data[0]);
452 break;
453 default:
454 assert(0);
455 return;
456 }
457
458 i = st_random() % n;
459
460 for(y = 0; y < h; ++y)
461 for(x = 0; x < w; ++x)
462 for(ch = 0; ch < 4; ++ch)
463 rgba[y*rgba_stride + x*4 + ch] = (float)(data[i].rgba[y*4*4 + x*4 + ch])/255.0f;
464
465 memcpy(raw, data[i].raw, util_format_get_blocksize(format));
466 }
467
468
469 static INLINE void
470 st_sample_generic_pixel_block(enum pipe_format format,
471 uint8_t *raw,
472 float *rgba, unsigned rgba_stride,
473 unsigned w, unsigned h,
474 boolean norm)
475 {
476 unsigned i;
477 unsigned x, y, ch;
478 int blocksize = util_format_get_blocksize(format);
479
480 if (norm) {
481 for (y = 0; y < h; ++y) {
482 for (x = 0; x < w; ++x) {
483 for (ch = 0; ch < 4; ++ch) {
484 unsigned offset = y*rgba_stride + x*4 + ch;
485 rgba[offset] = (st_random() & 0xff) / (double)0xff;
486 }
487 }
488 }
489
490 util_format_write_4f(format,
491 rgba, rgba_stride * sizeof(float),
492 raw, util_format_get_stride(format, w),
493 0, 0, w, h);
494
495 } else {
496 for (i = 0; i < blocksize; ++i)
497 raw[i] = (uint8_t)st_random();
498 }
499
500 util_format_read_4f(format,
501 rgba, rgba_stride * sizeof(float),
502 raw, util_format_get_stride(format, w),
503 0, 0, w, h);
504
505 if (format == PIPE_FORMAT_UYVY || format == PIPE_FORMAT_YUYV) {
506 for (y = 0; y < h; ++y) {
507 for (x = 0; x < w; ++x) {
508 for (ch = 0; ch < 4; ++ch) {
509 unsigned offset = y*rgba_stride + x*4 + ch;
510 rgba[offset] = CLAMP(rgba[offset], 0.0f, 1.0f);
511 }
512 }
513 }
514 }
515 }
516
517
518 /**
519 * Randomly sample pixels.
520 */
521 void
522 st_sample_pixel_block(enum pipe_format format,
523 void *raw,
524 float *rgba, unsigned rgba_stride,
525 unsigned w, unsigned h,
526 boolean norm)
527 {
528 switch(format) {
529 case PIPE_FORMAT_DXT1_RGB:
530 case PIPE_FORMAT_DXT1_RGBA:
531 case PIPE_FORMAT_DXT3_RGBA:
532 case PIPE_FORMAT_DXT5_RGBA:
533 st_sample_dxt_pixel_block(format, raw, rgba, rgba_stride, w, h);
534 break;
535
536 default:
537 st_sample_generic_pixel_block(format, raw, rgba, rgba_stride, w, h, norm);
538 break;
539 }
540 }
541
542
543 void
544 st_sample_surface(struct pipe_context *pipe,
545 struct st_surface *surface,
546 float *rgba,
547 boolean norm)
548 {
549 struct pipe_texture *texture = surface->texture;
550 unsigned width = u_minify(texture->width0, surface->level);
551 unsigned height = u_minify(texture->height0, surface->level);
552 uint rgba_stride = width * 4;
553 struct pipe_transfer *transfer;
554 void *raw;
555
556 transfer = pipe->get_tex_transfer(pipe,
557 surface->texture,
558 surface->face,
559 surface->level,
560 surface->zslice,
561 PIPE_TRANSFER_WRITE,
562 0, 0,
563 width,
564 height);
565 if (!transfer)
566 return;
567
568 raw = pipe->transfer_map(pipe, transfer);
569 if (raw) {
570 enum pipe_format format = texture->format;
571 uint x, y;
572 int nblocksx = util_format_get_nblocksx(format, width);
573 int nblocksy = util_format_get_nblocksy(format, height);
574 int blockwidth = util_format_get_blockwidth(format);
575 int blockheight = util_format_get_blockheight(format);
576 int blocksize = util_format_get_blocksize(format);
577
578
579 for (y = 0; y < nblocksy; ++y) {
580 for (x = 0; x < nblocksx; ++x) {
581 st_sample_pixel_block(format,
582 (uint8_t *) raw + y * transfer->stride + x * blocksize,
583 rgba + y * blockheight * rgba_stride + x * blockwidth * 4,
584 rgba_stride,
585 MIN2(blockwidth, width - x*blockwidth),
586 MIN2(blockheight, height - y*blockheight),
587 norm);
588 }
589 }
590
591 pipe->transfer_unmap(pipe, transfer);
592 }
593
594 pipe->tex_transfer_destroy(pipe, transfer);
595 }