1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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 VMWARE 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.
26 **************************************************************************/
30 * Texture sampling -- common code.
32 * @author Jose Fonseca <jfonseca@vmware.com>
35 #include "pipe/p_defines.h"
36 #include "pipe/p_state.h"
37 #include "util/u_format.h"
38 #include "util/u_math.h"
39 #include "lp_bld_arit.h"
40 #include "lp_bld_const.h"
41 #include "lp_bld_debug.h"
42 #include "lp_bld_flow.h"
43 #include "lp_bld_sample.h"
44 #include "lp_bld_swizzle.h"
45 #include "lp_bld_type.h"
49 * Initialize lp_sampler_static_state object with the gallium sampler
51 * The former is considered to be static and the later dynamic.
54 lp_sampler_static_state(struct lp_sampler_static_state
*state
,
55 const struct pipe_sampler_view
*view
,
56 const struct pipe_sampler_state
*sampler
)
58 const struct pipe_resource
*texture
= view
->texture
;
60 memset(state
, 0, sizeof *state
);
69 * We don't copy sampler state over unless it is actually enabled, to avoid
70 * spurious recompiles, as the sampler static state is part of the shader
73 * Ideally the state tracker or cso_cache module would make all state
74 * canonical, but until that happens it's better to be safe than sorry here.
76 * XXX: Actually there's much more than can be done here, especially
77 * regarding 1D/2D/3D/CUBE textures, wrap modes, etc.
80 state
->format
= view
->format
;
81 state
->swizzle_r
= view
->swizzle_r
;
82 state
->swizzle_g
= view
->swizzle_g
;
83 state
->swizzle_b
= view
->swizzle_b
;
84 state
->swizzle_a
= view
->swizzle_a
;
86 state
->target
= texture
->target
;
87 state
->pot_width
= util_is_power_of_two(texture
->width0
);
88 state
->pot_height
= util_is_power_of_two(texture
->height0
);
89 state
->pot_depth
= util_is_power_of_two(texture
->depth0
);
91 state
->wrap_s
= sampler
->wrap_s
;
92 state
->wrap_t
= sampler
->wrap_t
;
93 state
->wrap_r
= sampler
->wrap_r
;
94 state
->min_img_filter
= sampler
->min_img_filter
;
95 state
->mag_img_filter
= sampler
->mag_img_filter
;
96 if (view
->last_level
) {
97 state
->min_mip_filter
= sampler
->min_mip_filter
;
99 state
->min_mip_filter
= PIPE_TEX_MIPFILTER_NONE
;
102 state
->compare_mode
= sampler
->compare_mode
;
103 if (sampler
->compare_mode
!= PIPE_TEX_COMPARE_NONE
) {
104 state
->compare_func
= sampler
->compare_func
;
107 state
->normalized_coords
= sampler
->normalized_coords
;
108 state
->lod_bias
= sampler
->lod_bias
;
109 if (!view
->last_level
&&
110 sampler
->min_img_filter
== sampler
->mag_img_filter
) {
111 state
->min_lod
= 0.0f
;
112 state
->max_lod
= 0.0f
;
114 state
->min_lod
= MAX2(sampler
->min_lod
, 0.0f
);
115 state
->max_lod
= sampler
->max_lod
;
117 state
->border_color
[0] = sampler
->border_color
[0];
118 state
->border_color
[1] = sampler
->border_color
[1];
119 state
->border_color
[2] = sampler
->border_color
[2];
120 state
->border_color
[3] = sampler
->border_color
[3];
123 * FIXME: Handle the remainder of pipe_sampler_view.
129 * Generate code to compute texture level of detail (lambda).
130 * \param ddx partial derivatives of (s, t, r, q) with respect to X
131 * \param ddy partial derivatives of (s, t, r, q) with respect to Y
132 * \param lod_bias optional float vector with the shader lod bias
133 * \param explicit_lod optional float vector with the explicit lod
134 * \param width scalar int texture width
135 * \param height scalar int texture height
136 * \param depth scalar int texture depth
138 * XXX: The resulting lod is scalar, so ignore all but the first element of
139 * derivatives, lod_bias, etc that are passed by the shader.
142 lp_build_lod_selector(struct lp_build_sample_context
*bld
,
143 const LLVMValueRef ddx
[4],
144 const LLVMValueRef ddy
[4],
145 LLVMValueRef lod_bias
, /* optional */
146 LLVMValueRef explicit_lod
, /* optional */
152 if (bld
->static_state
->min_lod
== bld
->static_state
->max_lod
) {
153 /* User is forcing sampling from a particular mipmap level.
154 * This is hit during mipmap generation.
156 return LLVMConstReal(LLVMFloatType(), bld
->static_state
->min_lod
);
159 struct lp_build_context
*float_bld
= &bld
->float_bld
;
160 LLVMValueRef sampler_lod_bias
= LLVMConstReal(LLVMFloatType(),
161 bld
->static_state
->lod_bias
);
162 LLVMValueRef min_lod
= LLVMConstReal(LLVMFloatType(),
163 bld
->static_state
->min_lod
);
164 LLVMValueRef max_lod
= LLVMConstReal(LLVMFloatType(),
165 bld
->static_state
->max_lod
);
166 LLVMValueRef index0
= LLVMConstInt(LLVMInt32Type(), 0, 0);
170 lod
= LLVMBuildExtractElement(bld
->builder
, explicit_lod
,
174 const int dims
= texture_dims(bld
->static_state
->target
);
175 LLVMValueRef dsdx
, dsdy
;
176 LLVMValueRef dtdx
= NULL
, dtdy
= NULL
, drdx
= NULL
, drdy
= NULL
;
179 dsdx
= LLVMBuildExtractElement(bld
->builder
, ddx
[0], index0
, "dsdx");
180 dsdx
= lp_build_abs(float_bld
, dsdx
);
181 dsdy
= LLVMBuildExtractElement(bld
->builder
, ddy
[0], index0
, "dsdy");
182 dsdy
= lp_build_abs(float_bld
, dsdy
);
184 dtdx
= LLVMBuildExtractElement(bld
->builder
, ddx
[1], index0
, "dtdx");
185 dtdx
= lp_build_abs(float_bld
, dtdx
);
186 dtdy
= LLVMBuildExtractElement(bld
->builder
, ddy
[1], index0
, "dtdy");
187 dtdy
= lp_build_abs(float_bld
, dtdy
);
189 drdx
= LLVMBuildExtractElement(bld
->builder
, ddx
[2], index0
, "drdx");
190 drdx
= lp_build_abs(float_bld
, drdx
);
191 drdy
= LLVMBuildExtractElement(bld
->builder
, ddy
[2], index0
, "drdy");
192 drdy
= lp_build_abs(float_bld
, drdy
);
196 /* Compute rho = max of all partial derivatives scaled by texture size.
197 * XXX this could be vectorized somewhat
199 rho
= LLVMBuildFMul(bld
->builder
,
200 lp_build_max(float_bld
, dsdx
, dsdy
),
201 lp_build_int_to_float(float_bld
, width
), "");
204 max
= LLVMBuildFMul(bld
->builder
,
205 lp_build_max(float_bld
, dtdx
, dtdy
),
206 lp_build_int_to_float(float_bld
, height
), "");
207 rho
= lp_build_max(float_bld
, rho
, max
);
209 max
= LLVMBuildFMul(bld
->builder
,
210 lp_build_max(float_bld
, drdx
, drdy
),
211 lp_build_int_to_float(float_bld
, depth
), "");
212 rho
= lp_build_max(float_bld
, rho
, max
);
216 /* compute lod = log2(rho) */
217 lod
= lp_build_log2(float_bld
, rho
);
219 /* add shader lod bias */
221 lod_bias
= LLVMBuildExtractElement(bld
->builder
, lod_bias
,
223 lod
= LLVMBuildFAdd(bld
->builder
, lod
, lod_bias
, "shader_lod_bias");
227 /* add sampler lod bias */
228 lod
= LLVMBuildFAdd(bld
->builder
, lod
, sampler_lod_bias
, "sampler_lod_bias");
231 lod
= lp_build_clamp(float_bld
, lod
, min_lod
, max_lod
);
239 * For PIPE_TEX_MIPFILTER_NEAREST, convert float LOD to integer
240 * mipmap level index.
241 * Note: this is all scalar code.
242 * \param lod scalar float texture level of detail
243 * \param level_out returns integer
246 lp_build_nearest_mip_level(struct lp_build_sample_context
*bld
,
249 LLVMValueRef
*level_out
)
251 struct lp_build_context
*float_bld
= &bld
->float_bld
;
252 struct lp_build_context
*int_bld
= &bld
->int_bld
;
253 LLVMValueRef last_level
, level
;
255 LLVMValueRef zero
= LLVMConstInt(LLVMInt32Type(), 0, 0);
257 last_level
= bld
->dynamic_state
->last_level(bld
->dynamic_state
,
260 /* convert float lod to integer */
261 level
= lp_build_iround(float_bld
, lod
);
263 /* clamp level to legal range of levels */
264 *level_out
= lp_build_clamp(int_bld
, level
, zero
, last_level
);
269 * For PIPE_TEX_MIPFILTER_LINEAR, convert float LOD to integer to
270 * two (adjacent) mipmap level indexes. Later, we'll sample from those
271 * two mipmap levels and interpolate between them.
274 lp_build_linear_mip_levels(struct lp_build_sample_context
*bld
,
277 LLVMValueRef
*level0_out
,
278 LLVMValueRef
*level1_out
,
279 LLVMValueRef
*weight_out
)
281 struct lp_build_context
*float_bld
= &bld
->float_bld
;
282 struct lp_build_context
*int_bld
= &bld
->int_bld
;
283 LLVMValueRef last_level
, level
;
285 last_level
= bld
->dynamic_state
->last_level(bld
->dynamic_state
,
288 /* convert float lod to integer */
289 level
= lp_build_ifloor(float_bld
, lod
);
291 /* compute level 0 and clamp to legal range of levels */
292 *level0_out
= lp_build_clamp(int_bld
, level
,
295 /* compute level 1 and clamp to legal range of levels */
296 level
= lp_build_add(int_bld
, level
, int_bld
->one
);
297 *level1_out
= lp_build_clamp(int_bld
, level
,
301 *weight_out
= lp_build_fract(float_bld
, lod
);
306 lp_build_get_mipmap_level(struct lp_build_sample_context
*bld
,
307 LLVMValueRef data_array
, LLVMValueRef level
)
309 LLVMValueRef indexes
[2], data_ptr
;
310 indexes
[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
312 data_ptr
= LLVMBuildGEP(bld
->builder
, data_array
, indexes
, 2, "");
313 data_ptr
= LLVMBuildLoad(bld
->builder
, data_ptr
, "");
319 lp_build_get_const_mipmap_level(struct lp_build_sample_context
*bld
,
320 LLVMValueRef data_array
, int level
)
322 LLVMValueRef lvl
= LLVMConstInt(LLVMInt32Type(), level
, 0);
323 return lp_build_get_mipmap_level(bld
, data_array
, lvl
);
328 * Codegen equivalent for u_minify().
329 * Return max(1, base_size >> level);
332 lp_build_minify(struct lp_build_sample_context
*bld
,
333 LLVMValueRef base_size
,
336 LLVMValueRef size
= LLVMBuildLShr(bld
->builder
, base_size
, level
, "minify");
337 size
= lp_build_max(&bld
->int_coord_bld
, size
, bld
->int_coord_bld
.one
);
343 * Dereference stride_array[mipmap_level] array to get a stride.
344 * Return stride as a vector.
347 lp_build_get_level_stride_vec(struct lp_build_sample_context
*bld
,
348 LLVMValueRef stride_array
, LLVMValueRef level
)
350 LLVMValueRef indexes
[2], stride
;
351 indexes
[0] = LLVMConstInt(LLVMInt32Type(), 0, 0);
353 stride
= LLVMBuildGEP(bld
->builder
, stride_array
, indexes
, 2, "");
354 stride
= LLVMBuildLoad(bld
->builder
, stride
, "");
355 stride
= lp_build_broadcast_scalar(&bld
->int_coord_bld
, stride
);
361 * When sampling a mipmap, we need to compute the width, height, depth
362 * of the source levels from the level indexes. This helper function
366 lp_build_mipmap_level_sizes(struct lp_build_sample_context
*bld
,
368 LLVMValueRef width_vec
,
369 LLVMValueRef height_vec
,
370 LLVMValueRef depth_vec
,
371 LLVMValueRef ilevel0
,
372 LLVMValueRef ilevel1
,
373 LLVMValueRef row_stride_array
,
374 LLVMValueRef img_stride_array
,
375 LLVMValueRef
*width0_vec
,
376 LLVMValueRef
*width1_vec
,
377 LLVMValueRef
*height0_vec
,
378 LLVMValueRef
*height1_vec
,
379 LLVMValueRef
*depth0_vec
,
380 LLVMValueRef
*depth1_vec
,
381 LLVMValueRef
*row_stride0_vec
,
382 LLVMValueRef
*row_stride1_vec
,
383 LLVMValueRef
*img_stride0_vec
,
384 LLVMValueRef
*img_stride1_vec
)
386 const unsigned mip_filter
= bld
->static_state
->min_mip_filter
;
387 LLVMValueRef ilevel0_vec
, ilevel1_vec
;
389 ilevel0_vec
= lp_build_broadcast_scalar(&bld
->int_coord_bld
, ilevel0
);
390 if (mip_filter
== PIPE_TEX_MIPFILTER_LINEAR
)
391 ilevel1_vec
= lp_build_broadcast_scalar(&bld
->int_coord_bld
, ilevel1
);
394 * Compute width, height, depth at mipmap level 'ilevel0'
396 *width0_vec
= lp_build_minify(bld
, width_vec
, ilevel0_vec
);
398 *height0_vec
= lp_build_minify(bld
, height_vec
, ilevel0_vec
);
399 *row_stride0_vec
= lp_build_get_level_stride_vec(bld
,
402 if (dims
== 3 || bld
->static_state
->target
== PIPE_TEXTURE_CUBE
) {
403 *img_stride0_vec
= lp_build_get_level_stride_vec(bld
,
407 *depth0_vec
= lp_build_minify(bld
, depth_vec
, ilevel0_vec
);
411 if (mip_filter
== PIPE_TEX_MIPFILTER_LINEAR
) {
412 /* compute width, height, depth for second mipmap level at 'ilevel1' */
413 *width1_vec
= lp_build_minify(bld
, width_vec
, ilevel1_vec
);
415 *height1_vec
= lp_build_minify(bld
, height_vec
, ilevel1_vec
);
416 *row_stride1_vec
= lp_build_get_level_stride_vec(bld
,
419 if (dims
== 3 || bld
->static_state
->target
== PIPE_TEXTURE_CUBE
) {
420 *img_stride1_vec
= lp_build_get_level_stride_vec(bld
,
424 *depth1_vec
= lp_build_minify(bld
, depth_vec
, ilevel1_vec
);
433 /** Helper used by lp_build_cube_lookup() */
435 lp_build_cube_ima(struct lp_build_context
*coord_bld
, LLVMValueRef coord
)
437 /* ima = -0.5 / abs(coord); */
438 LLVMValueRef negHalf
= lp_build_const_vec(coord_bld
->type
, -0.5);
439 LLVMValueRef absCoord
= lp_build_abs(coord_bld
, coord
);
440 LLVMValueRef ima
= lp_build_div(coord_bld
, negHalf
, absCoord
);
446 * Helper used by lp_build_cube_lookup()
447 * \param sign scalar +1 or -1
448 * \param coord float vector
449 * \param ima float vector
452 lp_build_cube_coord(struct lp_build_context
*coord_bld
,
453 LLVMValueRef sign
, int negate_coord
,
454 LLVMValueRef coord
, LLVMValueRef ima
)
456 /* return negate(coord) * ima * sign + 0.5; */
457 LLVMValueRef half
= lp_build_const_vec(coord_bld
->type
, 0.5);
460 assert(negate_coord
== +1 || negate_coord
== -1);
462 if (negate_coord
== -1) {
463 coord
= lp_build_negate(coord_bld
, coord
);
466 res
= lp_build_mul(coord_bld
, coord
, ima
);
468 sign
= lp_build_broadcast_scalar(coord_bld
, sign
);
469 res
= lp_build_mul(coord_bld
, res
, sign
);
471 res
= lp_build_add(coord_bld
, res
, half
);
477 /** Helper used by lp_build_cube_lookup()
478 * Return (major_coord >= 0) ? pos_face : neg_face;
481 lp_build_cube_face(struct lp_build_sample_context
*bld
,
482 LLVMValueRef major_coord
,
483 unsigned pos_face
, unsigned neg_face
)
485 LLVMValueRef cmp
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
,
487 bld
->float_bld
.zero
, "");
488 LLVMValueRef pos
= LLVMConstInt(LLVMInt32Type(), pos_face
, 0);
489 LLVMValueRef neg
= LLVMConstInt(LLVMInt32Type(), neg_face
, 0);
490 LLVMValueRef res
= LLVMBuildSelect(bld
->builder
, cmp
, pos
, neg
, "");
497 * Generate code to do cube face selection and compute per-face texcoords.
500 lp_build_cube_lookup(struct lp_build_sample_context
*bld
,
505 LLVMValueRef
*face_s
,
506 LLVMValueRef
*face_t
)
508 struct lp_build_context
*float_bld
= &bld
->float_bld
;
509 struct lp_build_context
*coord_bld
= &bld
->coord_bld
;
510 LLVMValueRef rx
, ry
, rz
;
511 LLVMValueRef arx
, ary
, arz
;
512 LLVMValueRef c25
= LLVMConstReal(LLVMFloatType(), 0.25);
513 LLVMValueRef arx_ge_ary
, arx_ge_arz
;
514 LLVMValueRef ary_ge_arx
, ary_ge_arz
;
515 LLVMValueRef arx_ge_ary_arz
, ary_ge_arx_arz
;
516 LLVMValueRef rx_pos
, ry_pos
, rz_pos
;
518 assert(bld
->coord_bld
.type
.length
== 4);
521 * Use the average of the four pixel's texcoords to choose the face.
523 rx
= lp_build_mul(float_bld
, c25
,
524 lp_build_sum_vector(&bld
->coord_bld
, s
));
525 ry
= lp_build_mul(float_bld
, c25
,
526 lp_build_sum_vector(&bld
->coord_bld
, t
));
527 rz
= lp_build_mul(float_bld
, c25
,
528 lp_build_sum_vector(&bld
->coord_bld
, r
));
530 arx
= lp_build_abs(float_bld
, rx
);
531 ary
= lp_build_abs(float_bld
, ry
);
532 arz
= lp_build_abs(float_bld
, rz
);
535 * Compare sign/magnitude of rx,ry,rz to determine face
537 arx_ge_ary
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, arx
, ary
, "");
538 arx_ge_arz
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, arx
, arz
, "");
539 ary_ge_arx
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, ary
, arx
, "");
540 ary_ge_arz
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, ary
, arz
, "");
542 arx_ge_ary_arz
= LLVMBuildAnd(bld
->builder
, arx_ge_ary
, arx_ge_arz
, "");
543 ary_ge_arx_arz
= LLVMBuildAnd(bld
->builder
, ary_ge_arx
, ary_ge_arz
, "");
545 rx_pos
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, rx
, float_bld
->zero
, "");
546 ry_pos
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, ry
, float_bld
->zero
, "");
547 rz_pos
= LLVMBuildFCmp(bld
->builder
, LLVMRealUGE
, rz
, float_bld
->zero
, "");
550 struct lp_build_flow_context
*flow_ctx
;
551 struct lp_build_if_state if_ctx
;
553 flow_ctx
= lp_build_flow_create(bld
->builder
);
554 lp_build_flow_scope_begin(flow_ctx
);
556 *face_s
= bld
->coord_bld
.undef
;
557 *face_t
= bld
->coord_bld
.undef
;
558 *face
= bld
->int_bld
.undef
;
560 lp_build_name(*face_s
, "face_s");
561 lp_build_name(*face_t
, "face_t");
562 lp_build_name(*face
, "face");
564 lp_build_flow_scope_declare(flow_ctx
, face_s
);
565 lp_build_flow_scope_declare(flow_ctx
, face_t
);
566 lp_build_flow_scope_declare(flow_ctx
, face
);
568 lp_build_if(&if_ctx
, flow_ctx
, bld
->builder
, arx_ge_ary_arz
);
571 LLVMValueRef sign
= lp_build_sgn(float_bld
, rx
);
572 LLVMValueRef ima
= lp_build_cube_ima(coord_bld
, s
);
573 *face_s
= lp_build_cube_coord(coord_bld
, sign
, +1, r
, ima
);
574 *face_t
= lp_build_cube_coord(coord_bld
, NULL
, +1, t
, ima
);
575 *face
= lp_build_cube_face(bld
, rx
,
577 PIPE_TEX_FACE_NEG_X
);
579 lp_build_else(&if_ctx
);
581 struct lp_build_flow_context
*flow_ctx2
;
582 struct lp_build_if_state if_ctx2
;
584 LLVMValueRef face_s2
= bld
->coord_bld
.undef
;
585 LLVMValueRef face_t2
= bld
->coord_bld
.undef
;
586 LLVMValueRef face2
= bld
->int_bld
.undef
;
588 flow_ctx2
= lp_build_flow_create(bld
->builder
);
589 lp_build_flow_scope_begin(flow_ctx2
);
590 lp_build_flow_scope_declare(flow_ctx2
, &face_s2
);
591 lp_build_flow_scope_declare(flow_ctx2
, &face_t2
);
592 lp_build_flow_scope_declare(flow_ctx2
, &face2
);
594 ary_ge_arx_arz
= LLVMBuildAnd(bld
->builder
, ary_ge_arx
, ary_ge_arz
, "");
596 lp_build_if(&if_ctx2
, flow_ctx2
, bld
->builder
, ary_ge_arx_arz
);
599 LLVMValueRef sign
= lp_build_sgn(float_bld
, ry
);
600 LLVMValueRef ima
= lp_build_cube_ima(coord_bld
, t
);
601 face_s2
= lp_build_cube_coord(coord_bld
, NULL
, -1, s
, ima
);
602 face_t2
= lp_build_cube_coord(coord_bld
, sign
, -1, r
, ima
);
603 face2
= lp_build_cube_face(bld
, ry
,
605 PIPE_TEX_FACE_NEG_Y
);
607 lp_build_else(&if_ctx2
);
610 LLVMValueRef sign
= lp_build_sgn(float_bld
, rz
);
611 LLVMValueRef ima
= lp_build_cube_ima(coord_bld
, r
);
612 face_s2
= lp_build_cube_coord(coord_bld
, sign
, -1, s
, ima
);
613 face_t2
= lp_build_cube_coord(coord_bld
, NULL
, +1, t
, ima
);
614 face2
= lp_build_cube_face(bld
, rz
,
616 PIPE_TEX_FACE_NEG_Z
);
618 lp_build_endif(&if_ctx2
);
619 lp_build_flow_scope_end(flow_ctx2
);
620 lp_build_flow_destroy(flow_ctx2
);
626 lp_build_endif(&if_ctx
);
627 lp_build_flow_scope_end(flow_ctx
);
628 lp_build_flow_destroy(flow_ctx
);
634 * Compute the partial offset of a pixel block along an arbitrary axis.
636 * @param coord coordinate in pixels
637 * @param stride number of bytes between rows of successive pixel blocks
638 * @param block_length number of pixels in a pixels block along the coordinate
640 * @param out_offset resulting relative offset of the pixel block in bytes
641 * @param out_subcoord resulting sub-block pixel coordinate
644 lp_build_sample_partial_offset(struct lp_build_context
*bld
,
645 unsigned block_length
,
648 LLVMValueRef
*out_offset
,
649 LLVMValueRef
*out_subcoord
)
652 LLVMValueRef subcoord
;
654 if (block_length
== 1) {
655 subcoord
= bld
->zero
;
659 * Pixel blocks have power of two dimensions. LLVM should convert the
660 * rem/div to bit arithmetic.
664 LLVMValueRef block_width
= lp_build_const_int_vec(bld
->type
, block_length
);
665 subcoord
= LLVMBuildURem(bld
->builder
, coord
, block_width
, "");
666 coord
= LLVMBuildUDiv(bld
->builder
, coord
, block_width
, "");
669 offset
= lp_build_mul(bld
, coord
, stride
);
672 assert(out_subcoord
);
674 *out_offset
= offset
;
675 *out_subcoord
= subcoord
;
680 * Compute the offset of a pixel block.
682 * x, y, z, y_stride, z_stride are vectors, and they refer to pixels.
684 * Returns the relative offset and i,j sub-block coordinates
687 lp_build_sample_offset(struct lp_build_context
*bld
,
688 const struct util_format_description
*format_desc
,
692 LLVMValueRef y_stride
,
693 LLVMValueRef z_stride
,
694 LLVMValueRef
*out_offset
,
698 LLVMValueRef x_stride
;
701 x_stride
= lp_build_const_vec(bld
->type
, format_desc
->block
.bits
/8);
703 lp_build_sample_partial_offset(bld
,
704 format_desc
->block
.width
,
709 LLVMValueRef y_offset
;
710 lp_build_sample_partial_offset(bld
,
711 format_desc
->block
.height
,
714 offset
= lp_build_add(bld
, offset
, y_offset
);
721 LLVMValueRef z_offset
;
723 lp_build_sample_partial_offset(bld
,
724 1, /* pixel blocks are always 2D */
727 offset
= lp_build_add(bld
, offset
, z_offset
);
730 *out_offset
= offset
;