projects / mesa.git / blob
? search:


08673d465e5b39fbfac7f7c6da44d9568e878377
[mesa.git] / src / gallium / drivers / softpipe / sp_image.c
1 /*
2 * Copyright 2016 Red Hat.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "sp_context.h"
25 #include "sp_image.h"
26 #include "sp_texture.h"
27
28 #include "util/format/u_format.h"
29
30 /*
31 * Get the offset into the base image
32 * first element for a buffer or layer/level for texture.
33 */
34 static uint32_t
35 get_image_offset(const struct softpipe_resource *spr,
36 const struct pipe_image_view *iview,
37 enum pipe_format format, unsigned r_coord)
38 {
39 int base_layer = 0;
40
41 if (spr->base.target == PIPE_BUFFER)
42 return iview->u.buf.offset;
43
44 if (spr->base.target == PIPE_TEXTURE_1D_ARRAY ||
45 spr->base.target == PIPE_TEXTURE_2D_ARRAY ||
46 spr->base.target == PIPE_TEXTURE_CUBE_ARRAY ||
47 spr->base.target == PIPE_TEXTURE_CUBE ||
48 spr->base.target == PIPE_TEXTURE_3D)
49 base_layer = r_coord + iview->u.tex.first_layer;
50 return softpipe_get_tex_image_offset(spr, iview->u.tex.level, base_layer);
51 }
52
53 /*
54 * Does this texture instruction have a layer or depth parameter.
55 */
56 static inline bool
57 has_layer_or_depth(unsigned tgsi_tex_instr)
58 {
59 return (tgsi_tex_instr == TGSI_TEXTURE_3D ||
60 tgsi_tex_instr == TGSI_TEXTURE_CUBE ||
61 tgsi_tex_instr == TGSI_TEXTURE_1D_ARRAY ||
62 tgsi_tex_instr == TGSI_TEXTURE_2D_ARRAY ||
63 tgsi_tex_instr == TGSI_TEXTURE_CUBE_ARRAY ||
64 tgsi_tex_instr == TGSI_TEXTURE_2D_ARRAY_MSAA);
65 }
66
67 /*
68 * Is this texture instruction a single non-array coordinate.
69 */
70 static inline bool
71 has_1coord(unsigned tgsi_tex_instr)
72 {
73 return (tgsi_tex_instr == TGSI_TEXTURE_BUFFER ||
74 tgsi_tex_instr == TGSI_TEXTURE_1D ||
75 tgsi_tex_instr == TGSI_TEXTURE_1D_ARRAY);
76 }
77
78 /*
79 * check the bounds vs w/h/d
80 */
81 static inline bool
82 bounds_check(int width, int height, int depth,
83 int s, int t, int r)
84 {
85 if (s < 0 || s >= width)
86 return false;
87 if (t < 0 || t >= height)
88 return false;
89 if (r < 0 || r >= depth)
90 return false;
91 return true;
92 }
93
94 /*
95 * Checks if the texture target compatible with the image resource
96 * pipe target.
97 */
98 static inline bool
99 has_compat_target(unsigned pipe_target, unsigned tgsi_target)
100 {
101 switch (pipe_target) {
102 case PIPE_TEXTURE_1D:
103 if (tgsi_target == TGSI_TEXTURE_1D)
104 return true;
105 break;
106 case PIPE_TEXTURE_2D:
107 if (tgsi_target == TGSI_TEXTURE_2D)
108 return true;
109 break;
110 case PIPE_TEXTURE_RECT:
111 if (tgsi_target == TGSI_TEXTURE_RECT)
112 return true;
113 break;
114 case PIPE_TEXTURE_3D:
115 if (tgsi_target == TGSI_TEXTURE_3D ||
116 tgsi_target == TGSI_TEXTURE_2D)
117 return true;
118 break;
119 case PIPE_TEXTURE_CUBE:
120 if (tgsi_target == TGSI_TEXTURE_CUBE ||
121 tgsi_target == TGSI_TEXTURE_2D)
122 return true;
123 break;
124 case PIPE_TEXTURE_1D_ARRAY:
125 if (tgsi_target == TGSI_TEXTURE_1D ||
126 tgsi_target == TGSI_TEXTURE_1D_ARRAY)
127 return true;
128 break;
129 case PIPE_TEXTURE_2D_ARRAY:
130 if (tgsi_target == TGSI_TEXTURE_2D ||
131 tgsi_target == TGSI_TEXTURE_2D_ARRAY)
132 return true;
133 break;
134 case PIPE_TEXTURE_CUBE_ARRAY:
135 if (tgsi_target == TGSI_TEXTURE_CUBE ||
136 tgsi_target == TGSI_TEXTURE_CUBE_ARRAY ||
137 tgsi_target == TGSI_TEXTURE_2D)
138 return true;
139 break;
140 case PIPE_BUFFER:
141 return (tgsi_target == TGSI_TEXTURE_BUFFER);
142 }
143 return false;
144 }
145
146 static bool
147 get_dimensions(const struct pipe_image_view *iview,
148 const struct softpipe_resource *spr,
149 unsigned tgsi_tex_instr,
150 enum pipe_format pformat,
151 unsigned *width,
152 unsigned *height,
153 unsigned *depth)
154 {
155 if (tgsi_tex_instr == TGSI_TEXTURE_BUFFER) {
156 *width = iview->u.buf.size / util_format_get_blocksize(pformat);
157 *height = 1;
158 *depth = 1;
159 /*
160 * Bounds check the buffer size from the view
161 * and the buffer size from the underlying buffer.
162 */
163 if (util_format_get_stride(pformat, *width) >
164 util_format_get_stride(spr->base.format, spr->base.width0))
165 return false;
166 } else {
167 unsigned level;
168
169 level = spr->base.target == PIPE_BUFFER ? 0 : iview->u.tex.level;
170 *width = u_minify(spr->base.width0, level);
171 *height = u_minify(spr->base.height0, level);
172
173 if (spr->base.target == PIPE_TEXTURE_3D)
174 *depth = u_minify(spr->base.depth0, level);
175 else
176 *depth = spr->base.array_size;
177
178 /* Make sure the resource and view have compatiable formats */
179 if (util_format_get_blocksize(pformat) >
180 util_format_get_blocksize(spr->base.format))
181 return false;
182 }
183 return true;
184 }
185
186 static void
187 fill_coords(const struct tgsi_image_params *params,
188 unsigned index,
189 const int s[TGSI_QUAD_SIZE],
190 const int t[TGSI_QUAD_SIZE],
191 const int r[TGSI_QUAD_SIZE],
192 int *s_coord, int *t_coord, int *r_coord)
193 {
194 *s_coord = s[index];
195 *t_coord = has_1coord(params->tgsi_tex_instr) ? 0 : t[index];
196 *r_coord = has_layer_or_depth(params->tgsi_tex_instr) ?
197 (params->tgsi_tex_instr == TGSI_TEXTURE_1D_ARRAY ? t[index] : r[index]) : 0;
198 }
199 /*
200 * Implement the image LOAD operation.
201 */
202 static void
203 sp_tgsi_load(const struct tgsi_image *image,
204 const struct tgsi_image_params *params,
205 const int s[TGSI_QUAD_SIZE],
206 const int t[TGSI_QUAD_SIZE],
207 const int r[TGSI_QUAD_SIZE],
208 const int sample[TGSI_QUAD_SIZE],
209 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
210 {
211 struct sp_tgsi_image *sp_img = (struct sp_tgsi_image *)image;
212 struct pipe_image_view *iview;
213 struct softpipe_resource *spr;
214 unsigned width, height, depth;
215 unsigned stride;
216 int c, j;
217 char *data_ptr;
218 unsigned offset = 0;
219
220 if (params->unit >= PIPE_MAX_SHADER_IMAGES)
221 goto fail_write_all_zero;
222 iview = &sp_img->sp_iview[params->unit];
223 spr = (struct softpipe_resource *)iview->resource;
224 if (!spr)
225 goto fail_write_all_zero;
226
227 if (!has_compat_target(spr->base.target, params->tgsi_tex_instr))
228 goto fail_write_all_zero;
229
230 if (!get_dimensions(iview, spr, params->tgsi_tex_instr,
231 params->format, &width, &height, &depth))
232 return;
233
234 stride = util_format_get_stride(params->format, width);
235
236 for (j = 0; j < TGSI_QUAD_SIZE; j++) {
237 int s_coord, t_coord, r_coord;
238 bool fill_zero = false;
239
240 if (!(params->execmask & (1 << j)))
241 fill_zero = true;
242
243 fill_coords(params, j, s, t, r, &s_coord, &t_coord, &r_coord);
244 if (!bounds_check(width, height, depth,
245 s_coord, t_coord, r_coord))
246 fill_zero = true;
247
248 if (fill_zero) {
249 int nc = util_format_get_nr_components(params->format);
250 int ival = util_format_is_pure_integer(params->format);
251 for (c = 0; c < 4; c++) {
252 rgba[c][j] = 0;
253 if (c == 3 && nc < 4) {
254 if (ival)
255 ((int32_t *)rgba[c])[j] = 1;
256 else
257 rgba[c][j] = 1.0;
258 }
259 }
260 continue;
261 }
262 offset = get_image_offset(spr, iview, params->format, r_coord);
263 data_ptr = (char *)spr->data + offset;
264
265 if (util_format_is_pure_sint(params->format)) {
266 int32_t sdata[4];
267
268 util_format_read_4i(params->format,
269 sdata, 0,
270 data_ptr, stride,
271 s_coord, t_coord, 1, 1);
272 for (c = 0; c < 4; c++)
273 ((int32_t *)rgba[c])[j] = sdata[c];
274 } else if (util_format_is_pure_uint(params->format)) {
275 uint32_t sdata[4];
276 util_format_read_4ui(params->format,
277 sdata, 0,
278 data_ptr, stride,
279 s_coord, t_coord, 1, 1);
280 for (c = 0; c < 4; c++)
281 ((uint32_t *)rgba[c])[j] = sdata[c];
282 } else {
283 float sdata[4];
284 util_format_read_4f(params->format,
285 sdata, 0,
286 data_ptr, stride,
287 s_coord, t_coord, 1, 1);
288 for (c = 0; c < 4; c++)
289 rgba[c][j] = sdata[c];
290 }
291 }
292 return;
293 fail_write_all_zero:
294 for (j = 0; j < TGSI_QUAD_SIZE; j++) {
295 for (c = 0; c < 4; c++)
296 rgba[c][j] = 0;
297 }
298 return;
299 }
300
301 /*
302 * Implement the image STORE operation.
303 */
304 static void
305 sp_tgsi_store(const struct tgsi_image *image,
306 const struct tgsi_image_params *params,
307 const int s[TGSI_QUAD_SIZE],
308 const int t[TGSI_QUAD_SIZE],
309 const int r[TGSI_QUAD_SIZE],
310 const int sample[TGSI_QUAD_SIZE],
311 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
312 {
313 struct sp_tgsi_image *sp_img = (struct sp_tgsi_image *)image;
314 struct pipe_image_view *iview;
315 struct softpipe_resource *spr;
316 unsigned width, height, depth;
317 unsigned stride;
318 char *data_ptr;
319 int j, c;
320 unsigned offset = 0;
321 unsigned pformat = params->format;
322
323 if (params->unit >= PIPE_MAX_SHADER_IMAGES)
324 return;
325 iview = &sp_img->sp_iview[params->unit];
326 spr = (struct softpipe_resource *)iview->resource;
327 if (!spr)
328 return;
329 if (!has_compat_target(spr->base.target, params->tgsi_tex_instr))
330 return;
331
332 if (params->format == PIPE_FORMAT_NONE)
333 pformat = spr->base.format;
334
335 if (!get_dimensions(iview, spr, params->tgsi_tex_instr,
336 pformat, &width, &height, &depth))
337 return;
338
339 stride = util_format_get_stride(pformat, width);
340
341 for (j = 0; j < TGSI_QUAD_SIZE; j++) {
342 int s_coord, t_coord, r_coord;
343
344 if (!(params->execmask & (1 << j)))
345 continue;
346
347 fill_coords(params, j, s, t, r, &s_coord, &t_coord, &r_coord);
348 if (!bounds_check(width, height, depth,
349 s_coord, t_coord, r_coord))
350 continue;
351
352 offset = get_image_offset(spr, iview, pformat, r_coord);
353 data_ptr = (char *)spr->data + offset;
354
355 if (util_format_is_pure_sint(pformat)) {
356 int32_t sdata[4];
357 for (c = 0; c < 4; c++)
358 sdata[c] = ((int32_t *)rgba[c])[j];
359 util_format_write_4i(pformat, sdata, 0, data_ptr, stride,
360 s_coord, t_coord, 1, 1);
361 } else if (util_format_is_pure_uint(pformat)) {
362 uint32_t sdata[4];
363 for (c = 0; c < 4; c++)
364 sdata[c] = ((uint32_t *)rgba[c])[j];
365 util_format_write_4ui(pformat, sdata, 0, data_ptr, stride,
366 s_coord, t_coord, 1, 1);
367 } else {
368 float sdata[4];
369 for (c = 0; c < 4; c++)
370 sdata[c] = rgba[c][j];
371 util_format_write_4f(pformat, sdata, 0, data_ptr, stride,
372 s_coord, t_coord, 1, 1);
373 }
374 }
375 }
376
377 /*
378 * Implement atomic operations on unsigned integers.
379 */
380 static void
381 handle_op_uint(const struct pipe_image_view *iview,
382 const struct tgsi_image_params *params,
383 bool just_read,
384 char *data_ptr,
385 uint qi,
386 unsigned stride,
387 enum tgsi_opcode opcode,
388 int s,
389 int t,
390 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE],
391 float rgba2[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
392 {
393 uint c;
394 int nc = util_format_get_nr_components(params->format);
395 unsigned sdata[4];
396
397 util_format_read_4ui(params->format,
398 sdata, 0,
399 data_ptr, stride,
400 s, t, 1, 1);
401
402 if (just_read) {
403 for (c = 0; c < nc; c++) {
404 ((uint32_t *)rgba[c])[qi] = sdata[c];
405 }
406 return;
407 }
408 switch (opcode) {
409 case TGSI_OPCODE_ATOMUADD:
410 for (c = 0; c < nc; c++) {
411 unsigned temp = sdata[c];
412 sdata[c] += ((uint32_t *)rgba[c])[qi];
413 ((uint32_t *)rgba[c])[qi] = temp;
414 }
415 break;
416 case TGSI_OPCODE_ATOMXCHG:
417 for (c = 0; c < nc; c++) {
418 unsigned temp = sdata[c];
419 sdata[c] = ((uint32_t *)rgba[c])[qi];
420 ((uint32_t *)rgba[c])[qi] = temp;
421 }
422 break;
423 case TGSI_OPCODE_ATOMCAS:
424 for (c = 0; c < nc; c++) {
425 unsigned dst_x = sdata[c];
426 unsigned cmp_x = ((uint32_t *)rgba[c])[qi];
427 unsigned src_x = ((uint32_t *)rgba2[c])[qi];
428 unsigned temp = sdata[c];
429 sdata[c] = (dst_x == cmp_x) ? src_x : dst_x;
430 ((uint32_t *)rgba[c])[qi] = temp;
431 }
432 break;
433 case TGSI_OPCODE_ATOMAND:
434 for (c = 0; c < nc; c++) {
435 unsigned temp = sdata[c];
436 sdata[c] &= ((uint32_t *)rgba[c])[qi];
437 ((uint32_t *)rgba[c])[qi] = temp;
438 }
439 break;
440 case TGSI_OPCODE_ATOMOR:
441 for (c = 0; c < nc; c++) {
442 unsigned temp = sdata[c];
443 sdata[c] |= ((uint32_t *)rgba[c])[qi];
444 ((uint32_t *)rgba[c])[qi] = temp;
445 }
446 break;
447 case TGSI_OPCODE_ATOMXOR:
448 for (c = 0; c < nc; c++) {
449 unsigned temp = sdata[c];
450 sdata[c] ^= ((uint32_t *)rgba[c])[qi];
451 ((uint32_t *)rgba[c])[qi] = temp;
452 }
453 break;
454 case TGSI_OPCODE_ATOMUMIN:
455 for (c = 0; c < nc; c++) {
456 unsigned dst_x = sdata[c];
457 unsigned src_x = ((uint32_t *)rgba[c])[qi];
458 sdata[c] = MIN2(dst_x, src_x);
459 ((uint32_t *)rgba[c])[qi] = dst_x;
460 }
461 break;
462 case TGSI_OPCODE_ATOMUMAX:
463 for (c = 0; c < nc; c++) {
464 unsigned dst_x = sdata[c];
465 unsigned src_x = ((uint32_t *)rgba[c])[qi];
466 sdata[c] = MAX2(dst_x, src_x);
467 ((uint32_t *)rgba[c])[qi] = dst_x;
468 }
469 break;
470 case TGSI_OPCODE_ATOMIMIN:
471 for (c = 0; c < nc; c++) {
472 int dst_x = sdata[c];
473 int src_x = ((uint32_t *)rgba[c])[qi];
474 sdata[c] = MIN2(dst_x, src_x);
475 ((uint32_t *)rgba[c])[qi] = dst_x;
476 }
477 break;
478 case TGSI_OPCODE_ATOMIMAX:
479 for (c = 0; c < nc; c++) {
480 int dst_x = sdata[c];
481 int src_x = ((uint32_t *)rgba[c])[qi];
482 sdata[c] = MAX2(dst_x, src_x);
483 ((uint32_t *)rgba[c])[qi] = dst_x;
484 }
485 break;
486 default:
487 assert(!"Unexpected TGSI opcode in sp_tgsi_op");
488 break;
489 }
490 util_format_write_4ui(params->format, sdata, 0, data_ptr, stride,
491 s, t, 1, 1);
492 }
493
494 /*
495 * Implement atomic operations on signed integers.
496 */
497 static void
498 handle_op_int(const struct pipe_image_view *iview,
499 const struct tgsi_image_params *params,
500 bool just_read,
501 char *data_ptr,
502 uint qi,
503 unsigned stride,
504 enum tgsi_opcode opcode,
505 int s,
506 int t,
507 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE],
508 float rgba2[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
509 {
510 uint c;
511 int nc = util_format_get_nr_components(params->format);
512 int sdata[4];
513 util_format_read_4i(params->format,
514 sdata, 0,
515 data_ptr, stride,
516 s, t, 1, 1);
517
518 if (just_read) {
519 for (c = 0; c < nc; c++) {
520 ((int32_t *)rgba[c])[qi] = sdata[c];
521 }
522 return;
523 }
524 switch (opcode) {
525 case TGSI_OPCODE_ATOMUADD:
526 for (c = 0; c < nc; c++) {
527 int temp = sdata[c];
528 sdata[c] += ((int32_t *)rgba[c])[qi];
529 ((int32_t *)rgba[c])[qi] = temp;
530 }
531 break;
532 case TGSI_OPCODE_ATOMXCHG:
533 for (c = 0; c < nc; c++) {
534 int temp = sdata[c];
535 sdata[c] = ((int32_t *)rgba[c])[qi];
536 ((int32_t *)rgba[c])[qi] = temp;
537 }
538 break;
539 case TGSI_OPCODE_ATOMCAS:
540 for (c = 0; c < nc; c++) {
541 int dst_x = sdata[c];
542 int cmp_x = ((int32_t *)rgba[c])[qi];
543 int src_x = ((int32_t *)rgba2[c])[qi];
544 int temp = sdata[c];
545 sdata[c] = (dst_x == cmp_x) ? src_x : dst_x;
546 ((int32_t *)rgba[c])[qi] = temp;
547 }
548 break;
549 case TGSI_OPCODE_ATOMAND:
550 for (c = 0; c < nc; c++) {
551 int temp = sdata[c];
552 sdata[c] &= ((int32_t *)rgba[c])[qi];
553 ((int32_t *)rgba[c])[qi] = temp;
554 }
555 break;
556 case TGSI_OPCODE_ATOMOR:
557 for (c = 0; c < nc; c++) {
558 int temp = sdata[c];
559 sdata[c] |= ((int32_t *)rgba[c])[qi];
560 ((int32_t *)rgba[c])[qi] = temp;
561 }
562 break;
563 case TGSI_OPCODE_ATOMXOR:
564 for (c = 0; c < nc; c++) {
565 int temp = sdata[c];
566 sdata[c] ^= ((int32_t *)rgba[c])[qi];
567 ((int32_t *)rgba[c])[qi] = temp;
568 }
569 break;
570 case TGSI_OPCODE_ATOMUMIN:
571 for (c = 0; c < nc; c++) {
572 int dst_x = sdata[c];
573 int src_x = ((int32_t *)rgba[c])[qi];
574 sdata[c] = MIN2(dst_x, src_x);
575 ((int32_t *)rgba[c])[qi] = dst_x;
576 }
577 break;
578 case TGSI_OPCODE_ATOMUMAX:
579 for (c = 0; c < nc; c++) {
580 int dst_x = sdata[c];
581 int src_x = ((int32_t *)rgba[c])[qi];
582 sdata[c] = MAX2(dst_x, src_x);
583 ((int32_t *)rgba[c])[qi] = dst_x;
584 }
585 break;
586 case TGSI_OPCODE_ATOMIMIN:
587 for (c = 0; c < nc; c++) {
588 int dst_x = sdata[c];
589 int src_x = ((int32_t *)rgba[c])[qi];
590 sdata[c] = MIN2(dst_x, src_x);
591 ((int32_t *)rgba[c])[qi] = dst_x;
592 }
593 break;
594 case TGSI_OPCODE_ATOMIMAX:
595 for (c = 0; c < nc; c++) {
596 int dst_x = sdata[c];
597 int src_x = ((int32_t *)rgba[c])[qi];
598 sdata[c] = MAX2(dst_x, src_x);
599 ((int32_t *)rgba[c])[qi] = dst_x;
600 }
601 break;
602 default:
603 assert(!"Unexpected TGSI opcode in sp_tgsi_op");
604 break;
605 }
606 util_format_write_4i(params->format, sdata, 0, data_ptr, stride,
607 s, t, 1, 1);
608 }
609
610 /* GLES OES_shader_image_atomic.txt allows XCHG on R32F */
611 static void
612 handle_op_r32f_xchg(const struct pipe_image_view *iview,
613 const struct tgsi_image_params *params,
614 bool just_read,
615 char *data_ptr,
616 uint qi,
617 unsigned stride,
618 enum tgsi_opcode opcode,
619 int s,
620 int t,
621 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
622 {
623 float sdata[4];
624 uint c;
625 int nc = 1;
626 util_format_read_4f(params->format,
627 sdata, 0,
628 data_ptr, stride,
629 s, t, 1, 1);
630 if (just_read) {
631 for (c = 0; c < nc; c++) {
632 ((int32_t *)rgba[c])[qi] = sdata[c];
633 }
634 return;
635 }
636
637 for (c = 0; c < nc; c++) {
638 int temp = sdata[c];
639 sdata[c] = ((float *)rgba[c])[qi];
640 ((float *)rgba[c])[qi] = temp;
641 }
642 util_format_write_4f(params->format, sdata, 0, data_ptr, stride,
643 s, t, 1, 1);
644 }
645
646 /*
647 * Implement atomic image operations.
648 */
649 static void
650 sp_tgsi_op(const struct tgsi_image *image,
651 const struct tgsi_image_params *params,
652 enum tgsi_opcode opcode,
653 const int s[TGSI_QUAD_SIZE],
654 const int t[TGSI_QUAD_SIZE],
655 const int r[TGSI_QUAD_SIZE],
656 const int sample[TGSI_QUAD_SIZE],
657 float rgba[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE],
658 float rgba2[TGSI_NUM_CHANNELS][TGSI_QUAD_SIZE])
659 {
660 struct sp_tgsi_image *sp_img = (struct sp_tgsi_image *)image;
661 struct pipe_image_view *iview;
662 struct softpipe_resource *spr;
663 unsigned width, height, depth;
664 unsigned stride;
665 int j, c;
666 unsigned offset;
667 char *data_ptr;
668
669 if (params->unit >= PIPE_MAX_SHADER_IMAGES)
670 return;
671 iview = &sp_img->sp_iview[params->unit];
672 spr = (struct softpipe_resource *)iview->resource;
673 if (!spr)
674 goto fail_write_all_zero;
675 if (!has_compat_target(spr->base.target, params->tgsi_tex_instr))
676 goto fail_write_all_zero;
677
678 if (!get_dimensions(iview, spr, params->tgsi_tex_instr,
679 params->format, &width, &height, &depth))
680 goto fail_write_all_zero;
681
682 stride = util_format_get_stride(spr->base.format, width);
683
684 for (j = 0; j < TGSI_QUAD_SIZE; j++) {
685 int s_coord, t_coord, r_coord;
686 bool just_read = false;
687
688 fill_coords(params, j, s, t, r, &s_coord, &t_coord, &r_coord);
689 if (!bounds_check(width, height, depth,
690 s_coord, t_coord, r_coord)) {
691 int nc = util_format_get_nr_components(params->format);
692 int ival = util_format_is_pure_integer(params->format);
693 int c;
694 for (c = 0; c < 4; c++) {
695 rgba[c][j] = 0;
696 if (c == 3 && nc < 4) {
697 if (ival)
698 ((int32_t *)rgba[c])[j] = 1;
699 else
700 rgba[c][j] = 1.0;
701 }
702 }
703 continue;
704 }
705
706 /* just readback the value for atomic if execmask isn't set */
707 if (!(params->execmask & (1 << j))) {
708 just_read = true;
709 }
710
711 offset = get_image_offset(spr, iview, params->format, r_coord);
712 data_ptr = (char *)spr->data + offset;
713
714 /* we should see atomic operations on r32 formats */
715 if (util_format_is_pure_uint(params->format))
716 handle_op_uint(iview, params, just_read, data_ptr, j, stride,
717 opcode, s_coord, t_coord, rgba, rgba2);
718 else if (util_format_is_pure_sint(params->format))
719 handle_op_int(iview, params, just_read, data_ptr, j, stride,
720 opcode, s_coord, t_coord, rgba, rgba2);
721 else if (params->format == PIPE_FORMAT_R32_FLOAT &&
722 opcode == TGSI_OPCODE_ATOMXCHG)
723 handle_op_r32f_xchg(iview, params, just_read, data_ptr, j, stride,
724 opcode, s_coord, t_coord, rgba);
725 else
726 assert(0);
727 }
728 return;
729 fail_write_all_zero:
730 for (j = 0; j < TGSI_QUAD_SIZE; j++) {
731 for (c = 0; c < 4; c++)
732 rgba[c][j] = 0;
733 }
734 return;
735 }
736
737 static void
738 sp_tgsi_get_dims(const struct tgsi_image *image,
739 const struct tgsi_image_params *params,
740 int dims[4])
741 {
742 struct sp_tgsi_image *sp_img = (struct sp_tgsi_image *)image;
743 struct pipe_image_view *iview;
744 struct softpipe_resource *spr;
745 int level;
746
747 if (params->unit >= PIPE_MAX_SHADER_IMAGES)
748 return;
749 iview = &sp_img->sp_iview[params->unit];
750 spr = (struct softpipe_resource *)iview->resource;
751 if (!spr)
752 return;
753
754 if (params->tgsi_tex_instr == TGSI_TEXTURE_BUFFER) {
755 dims[0] = iview->u.buf.size / util_format_get_blocksize(iview->format);
756 dims[1] = dims[2] = dims[3] = 0;
757 return;
758 }
759
760 level = iview->u.tex.level;
761 dims[0] = u_minify(spr->base.width0, level);
762 switch (params->tgsi_tex_instr) {
763 case TGSI_TEXTURE_1D_ARRAY:
764 dims[1] = iview->u.tex.last_layer - iview->u.tex.first_layer + 1;
765 /* fallthrough */
766 case TGSI_TEXTURE_1D:
767 return;
768 case TGSI_TEXTURE_2D_ARRAY:
769 dims[2] = iview->u.tex.last_layer - iview->u.tex.first_layer + 1;
770 /* fallthrough */
771 case TGSI_TEXTURE_2D:
772 case TGSI_TEXTURE_CUBE:
773 case TGSI_TEXTURE_RECT:
774 dims[1] = u_minify(spr->base.height0, level);
775 return;
776 case TGSI_TEXTURE_3D:
777 dims[1] = u_minify(spr->base.height0, level);
778 dims[2] = u_minify(spr->base.depth0, level);
779 return;
780 case TGSI_TEXTURE_CUBE_ARRAY:
781 dims[1] = u_minify(spr->base.height0, level);
782 dims[2] = (iview->u.tex.last_layer - iview->u.tex.first_layer + 1) / 6;
783 break;
784 default:
785 assert(!"unexpected texture target in sp_get_dims()");
786 return;
787 }
788 }
789
790 struct sp_tgsi_image *
791 sp_create_tgsi_image(void)
792 {
793 struct sp_tgsi_image *img = CALLOC_STRUCT(sp_tgsi_image);
794 if (!img)
795 return NULL;
796
797 img->base.load = sp_tgsi_load;
798 img->base.store = sp_tgsi_store;
799 img->base.op = sp_tgsi_op;
800 img->base.get_dims = sp_tgsi_get_dims;
801 return img;
802 };