fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-06-14 22:18:20 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

llvmpipe: add stride argument to lp_build_swizzle_aos_n

Browse source 
Acked-by: Roland Scheidegger <roland.scheidegger@broadcom.com>
Acked-by: Konstantin Seurer <konstantin.seurer@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/38316>
This commit is contained in:
Aleksi Sapon 2025-12-03 12:21:53 -05:00 • committed by Marge Bot
parent 3bd8a5e3f1
commit f4f1ba1fb2
4 changed files with 54 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
src/gallium/auxiliary/gallivm/lp_bld_sample.c
View file

@ -314,9 +314,9 @@ lp_apply_ellipse_transform(struct lp_build_context *bld,
static const unsigned char swizzle01[] = { 0, 1 };
static const unsigned char swizzle23[] = { 2, 3 };
LLVMValueRef ds2dx_ds2dy = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle01, ARRAY_SIZE(swizzle01), half_length_vec.length);
swizzle01, ARRAY_SIZE(swizzle01), 4, half_length_vec.length);
LLVMValueRef dt2dx_dt2dy = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle23, ARRAY_SIZE(swizzle23), half_length_vec.length);
swizzle23, ARRAY_SIZE(swizzle23), 4, half_length_vec.length);
LLVMValueRef square_length_dx_dy = lp_build_add(&half_length_bld, ds2dx_ds2dy, dt2dx_dt2dy);
LLVMValueRef zero_length_dx_dy = lp_build_cmp(&half_length_bld, PIPE_FUNC_LESS,
square_length_dx_dy, lp_build_const_vec(gallivm, half_length_vec, epsilon2));
@ -334,17 +334,17 @@ lp_apply_ellipse_transform(struct lp_build_context *bld,
*/
static const unsigned char swizzle32[] = { 3, 2 };
LLVMValueRef dsdx_dsdy = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
swizzle01, ARRAY_SIZE(swizzle01), half_length_vec.length);
swizzle01, ARRAY_SIZE(swizzle01), 4, half_length_vec.length);
LLVMValueRef dtdy_dtdx = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
swizzle32, ARRAY_SIZE(swizzle32), half_length_vec.length);
swizzle32, ARRAY_SIZE(swizzle32), 4, half_length_vec.length);
LLVMValueRef dsdxdtdy_dsdydtdx = lp_build_mul(&half_length_bld, dsdx_dsdy, dtdy_dtdx);
static const unsigned char swizzle0[] = { 0 };
static const unsigned char swizzle1[] = { 1 };
LLVMValueRef determinant = lp_build_sub(&quarter_length_bld,
lp_build_swizzle_aos_n(gallivm, dsdxdtdy_dsdydtdx,
swizzle0, ARRAY_SIZE(swizzle0), quarter_length_vec.length),
swizzle0, ARRAY_SIZE(swizzle0), 2, quarter_length_vec.length),
lp_build_swizzle_aos_n(gallivm, dsdxdtdy_dsdydtdx,
swizzle1, ARRAY_SIZE(swizzle1), quarter_length_vec.length));
swizzle1, ARRAY_SIZE(swizzle1), 2, quarter_length_vec.length));
LLVMValueRef determinant2 = lp_build_mul(&quarter_length_bld, determinant, determinant);
LLVMValueRef zero_determinant = lp_build_cmp(&quarter_length_bld, PIPE_FUNC_LESS,
determinant2, lp_build_const_vec(gallivm, quarter_length_vec, epsilon2));
@ -355,15 +355,15 @@ lp_apply_ellipse_transform(struct lp_build_context *bld,
static const unsigned char swizzle02[] = { 0, 2 };
static const unsigned char swizzle13[] = { 1, 3 };
LLVMValueRef dsdx_dtdx = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
swizzle02, ARRAY_SIZE(swizzle02), half_length_vec.length);
swizzle02, ARRAY_SIZE(swizzle02), 4, half_length_vec.length);
LLVMValueRef dsdy_dtdy = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
swizzle13, ARRAY_SIZE(swizzle13), half_length_vec.length);
swizzle13, ARRAY_SIZE(swizzle13), 4, half_length_vec.length);
LLVMValueRef ds2dxdy_dt2dxdy = lp_build_mul(&half_length_bld, dsdx_dtdx, dsdy_dtdy);
LLVMValueRef dot_product = lp_build_add(&quarter_length_bld,
lp_build_swizzle_aos_n(gallivm, ds2dxdy_dt2dxdy,
swizzle0, ARRAY_SIZE(swizzle0), quarter_length_vec.length),
swizzle0, ARRAY_SIZE(swizzle0), 2, quarter_length_vec.length),
lp_build_swizzle_aos_n(gallivm, ds2dxdy_dt2dxdy,
swizzle1, ARRAY_SIZE(swizzle1), quarter_length_vec.length));
swizzle1, ARRAY_SIZE(swizzle1), 2, quarter_length_vec.length));
LLVMValueRef abs_dot_product = lp_build_abs(&quarter_length_bld, dot_product);
LLVMValueRef zero_dot_product = lp_build_cmp(&quarter_length_bld, PIPE_FUNC_LESS,
abs_dot_product, lp_build_const_vec(gallivm, quarter_length_vec, epsilon));
@ -395,27 +395,27 @@ lp_apply_ellipse_transform(struct lp_build_context *bld,
static const unsigned char swizzle20[] = { 2, 0 };
static const unsigned char swizzle31[] = { 3, 1 };
LLVMValueRef dt2dx_ds2dx = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle20, ARRAY_SIZE(swizzle20), half_length_vec.length);
swizzle20, ARRAY_SIZE(swizzle20), 4, half_length_vec.length);
LLVMValueRef dt2dy_ds2dy = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle31, ARRAY_SIZE(swizzle31), half_length_vec.length);
swizzle31, ARRAY_SIZE(swizzle31), 4, half_length_vec.length);
LLVMValueRef A_C = lp_build_add(&half_length_bld, dt2dx_ds2dx, dt2dy_ds2dy);
LLVMValueRef A = lp_build_swizzle_aos_n(gallivm, A_C,
swizzle0, ARRAY_SIZE(swizzle0), quarter_length_vec.length);
swizzle0, ARRAY_SIZE(swizzle0), 2, quarter_length_vec.length);
LLVMValueRef C = lp_build_swizzle_aos_n(gallivm, A_C,
swizzle1, ARRAY_SIZE(swizzle1), quarter_length_vec.length);
swizzle1, ARRAY_SIZE(swizzle1), 2, quarter_length_vec.length);
/*
* float B = -2.0 * (dx.s * dx.t + dy.s * dy.t)
*/
LLVMValueRef dtdx_dtdy = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
swizzle23, ARRAY_SIZE(swizzle23), half_length_vec.length);
swizzle23, ARRAY_SIZE(swizzle23), 4, half_length_vec.length);
LLVMValueRef dstdx_dstdy = lp_build_mul(&half_length_bld, dsdx_dsdy, dtdx_dtdy);
LLVMValueRef B = lp_build_mul(&quarter_length_bld,
lp_build_const_vec(gallivm, quarter_length_vec, -2), lp_build_add(&quarter_length_bld,
lp_build_swizzle_aos_n(gallivm, dstdx_dstdy,
swizzle0, ARRAY_SIZE(swizzle0), quarter_length_vec.length),
swizzle0, ARRAY_SIZE(swizzle0), 2, quarter_length_vec.length),
lp_build_swizzle_aos_n(gallivm, dstdx_dstdy,
swizzle1, ARRAY_SIZE(swizzle1), quarter_length_vec.length)));
swizzle1, ARRAY_SIZE(swizzle1), 2, quarter_length_vec.length)));
/*
* float F = (dx.s * dy.t - dy.s * dx.t) * (dx.s * dy.t - dy.s * dx.t)
@ -534,9 +534,9 @@ lp_build_rho_aniso(struct lp_build_sample_context *bld,
LLVMValueRef int_size = lp_build_minify(int_size_bld, bld->int_size, first_level, true);
LLVMValueRef float_size = lp_build_int_to_float(float_size_bld, int_size);
static const unsigned char swizzle01[] = { 0, 1 };
LLVMValueRef width_height = lp_build_swizzle_aos_n(gallivm, float_size,
swizzle01, ARRAY_SIZE(swizzle01), full_length_vec.length);
static const unsigned char swizzle0011[] = { 0, 0, 1,1 };
LLVMValueRef w_w_h_h = lp_build_swizzle_aos_n(gallivm, float_size,
swizzle0011, ARRAY_SIZE(swizzle0011), 0, full_length_vec.length);
LLVMValueRef dsdx_dsdy_dtdx_dtdy;
if (derivs) {
@ -569,27 +569,28 @@ lp_build_rho_aniso(struct lp_build_sample_context *bld,
0, 1, 2,3,
};
dsdx_dsdy_dtdx_dtdy = lp_build_swizzle_aos_n(gallivm, dsdx_dsdy_dtdx_dtdy,
broadcast4, ARRAY_SIZE(broadcast4), full_length_vec.length);
broadcast4, ARRAY_SIZE(broadcast4), 4, full_length_vec.length);
}
}
dsdx_dsdy_dtdx_dtdy = lp_build_mul(&full_length_bld, dsdx_dsdy_dtdx_dtdy, width_height);
dsdx_dsdy_dtdx_dtdy = lp_build_mul(&full_length_bld, dsdx_dsdy_dtdx_dtdy, w_w_h_h);
LLVMValueRef ds2dx_ds2dy_dt2dx_dt2dy = lp_apply_ellipse_transform(&full_length_bld, dsdx_dsdy_dtdx_dtdy);
static const unsigned char swizzle01[] = { 0, 1 };
static const unsigned char swizzle23[] = { 2, 3 };
LLVMValueRef ds2dx_ds2dy = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle01, ARRAY_SIZE(swizzle01), half_length_vec.length);
swizzle01, ARRAY_SIZE(swizzle01), 4, half_length_vec.length);
LLVMValueRef dt2dx_dt2dy = lp_build_swizzle_aos_n(gallivm, ds2dx_ds2dy_dt2dx_dt2dy,
swizzle23, ARRAY_SIZE(swizzle23), half_length_vec.length);
swizzle23, ARRAY_SIZE(swizzle23), 4, half_length_vec.length);
LLVMValueRef rho_x2_rho_y2 = lp_build_add(&half_length_bld, ds2dx_ds2dy, dt2dx_dt2dy);
static const unsigned char swizzle0[] = { 0 };
static const unsigned char swizzle1[] = { 1 };
LLVMValueRef rho_x2 = lp_build_swizzle_aos_n(gallivm, rho_x2_rho_y2,
swizzle0, ARRAY_SIZE(swizzle0), quarter_length_vec.length);
swizzle0, ARRAY_SIZE(swizzle0), 2, quarter_length_vec.length);
LLVMValueRef rho_y2 = lp_build_swizzle_aos_n(gallivm, rho_x2_rho_y2,
swizzle1, ARRAY_SIZE(swizzle1), quarter_length_vec.length);
swizzle1, ARRAY_SIZE(swizzle1), 2, quarter_length_vec.length);
LLVMValueRef rho_max2 = lp_build_max(&quarter_length_bld, rho_x2, rho_y2);
LLVMValueRef rho_min2 = lp_build_min(&quarter_length_bld, rho_x2, rho_y2);

26
src/gallium/auxiliary/gallivm/lp_bld_swizzle.c
View file

@ -304,9 +304,16 @@ lp_build_swizzle_scalar_aos(struct lp_build_context *bld,
* Swizzle a vector consisting of an array of XYZW structs.
*
* This fills a vector of dst_len length with the swizzled channels from src.
* Swizzle values are repeated as many times as necessary to fill the dst_len.
* The "stride" value is used to increment a base index every time the list of
* swizzle repeats. Once its value equals or exceeds the source length, all
* further values are "undef".
*
* e.g. with swizzles = { 2, 1, 0 } and swizzle_count = 6 results in
* RGBA RGBA = BGR BGR BG
* e.g. with swizzles = { 2, 1, 0 }, stride = 0, dst_len = 6 results in
* R1G1B1A1 R2G2B2A2 = B1G1R1 B1G1R1 B1G1
*
* e.g. with swizzles = { 2, 1, 0 }, stride = 4, dst_len = 6 results in
* R1G1B1A1 R2G2B2A2 = B1G1R1 B2G2R2 undef undef
*
* @param swizzles the swizzle array
* @param num_swizzles the number of elements in swizzles
@ -317,6 +324,7 @@ lp_build_swizzle_aos_n(struct gallivm_state* gallivm,
LLVMValueRef src,
const unsigned char* swizzles,
unsigned num_swizzles,
unsigned stride,
unsigned dst_len)
{
LLVMBuilderRef builder = gallivm->builder;
@ -329,8 +337,20 @@ lp_build_swizzle_aos_n(struct gallivm_state* gallivm,
lp_build_const_int32(gallivm, swizzles[0]), "");
}
const unsigned src_len = LLVMGetVectorSize(LLVMTypeOf(src));
unsigned base_index = 0;
for (unsigned i = 0; i < dst_len; ++i) {
int swizzle = swizzles[i % num_swizzles];
const unsigned local_index = i % num_swizzles;
unsigned swizzle = swizzles[local_index];
swizzle += base_index;
if (local_index + 1 == num_swizzles) {
base_index += stride;
}
if (swizzle >= src_len) {
swizzle = LP_BLD_SWIZZLE_DONTCARE;
}
if (swizzle == LP_BLD_SWIZZLE_DONTCARE) {
shuffles[i] = LLVMGetUndef(LLVMInt32TypeInContext(gallivm->context));

1
src/gallium/auxiliary/gallivm/lp_bld_swizzle.h
View file

@ -96,6 +96,7 @@ lp_build_swizzle_aos_n(struct gallivm_state* gallivm,
LLVMValueRef src,
const unsigned char* swizzles,
unsigned num_swizzles,
unsigned stride,
unsigned dst_len);

6
src/gallium/drivers/llvmpipe/lp_state_fs.c
View file

@ -1589,7 +1589,7 @@ generate_fs_twiddle(struct gallivm_state *gallivm,
for (unsigned i = 0; i < src_count; ++i) {
dst[i] = lp_build_swizzle_aos_n(gallivm, dst[i], swizzles,
type.length, type.length);
type.length, 0, type.length);
}
}
@ -2877,11 +2877,11 @@ generate_unswizzled_blend(struct gallivm_state *gallivm,
if (pad_inline) {
/* Use all 4 channels e.g. from RGBA RGBA to RGxx RGxx */
blend_color = lp_build_swizzle_aos_n(gallivm, blend_color, swizzle,
TGSI_NUM_CHANNELS, row_type.length);
TGSI_NUM_CHANNELS, 0, row_type.length);
} else {
/* Only use dst_channels e.g. RGBA RGBA to RG RG xxxx */
blend_color = lp_build_swizzle_aos_n(gallivm, blend_color, swizzle,
dst_channels, row_type.length);
dst_channels, 0, row_type.length);
}
/*