#include "util/u_dump.h"
#include "util/u_memory.h"
#include "util/u_math.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
#include "util/u_cpu_detect.h"
#include "lp_bld_debug.h"
#include "lp_bld_type.h"
/**
- * Build LLVM code for texture coord wrapping, for nearest filtering,
- * for float texcoords.
- * \param coord the incoming texcoord (s,t or r)
- * \param length the texture size along one dimension
- * \param offset the texel offset along the coord axis
- * \param is_pot if TRUE, length is a power of two
- * \param wrap_mode one of PIPE_TEX_WRAP_x
- * \param icoord the texcoord after wrapping, as int
+ * Helper to compute the first coord and the weight for
+ * linear wrap repeat npot textures
*/
static void
-lp_build_sample_wrap_nearest_float(struct lp_build_sample_context *bld,
- LLVMValueRef coord,
- LLVMValueRef length,
- LLVMValueRef offset,
- boolean is_pot,
- unsigned wrap_mode,
- LLVMValueRef *icoord)
+lp_build_coord_repeat_npot_linear_int(struct lp_build_sample_context *bld,
+ LLVMValueRef coord_f,
+ LLVMValueRef length_i,
+ LLVMValueRef length_f,
+ LLVMValueRef *coord0_i,
+ LLVMValueRef *weight_i)
{
struct lp_build_context *coord_bld = &bld->coord_bld;
- LLVMValueRef length_minus_one;
+ struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
+ struct lp_build_context abs_coord_bld;
+ struct lp_type abs_type;
+ LLVMValueRef length_minus_one = lp_build_sub(int_coord_bld, length_i,
+ int_coord_bld->one);
+ LLVMValueRef mask, i32_c8, i32_c128, i32_c255;
+
+ /* wrap with normalized floats is just fract */
+ coord_f = lp_build_fract(coord_bld, coord_f);
+ /* mul by size */
+ coord_f = lp_build_mul(coord_bld, coord_f, length_f);
+ /* convert to int, compute lerp weight */
+ coord_f = lp_build_mul_imm(&bld->coord_bld, coord_f, 256);
+
+ /* At this point we don't have any negative numbers so use non-signed
+ * build context which might help on some archs.
+ */
+ abs_type = coord_bld->type;
+ abs_type.sign = 0;
+ lp_build_context_init(&abs_coord_bld, bld->gallivm, abs_type);
+ *coord0_i = lp_build_iround(&abs_coord_bld, coord_f);
- switch(wrap_mode) {
- case PIPE_TEX_WRAP_REPEAT:
- if (offset) {
- /* this is definitely not ideal for POT case */
- offset = lp_build_int_to_float(coord_bld, offset);
- offset = lp_build_div(coord_bld, offset, length);
- coord = lp_build_add(coord_bld, coord, offset);
- }
- /* take fraction, unnormalize */
- coord = lp_build_fract_safe(coord_bld, coord);
- coord = lp_build_mul(coord_bld, coord, length);
- *icoord = lp_build_itrunc(coord_bld, coord);
- break;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- length_minus_one = lp_build_sub(coord_bld, length, coord_bld->one);
- if (bld->static_sampler_state->normalized_coords) {
- /* scale coord to length */
- coord = lp_build_mul(coord_bld, coord, length);
- }
- if (offset) {
- offset = lp_build_int_to_float(coord_bld, offset);
- coord = lp_build_add(coord_bld, coord, offset);
- }
- coord = lp_build_clamp(coord_bld, coord, coord_bld->zero,
- length_minus_one);
- *icoord = lp_build_itrunc(coord_bld, coord);
- break;
+ /* subtract 0.5 (add -128) */
+ i32_c128 = lp_build_const_int_vec(bld->gallivm, bld->int_coord_type, -128);
+ *coord0_i = LLVMBuildAdd(bld->gallivm->builder, *coord0_i, i32_c128, "");
- case PIPE_TEX_WRAP_CLAMP:
- case PIPE_TEX_WRAP_CLAMP_TO_BORDER:
- case PIPE_TEX_WRAP_MIRROR_REPEAT:
- case PIPE_TEX_WRAP_MIRROR_CLAMP:
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE:
- case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER:
- default:
- assert(0);
- }
+ /* compute fractional part (AND with 0xff) */
+ i32_c255 = lp_build_const_int_vec(bld->gallivm, bld->int_coord_type, 255);
+ *weight_i = LLVMBuildAnd(bld->gallivm->builder, *coord0_i, i32_c255, "");
+
+ /* compute floor (shift right 8) */
+ i32_c8 = lp_build_const_int_vec(bld->gallivm, bld->int_coord_type, 8);
+ *coord0_i = LLVMBuildAShr(bld->gallivm->builder, *coord0_i, i32_c8, "");
+ /*
+ * we avoided the 0.5/length division before the repeat wrap,
+ * now need to fix up edge cases with selects
+ */
+ mask = lp_build_compare(int_coord_bld->gallivm, int_coord_bld->type,
+ PIPE_FUNC_LESS, *coord0_i, int_coord_bld->zero);
+ *coord0_i = lp_build_select(int_coord_bld, mask, length_minus_one, *coord0_i);
+ /*
+ * We should never get values too large - except if coord was nan or inf,
+ * in which case things go terribly wrong...
+ * Alternatively, could use fract_safe above...
+ */
+ *coord0_i = lp_build_min(int_coord_bld, *coord0_i, length_minus_one);
}
}
else {
LLVMValueRef mask;
- LLVMValueRef weight;
LLVMValueRef length_f = lp_build_int_to_float(&bld->coord_bld, length);
if (offset) {
offset = lp_build_int_to_float(&bld->coord_bld, offset);
offset = lp_build_div(&bld->coord_bld, offset, length_f);
coord_f = lp_build_add(&bld->coord_bld, coord_f, offset);
}
- lp_build_coord_repeat_npot_linear(bld, coord_f,
- length, length_f,
- &coord0, &weight);
+ lp_build_coord_repeat_npot_linear_int(bld, coord_f,
+ length, length_f,
+ &coord0, weight_i);
mask = lp_build_compare(bld->gallivm, int_coord_bld->type,
PIPE_FUNC_NOTEQUAL, coord0, length_minus_one);
coord1 = LLVMBuildAnd(builder,
lp_build_add(int_coord_bld, coord0,
int_coord_bld->one),
mask, "");
- weight = lp_build_mul_imm(&bld->coord_bld, weight, 256);
- *weight_i = lp_build_itrunc(&bld->coord_bld, weight);
}
break;
coord0 = LLVMBuildAnd(builder, coord0, length_minus_one, "");
}
else {
- LLVMValueRef weight;
LLVMValueRef length_f = lp_build_int_to_float(&bld->coord_bld, length);
if (offset) {
offset = lp_build_int_to_float(&bld->coord_bld, offset);
offset = lp_build_div(&bld->coord_bld, offset, length_f);
coord_f = lp_build_add(&bld->coord_bld, coord_f, offset);
}
- lp_build_coord_repeat_npot_linear(bld, coord_f,
- length, length_f,
- &coord0, &weight);
- weight = lp_build_mul_imm(&bld->coord_bld, weight, 256);
- *weight_i = lp_build_itrunc(&bld->coord_bld, weight);
+ lp_build_coord_repeat_npot_linear_int(bld, coord_f,
+ length, length_f,
+ &coord0, weight_i);
}
mask = lp_build_compare(bld->gallivm, int_coord_bld->type,
}
-/**
- * Build LLVM code for texture coord wrapping, for linear filtering,
- * for float texcoords.
- * \param block_length is the length of the pixel block along the
- * coordinate axis
- * \param coord the incoming texcoord (s,t or r)
- * \param length the texture size along one dimension
- * \param offset the texel offset along the coord axis
- * \param is_pot if TRUE, length is a power of two
- * \param wrap_mode one of PIPE_TEX_WRAP_x
- * \param coord0 the first texcoord after wrapping, as int
- * \param coord1 the second texcoord after wrapping, as int
- * \param weight the filter weight as int (0-255)
- * \param force_nearest if this coord actually uses nearest filtering
- */
-static void
-lp_build_sample_wrap_linear_float(struct lp_build_sample_context *bld,
- unsigned block_length,
- LLVMValueRef coord,
- LLVMValueRef length,
- LLVMValueRef offset,
- boolean is_pot,
- unsigned wrap_mode,
- LLVMValueRef *coord0,
- LLVMValueRef *coord1,
- LLVMValueRef *weight,
- unsigned force_nearest)
-{
- struct lp_build_context *int_coord_bld = &bld->int_coord_bld;
- struct lp_build_context *coord_bld = &bld->coord_bld;
- LLVMBuilderRef builder = bld->gallivm->builder;
- LLVMValueRef half = lp_build_const_vec(bld->gallivm, coord_bld->type, 0.5);
- LLVMValueRef length_minus_one = lp_build_sub(coord_bld, length, coord_bld->one);
-
- switch(wrap_mode) {
- case PIPE_TEX_WRAP_REPEAT:
- if (is_pot) {
- /* mul by size and subtract 0.5 */
- coord = lp_build_mul(coord_bld, coord, length);
- if (offset) {
- offset = lp_build_int_to_float(coord_bld, offset);
- coord = lp_build_add(coord_bld, coord, offset);
- }
- if (!force_nearest)
- coord = lp_build_sub(coord_bld, coord, half);
- *coord1 = lp_build_add(coord_bld, coord, coord_bld->one);
- /* convert to int, compute lerp weight */
- lp_build_ifloor_fract(coord_bld, coord, coord0, weight);
- *coord1 = lp_build_ifloor(coord_bld, *coord1);
- /* repeat wrap */
- length_minus_one = lp_build_itrunc(coord_bld, length_minus_one);
- *coord0 = LLVMBuildAnd(builder, *coord0, length_minus_one, "");
- *coord1 = LLVMBuildAnd(builder, *coord1, length_minus_one, "");
- }
- else {
- LLVMValueRef mask;
- if (offset) {
- offset = lp_build_int_to_float(coord_bld, offset);
- offset = lp_build_div(coord_bld, offset, length);
- coord = lp_build_add(coord_bld, coord, offset);
- }
- /* wrap with normalized floats is just fract */
- coord = lp_build_fract(coord_bld, coord);
- /* unnormalize */
- coord = lp_build_mul(coord_bld, coord, length);
- /*
- * we avoided the 0.5/length division, have to fix up wrong
- * edge cases with selects
- */
- *coord1 = lp_build_add(coord_bld, coord, half);
- coord = lp_build_sub(coord_bld, coord, half);
- *weight = lp_build_fract(coord_bld, coord);
- mask = lp_build_compare(coord_bld->gallivm, coord_bld->type,
- PIPE_FUNC_LESS, coord, coord_bld->zero);
- *coord0 = lp_build_select(coord_bld, mask, length_minus_one, coord);
- *coord0 = lp_build_itrunc(coord_bld, *coord0);
- mask = lp_build_compare(coord_bld->gallivm, coord_bld->type,
- PIPE_FUNC_LESS, *coord1, length);
- *coord1 = lp_build_select(coord_bld, mask, *coord1, coord_bld->zero);
- *coord1 = lp_build_itrunc(coord_bld, *coord1);
- }
- break;
- case PIPE_TEX_WRAP_CLAMP_TO_EDGE:
- if (bld->static_sampler_state->normalized_coords) {
- /* mul by tex size */
- coord = lp_build_mul(coord_bld, coord, length);
- }
- if (offset) {
- offset = lp_build_int_to_float(coord_bld, offset);
- coord = lp_build_add(coord_bld, coord, offset);
- }
- /* subtract 0.5 */
- if (!force_nearest) {
- coord = lp_build_sub(coord_bld, coord, half);
- }
- /* clamp to [0, length - 1] */
- coord = lp_build_min(coord_bld, coord, length_minus_one);
- coord = lp_build_max(coord_bld, coord, coord_bld->zero);
- *coord1 = lp_build_add(coord_bld, coord, coord_bld->one);
- /* convert to int, compute lerp weight */
- lp_build_ifloor_fract(coord_bld, coord, coord0, weight);
- /* coord1 = min(coord1, length-1) */
- *coord1 = lp_build_min(coord_bld, *coord1, length_minus_one);
- *coord1 = lp_build_itrunc(coord_bld, *coord1);
- break;
- default:
- assert(0);
- *coord0 = int_coord_bld->zero;
- *coord1 = int_coord_bld->zero;
- *weight = coord_bld->zero;
- break;
- }
- *weight = lp_build_mul_imm(coord_bld, *weight, 256);
- *weight = lp_build_itrunc(coord_bld, *weight);
- return;
-}
-
-
/**
* Fetch texels for image with nearest sampling.
* Return filtered color as two vectors of 16-bit fixed point values.
LLVMValueRef rgba8;
struct lp_build_context u8n;
LLVMTypeRef u8n_vec_type;
+ struct lp_type fetch_type;
lp_build_context_init(&u8n, bld->gallivm, lp_type_unorm(8, bld->vector_width));
u8n_vec_type = lp_build_vec_type(bld->gallivm, u8n.type);
+ fetch_type = lp_type_uint(bld->texel_type.width);
if (util_format_is_rgba8_variant(bld->format_desc)) {
/*
* Given the format is a rgba8, just read the pixels as is,
rgba8 = lp_build_gather(bld->gallivm,
bld->texel_type.length,
bld->format_desc->block.bits,
- bld->texel_type.width,
+ fetch_type,
+ TRUE,
data_ptr, offset, TRUE);
rgba8 = LLVMBuildBitCast(builder, rgba8, u8n_vec_type, "");
rgba8 = lp_build_fetch_rgba_aos(bld->gallivm,
bld->format_desc,
u8n.type,
+ TRUE,
data_ptr, offset,
x_subcoord,
- y_subcoord);
+ y_subcoord,
+ bld->cache);
}
*colors = rgba8;
LLVMValueRef *colors)
{
const unsigned dims = bld->dims;
- LLVMBuilderRef builder = bld->gallivm->builder;
struct lp_build_context i32;
- LLVMTypeRef i32_vec_type;
- LLVMValueRef i32_c8;
LLVMValueRef width_vec, height_vec, depth_vec;
LLVMValueRef s_ipart, t_ipart = NULL, r_ipart = NULL;
LLVMValueRef s_float, t_float = NULL, r_float = NULL;
lp_build_context_init(&i32, bld->gallivm, lp_type_int_vec(32, bld->vector_width));
- i32_vec_type = lp_build_vec_type(bld->gallivm, i32.type);
-
lp_build_extract_image_sizes(bld,
&bld->int_size_bld,
bld->int_coord_type,
s_float = s; t_float = t; r_float = r;
if (bld->static_sampler_state->normalized_coords) {
- LLVMValueRef scaled_size;
LLVMValueRef flt_size;
- /* scale size by 256 (8 fractional bits) */
- scaled_size = lp_build_shl_imm(&bld->int_size_bld, int_size, 8);
-
- flt_size = lp_build_int_to_float(&bld->float_size_bld, scaled_size);
+ flt_size = lp_build_int_to_float(&bld->float_size_bld, int_size);
lp_build_unnormalized_coords(bld, flt_size, &s, &t, &r);
}
- else {
- /* scale coords by 256 (8 fractional bits) */
- s = lp_build_mul_imm(&bld->coord_bld, s, 256);
- if (dims >= 2)
- t = lp_build_mul_imm(&bld->coord_bld, t, 256);
- if (dims >= 3)
- r = lp_build_mul_imm(&bld->coord_bld, r, 256);
- }
/* convert float to int */
- s = LLVMBuildFPToSI(builder, s, i32_vec_type, "");
- if (dims >= 2)
- t = LLVMBuildFPToSI(builder, t, i32_vec_type, "");
- if (dims >= 3)
- r = LLVMBuildFPToSI(builder, r, i32_vec_type, "");
-
- /* compute floor (shift right 8) */
- i32_c8 = lp_build_const_int_vec(bld->gallivm, i32.type, 8);
- s_ipart = LLVMBuildAShr(builder, s, i32_c8, "");
+ /* For correct rounding, need floor, not truncation here.
+ * Note that in some cases (clamp to edge, no texel offsets) we
+ * could use a non-signed build context which would help archs
+ * greatly which don't have arch rounding.
+ */
+ s_ipart = lp_build_ifloor(&bld->coord_bld, s);
if (dims >= 2)
- t_ipart = LLVMBuildAShr(builder, t, i32_c8, "");
+ t_ipart = lp_build_ifloor(&bld->coord_bld, t);
if (dims >= 3)
- r_ipart = LLVMBuildAShr(builder, r, i32_c8, "");
+ r_ipart = lp_build_ifloor(&bld->coord_bld, r);
/* add texel offsets */
if (offsets[0]) {
offset = lp_build_add(&bld->int_coord_bld, offset, z_offset);
}
}
- if (bld->static_texture_state->target == PIPE_TEXTURE_CUBE ||
- bld->static_texture_state->target == PIPE_TEXTURE_1D_ARRAY ||
- bld->static_texture_state->target == PIPE_TEXTURE_2D_ARRAY) {
+ if (has_layer_coord(bld->static_texture_state->target)) {
LLVMValueRef z_offset;
/* The r coord is the cube face in [0,5] or array layer */
z_offset = lp_build_mul(&bld->int_coord_bld, r, img_stride_vec);
}
-/**
- * Sample a single texture image with nearest sampling.
- * If sampling a cube texture, r = cube face in [0,5].
- * Return filtered color as two vectors of 16-bit fixed point values.
- * Does address calcs (except offsets) with floats.
- * Useful for AVX which has support for 8x32 floats but not 8x32 ints.
- */
-static void
-lp_build_sample_image_nearest_afloat(struct lp_build_sample_context *bld,
- LLVMValueRef int_size,
- LLVMValueRef row_stride_vec,
- LLVMValueRef img_stride_vec,
- LLVMValueRef data_ptr,
- LLVMValueRef mipoffsets,
- LLVMValueRef s,
- LLVMValueRef t,
- LLVMValueRef r,
- const LLVMValueRef *offsets,
- LLVMValueRef *colors)
- {
- const unsigned dims = bld->dims;
- LLVMValueRef width_vec, height_vec, depth_vec;
- LLVMValueRef offset;
- LLVMValueRef x_subcoord, y_subcoord;
- LLVMValueRef x_icoord = NULL, y_icoord = NULL, z_icoord = NULL;
- LLVMValueRef flt_size;
-
- flt_size = lp_build_int_to_float(&bld->float_size_bld, int_size);
-
- lp_build_extract_image_sizes(bld,
- &bld->float_size_bld,
- bld->coord_type,
- flt_size,
- &width_vec,
- &height_vec,
- &depth_vec);
-
- /* Do texcoord wrapping */
- lp_build_sample_wrap_nearest_float(bld,
- s, width_vec, offsets[0],
- bld->static_texture_state->pot_width,
- bld->static_sampler_state->wrap_s,
- &x_icoord);
-
- if (dims >= 2) {
- lp_build_sample_wrap_nearest_float(bld,
- t, height_vec, offsets[1],
- bld->static_texture_state->pot_height,
- bld->static_sampler_state->wrap_t,
- &y_icoord);
-
- if (dims >= 3) {
- lp_build_sample_wrap_nearest_float(bld,
- r, depth_vec, offsets[2],
- bld->static_texture_state->pot_depth,
- bld->static_sampler_state->wrap_r,
- &z_icoord);
- }
- }
- if (bld->static_texture_state->target == PIPE_TEXTURE_CUBE ||
- bld->static_texture_state->target == PIPE_TEXTURE_1D_ARRAY ||
- bld->static_texture_state->target == PIPE_TEXTURE_2D_ARRAY) {
- z_icoord = r;
- }
-
- /*
- * From here on we deal with ints, and we should split up the 256bit
- * vectors manually for better generated code.
- */
-
- /*
- * compute texel offsets -
- * cannot do offset calc with floats, difficult for block-based formats,
- * and not enough precision anyway.
- */
- lp_build_sample_offset(&bld->int_coord_bld,
- bld->format_desc,
- x_icoord, y_icoord,
- z_icoord,
- row_stride_vec, img_stride_vec,
- &offset,
- &x_subcoord, &y_subcoord);
- if (mipoffsets) {
- offset = lp_build_add(&bld->int_coord_bld, offset, mipoffsets);
- }
-
- lp_build_sample_fetch_image_nearest(bld, data_ptr, offset,
- x_subcoord, y_subcoord,
- colors);
-}
-
-
/**
* Fetch texels for image with linear sampling.
* Return filtered color as two vectors of 16-bit fixed point values.
r_fpart = LLVMBuildBitCast(builder, r_fpart, u8n_vec_type, "");
for (j = 0; j < u8n.type.length; j += 4) {
-#ifdef PIPE_ARCH_LITTLE_ENDIAN
+#if UTIL_ARCH_LITTLE_ENDIAN
unsigned subindex = 0;
#else
unsigned subindex = 3;
LLVMValueRef rgba8;
if (util_format_is_rgba8_variant(bld->format_desc)) {
+ struct lp_type fetch_type;
/*
* Given the format is a rgba8, just read the pixels as is,
* without any swizzling. Swizzling will be done later.
*/
+ fetch_type = lp_type_uint(bld->texel_type.width);
rgba8 = lp_build_gather(bld->gallivm,
bld->texel_type.length,
bld->format_desc->block.bits,
- bld->texel_type.width,
+ fetch_type,
+ TRUE,
data_ptr, offset[k][j][i], TRUE);
rgba8 = LLVMBuildBitCast(builder, rgba8, u8n_vec_type, "");
rgba8 = lp_build_fetch_rgba_aos(bld->gallivm,
bld->format_desc,
u8n.type,
+ TRUE,
data_ptr, offset[k][j][i],
x_subcoord[i],
- y_subcoord[j]);
+ y_subcoord[j],
+ bld->cache);
}
neighbors[k][j][i] = rgba8;
const unsigned dims = bld->dims;
LLVMBuilderRef builder = bld->gallivm->builder;
struct lp_build_context i32;
- LLVMTypeRef i32_vec_type;
LLVMValueRef i32_c8, i32_c128, i32_c255;
LLVMValueRef width_vec, height_vec, depth_vec;
LLVMValueRef s_ipart, s_fpart, s_float;
lp_build_context_init(&i32, bld->gallivm, lp_type_int_vec(32, bld->vector_width));
- i32_vec_type = lp_build_vec_type(bld->gallivm, i32.type);
-
lp_build_extract_image_sizes(bld,
&bld->int_size_bld,
bld->int_coord_type,
}
/* convert float to int */
- s = LLVMBuildFPToSI(builder, s, i32_vec_type, "");
+ /* For correct rounding, need round to nearest, not truncation here.
+ * Note that in some cases (clamp to edge, no texel offsets) we
+ * could use a non-signed build context which would help archs which
+ * don't have fptosi intrinsic with nearest rounding implemented.
+ */
+ s = lp_build_iround(&bld->coord_bld, s);
if (dims >= 2)
- t = LLVMBuildFPToSI(builder, t, i32_vec_type, "");
+ t = lp_build_iround(&bld->coord_bld, t);
if (dims >= 3)
- r = LLVMBuildFPToSI(builder, r, i32_vec_type, "");
+ r = lp_build_iround(&bld->coord_bld, r);
/* subtract 0.5 (add -128) */
i32_c128 = lp_build_const_int_vec(bld->gallivm, i32.type, -128);
&x_subcoord[0], &x_subcoord[1]);
/* add potential cube/array/mip offsets now as they are constant per pixel */
- if (bld->static_texture_state->target == PIPE_TEXTURE_CUBE ||
- bld->static_texture_state->target == PIPE_TEXTURE_1D_ARRAY ||
- bld->static_texture_state->target == PIPE_TEXTURE_2D_ARRAY) {
+ if (has_layer_coord(bld->static_texture_state->target)) {
LLVMValueRef z_offset;
z_offset = lp_build_mul(&bld->int_coord_bld, r, img_stride_vec);
/* The r coord is the cube face in [0,5] or array layer */
if (dims >= 3) {
lp_build_sample_wrap_linear_int(bld,
- bld->format_desc->block.height,
+ 1, /* block length (depth) */
r_ipart, &r_fpart, r_float,
depth_vec, z_stride, offsets[2],
bld->static_texture_state->pot_depth,
}
-/**
- * Sample a single texture image with (bi-)(tri-)linear sampling.
- * Return filtered color as two vectors of 16-bit fixed point values.
- * Does address calcs (except offsets) with floats.
- * Useful for AVX which has support for 8x32 floats but not 8x32 ints.
- */
-static void
-lp_build_sample_image_linear_afloat(struct lp_build_sample_context *bld,
- LLVMValueRef int_size,
- LLVMValueRef row_stride_vec,
- LLVMValueRef img_stride_vec,
- LLVMValueRef data_ptr,
- LLVMValueRef mipoffsets,
- LLVMValueRef s,
- LLVMValueRef t,
- LLVMValueRef r,
- const LLVMValueRef *offsets,
- LLVMValueRef *colors)
-{
- const unsigned dims = bld->dims;
- LLVMValueRef width_vec, height_vec, depth_vec;
- LLVMValueRef s_fpart;
- LLVMValueRef t_fpart = NULL;
- LLVMValueRef r_fpart = NULL;
- LLVMValueRef x_stride, y_stride, z_stride;
- LLVMValueRef x_offset0, x_offset1;
- LLVMValueRef y_offset0, y_offset1;
- LLVMValueRef z_offset0, z_offset1;
- LLVMValueRef offset[2][2][2]; /* [z][y][x] */
- LLVMValueRef x_subcoord[2], y_subcoord[2];
- LLVMValueRef flt_size;
- LLVMValueRef x_icoord0, x_icoord1;
- LLVMValueRef y_icoord0, y_icoord1;
- LLVMValueRef z_icoord0, z_icoord1;
- unsigned x, y, z;
-
- flt_size = lp_build_int_to_float(&bld->float_size_bld, int_size);
-
- lp_build_extract_image_sizes(bld,
- &bld->float_size_bld,
- bld->coord_type,
- flt_size,
- &width_vec,
- &height_vec,
- &depth_vec);
-
- /* do texcoord wrapping and compute texel offsets */
- lp_build_sample_wrap_linear_float(bld,
- bld->format_desc->block.width,
- s, width_vec, offsets[0],
- bld->static_texture_state->pot_width,
- bld->static_sampler_state->wrap_s,
- &x_icoord0, &x_icoord1,
- &s_fpart,
- bld->static_sampler_state->force_nearest_s);
-
- if (dims >= 2) {
- lp_build_sample_wrap_linear_float(bld,
- bld->format_desc->block.height,
- t, height_vec, offsets[1],
- bld->static_texture_state->pot_height,
- bld->static_sampler_state->wrap_t,
- &y_icoord0, &y_icoord1,
- &t_fpart,
- bld->static_sampler_state->force_nearest_t);
-
- if (dims >= 3) {
- lp_build_sample_wrap_linear_float(bld,
- bld->format_desc->block.height,
- r, depth_vec, offsets[2],
- bld->static_texture_state->pot_depth,
- bld->static_sampler_state->wrap_r,
- &z_icoord0, &z_icoord1,
- &r_fpart, 0);
- }
- }
-
- /*
- * From here on we deal with ints, and we should split up the 256bit
- * vectors manually for better generated code.
- */
-
- /* get pixel, row and image strides */
- x_stride = lp_build_const_vec(bld->gallivm,
- bld->int_coord_bld.type,
- bld->format_desc->block.bits/8);
- y_stride = row_stride_vec;
- z_stride = img_stride_vec;
-
- /*
- * compute texel offset -
- * cannot do offset calc with floats, difficult for block-based formats,
- * and not enough precision anyway.
- */
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- bld->format_desc->block.width,
- x_icoord0, x_stride,
- &x_offset0, &x_subcoord[0]);
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- bld->format_desc->block.width,
- x_icoord1, x_stride,
- &x_offset1, &x_subcoord[1]);
-
- /* add potential cube/array/mip offsets now as they are constant per pixel */
- if (bld->static_texture_state->target == PIPE_TEXTURE_CUBE ||
- bld->static_texture_state->target == PIPE_TEXTURE_1D_ARRAY ||
- bld->static_texture_state->target == PIPE_TEXTURE_2D_ARRAY) {
- LLVMValueRef z_offset;
- z_offset = lp_build_mul(&bld->int_coord_bld, r, img_stride_vec);
- /* The r coord is the cube face in [0,5] or array layer */
- x_offset0 = lp_build_add(&bld->int_coord_bld, x_offset0, z_offset);
- x_offset1 = lp_build_add(&bld->int_coord_bld, x_offset1, z_offset);
- }
- if (mipoffsets) {
- x_offset0 = lp_build_add(&bld->int_coord_bld, x_offset0, mipoffsets);
- x_offset1 = lp_build_add(&bld->int_coord_bld, x_offset1, mipoffsets);
- }
-
- for (z = 0; z < 2; z++) {
- for (y = 0; y < 2; y++) {
- offset[z][y][0] = x_offset0;
- offset[z][y][1] = x_offset1;
- }
- }
-
- if (dims >= 2) {
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- bld->format_desc->block.height,
- y_icoord0, y_stride,
- &y_offset0, &y_subcoord[0]);
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- bld->format_desc->block.height,
- y_icoord1, y_stride,
- &y_offset1, &y_subcoord[1]);
- for (z = 0; z < 2; z++) {
- for (x = 0; x < 2; x++) {
- offset[z][0][x] = lp_build_add(&bld->int_coord_bld,
- offset[z][0][x], y_offset0);
- offset[z][1][x] = lp_build_add(&bld->int_coord_bld,
- offset[z][1][x], y_offset1);
- }
- }
- }
-
- if (dims >= 3) {
- LLVMValueRef z_subcoord[2];
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- 1,
- z_icoord0, z_stride,
- &z_offset0, &z_subcoord[0]);
- lp_build_sample_partial_offset(&bld->int_coord_bld,
- 1,
- z_icoord1, z_stride,
- &z_offset1, &z_subcoord[1]);
- for (y = 0; y < 2; y++) {
- for (x = 0; x < 2; x++) {
- offset[0][y][x] = lp_build_add(&bld->int_coord_bld,
- offset[0][y][x], z_offset0);
- offset[1][y][x] = lp_build_add(&bld->int_coord_bld,
- offset[1][y][x], z_offset1);
- }
- }
- }
-
- lp_build_sample_fetch_image_linear(bld, data_ptr, offset,
- x_subcoord, y_subcoord,
- s_fpart, t_fpart, r_fpart,
- colors);
-}
-
-
/**
* Sample the texture/mipmap using given image filter and mip filter.
* data0_ptr and data1_ptr point to the two mipmap levels to sample
lp_build_mipmap_level_sizes(bld, ilevel0,
&size0,
&row_stride0_vec, &img_stride0_vec);
- if (bld->num_lods == 1) {
+ if (bld->num_mips == 1) {
data_ptr0 = lp_build_get_mipmap_level(bld, ilevel0);
}
else {
mipoff0 = lp_build_get_mip_offsets(bld, ilevel0);
}
- if (util_cpu_caps.has_avx && bld->coord_type.length > 4) {
- if (img_filter == PIPE_TEX_FILTER_NEAREST) {
- lp_build_sample_image_nearest_afloat(bld,
- size0,
- row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r, offsets,
- &colors0);
- }
- else {
- assert(img_filter == PIPE_TEX_FILTER_LINEAR);
- lp_build_sample_image_linear_afloat(bld,
- size0,
- row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r, offsets,
- &colors0);
- }
+ if (img_filter == PIPE_TEX_FILTER_NEAREST) {
+ lp_build_sample_image_nearest(bld,
+ size0,
+ row_stride0_vec, img_stride0_vec,
+ data_ptr0, mipoff0, s, t, r, offsets,
+ &colors0);
}
else {
- if (img_filter == PIPE_TEX_FILTER_NEAREST) {
- lp_build_sample_image_nearest(bld,
- size0,
- row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r, offsets,
- &colors0);
- }
- else {
- assert(img_filter == PIPE_TEX_FILTER_LINEAR);
- lp_build_sample_image_linear(bld,
- size0,
- row_stride0_vec, img_stride0_vec,
- data_ptr0, mipoff0, s, t, r, offsets,
- &colors0);
- }
+ assert(img_filter == PIPE_TEX_FILTER_LINEAR);
+ lp_build_sample_image_linear(bld,
+ size0,
+ row_stride0_vec, img_stride0_vec,
+ data_ptr0, mipoff0, s, t, r, offsets,
+ &colors0);
}
/* Store the first level's colors in the output variables */
if (mip_filter == PIPE_TEX_MIPFILTER_LINEAR) {
LLVMValueRef h16vec_scale = lp_build_const_vec(bld->gallivm,
- bld->levelf_bld.type, 256.0);
- LLVMTypeRef i32vec_type = bld->leveli_bld.vec_type;
+ bld->lodf_bld.type, 256.0);
+ LLVMTypeRef i32vec_type = bld->lodi_bld.vec_type;
struct lp_build_if_state if_ctx;
LLVMValueRef need_lerp;
unsigned num_quads = bld->coord_bld.type.length / 4;
/* need_lerp = lod_fpart > 0 */
if (bld->num_lods == 1) {
need_lerp = LLVMBuildICmp(builder, LLVMIntSGT,
- lod_fpart, bld->leveli_bld.zero,
+ lod_fpart, bld->lodi_bld.zero,
"need_lerp");
}
else {
* lod_fpart values have same sign.
* We can however then skip the greater than comparison.
*/
- lod_fpart = lp_build_max(&bld->leveli_bld, lod_fpart,
- bld->leveli_bld.zero);
- need_lerp = lp_build_any_true_range(&bld->leveli_bld, bld->num_lods, lod_fpart);
+ lod_fpart = lp_build_max(&bld->lodi_bld, lod_fpart,
+ bld->lodi_bld.zero);
+ need_lerp = lp_build_any_true_range(&bld->lodi_bld, bld->num_lods, lod_fpart);
}
lp_build_if(&if_ctx, bld->gallivm, need_lerp);
lp_build_mipmap_level_sizes(bld, ilevel1,
&size1,
&row_stride1_vec, &img_stride1_vec);
- if (bld->num_lods == 1) {
+ if (bld->num_mips == 1) {
data_ptr1 = lp_build_get_mipmap_level(bld, ilevel1);
}
else {
mipoff1 = lp_build_get_mip_offsets(bld, ilevel1);
}
- if (util_cpu_caps.has_avx && bld->coord_type.length > 4) {
- if (img_filter == PIPE_TEX_FILTER_NEAREST) {
- lp_build_sample_image_nearest_afloat(bld,
- size1,
- row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r, offsets,
- &colors1);
- }
- else {
- lp_build_sample_image_linear_afloat(bld,
- size1,
- row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r, offsets,
- &colors1);
- }
+ if (img_filter == PIPE_TEX_FILTER_NEAREST) {
+ lp_build_sample_image_nearest(bld,
+ size1,
+ row_stride1_vec, img_stride1_vec,
+ data_ptr1, mipoff1, s, t, r, offsets,
+ &colors1);
}
else {
- if (img_filter == PIPE_TEX_FILTER_NEAREST) {
- lp_build_sample_image_nearest(bld,
- size1,
- row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r, offsets,
- &colors1);
- }
- else {
- lp_build_sample_image_linear(bld,
- size1,
- row_stride1_vec, img_stride1_vec,
- data_ptr1, mipoff1, s, t, r, offsets,
- &colors1);
- }
+ lp_build_sample_image_linear(bld,
+ size1,
+ row_stride1_vec, img_stride1_vec,
+ data_ptr1, mipoff1, s, t, r, offsets,
+ &colors1);
}
/* interpolate samples from the two mipmap levels */
if (num_quads == 1 && bld->num_lods == 1) {
lod_fpart = LLVMBuildTrunc(builder, lod_fpart, u8n_bld.elem_type, "");
lod_fpart = lp_build_broadcast_scalar(&u8n_bld, lod_fpart);
-
-#if HAVE_LLVM == 0x208
- /* This was a work-around for a bug in LLVM 2.8.
- * Evidently, something goes wrong in the construction of the
- * lod_fpart short[8] vector. Adding this no-effect shuffle seems
- * to force the vector to be properly constructed.
- * Tested with mesa-demos/src/tests/mipmap_limits.c (press t, f).
- */
-#error Unsupported
-#endif
}
else {
unsigned num_chans_per_lod = 4 * bld->coord_type.length / bld->num_lods;
- LLVMTypeRef tmp_vec_type = LLVMVectorType(u8n_bld.elem_type, bld->leveli_bld.type.length);
+ LLVMTypeRef tmp_vec_type = LLVMVectorType(u8n_bld.elem_type, bld->lodi_bld.type.length);
LLVMValueRef shuffle[LP_MAX_VECTOR_LENGTH];
/* Take the LSB of lod_fpart */
LLVMValueRef t,
LLVMValueRef r,
const LLVMValueRef *offsets,
- LLVMValueRef lod_ipart,
+ LLVMValueRef lod_positive,
LLVMValueRef lod_fpart,
LLVMValueRef ilevel0,
LLVMValueRef ilevel1,
LLVMValueRef texel_out[4])
{
- struct lp_build_context *int_bld = &bld->int_bld;
LLVMBuilderRef builder = bld->gallivm->builder;
const unsigned mip_filter = bld->static_sampler_state->min_mip_filter;
const unsigned min_filter = bld->static_sampler_state->min_img_filter;
* depending on the lod being > 0 or <= 0, respectively.
*/
struct lp_build_if_state if_ctx;
- LLVMValueRef minify;
/*
- * XXX this should take all lods into account, if some are min
- * some max probably could hack up the coords/weights in the linear
+ * FIXME this should take all lods into account, if some are min
+ * some max probably could hack up the weights in the linear
* path with selects to work for nearest.
- * If that's just two quads sitting next to each other it seems
- * quite ok to do the same filtering method on both though, at
- * least unless we have explicit lod (and who uses different
- * min/mag filter with that?)
*/
if (bld->num_lods > 1)
- lod_ipart = LLVMBuildExtractElement(builder, lod_ipart,
- lp_build_const_int32(bld->gallivm, 0), "");
+ lod_positive = LLVMBuildExtractElement(builder, lod_positive,
+ lp_build_const_int32(bld->gallivm, 0), "");
- /* minify = lod >= 0.0 */
- minify = LLVMBuildICmp(builder, LLVMIntSGE,
- lod_ipart, int_bld->zero, "");
+ lod_positive = LLVMBuildTrunc(builder, lod_positive,
+ LLVMInt1TypeInContext(bld->gallivm->context), "");
- lp_build_if(&if_ctx, bld->gallivm, minify);
+ lp_build_if(&if_ctx, bld->gallivm, lod_positive);
{
/* Use the minification filter */
lp_build_sample_mipmap(bld,
projects / mesa.git / blobdiff