#include <stdint.h>
#include <stdlib.h>
+#include "util/format/u_format.h"
#include <util/macros.h>
#include "lima_format.h"
#define LIMA_PIXEL_FORMAT_B5G5R5A1 0x01
#define LIMA_PIXEL_FORMAT_B4G4R4A4 0x02
#define LIMA_PIXEL_FORMAT_B8G8R8A8 0x03
+#define LIMA_PIXEL_FORMAT_B8 0x04
+#define LIMA_PIXEL_FORMAT_G8B8 0x05
#define LIMA_PIXEL_FORMAT_Z16 0x0e
#define LIMA_PIXEL_FORMAT_Z24S8 0x0f
bool present;
int format;
bool swap_r_b;
- uint32_t channel_layout;
+ union {
+ uint32_t channel_layout;
+ uint8_t swizzle[4];
+ };
};
-#define LIMA_TEXEL_FORMAT(pipe, tex, swap) \
+#define SWIZ(x,y,z,w) { \
+ PIPE_SWIZZLE_##x, \
+ PIPE_SWIZZLE_##y, \
+ PIPE_SWIZZLE_##z, \
+ PIPE_SWIZZLE_##w \
+}
+
+#define LIMA_TEXEL_FORMAT(pipe, tex, swap, swiz) \
[PIPE_FORMAT_##pipe] = { \
.present = true, .format = LIMA_TEXEL_FORMAT_##tex, \
- .swap_r_b = swap \
+ .swap_r_b = swap, .swizzle = swiz \
}
#define LIMA_PIXEL_FORMAT(pipe, pix, swap, ch_layout) \
}
static const struct lima_format lima_texel_formats[] = {
- LIMA_TEXEL_FORMAT(R8G8B8A8_UNORM, RGBA_8888, true),
- LIMA_TEXEL_FORMAT(B8G8R8A8_UNORM, RGBA_8888, false),
- LIMA_TEXEL_FORMAT(R8G8B8A8_SRGB, RGBA_8888, true),
- LIMA_TEXEL_FORMAT(B8G8R8A8_SRGB, RGBA_8888, false),
- LIMA_TEXEL_FORMAT(R8G8B8X8_UNORM, RGBX_8888, true),
- LIMA_TEXEL_FORMAT(B8G8R8X8_UNORM, RGBX_8888, false),
- LIMA_TEXEL_FORMAT(B5G6R5_UNORM, BGR_565, false),
- LIMA_TEXEL_FORMAT(B5G5R5A1_UNORM, BGRA_5551, false),
- LIMA_TEXEL_FORMAT(B4G4R4A4_UNORM, BGRA_4444, false),
- LIMA_TEXEL_FORMAT(Z24_UNORM_S8_UINT, Z24X8, false),
- LIMA_TEXEL_FORMAT(Z24X8_UNORM, Z24X8, false),
- LIMA_TEXEL_FORMAT(L16_UNORM, L16, false),
- LIMA_TEXEL_FORMAT(L8_UNORM, L8, false),
- LIMA_TEXEL_FORMAT(A16_UNORM, A16, false),
- LIMA_TEXEL_FORMAT(A8_UNORM, A8, false),
- LIMA_TEXEL_FORMAT(I16_UNORM, I16, false),
- LIMA_TEXEL_FORMAT(I8_UNORM, I8, false),
- LIMA_TEXEL_FORMAT(L8A8_UNORM, L8A8, false),
- LIMA_TEXEL_FORMAT(ETC1_RGB8, ETC1_RGB8, false),
+ LIMA_TEXEL_FORMAT(R8G8B8A8_UNORM, RGBA_8888, true, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B8G8R8A8_UNORM, RGBA_8888, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(R8G8B8A8_SRGB, RGBA_8888, true, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B8G8R8A8_SRGB, RGBA_8888, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(R8G8B8X8_UNORM, RGBX_8888, true, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B8G8R8X8_UNORM, RGBX_8888, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B5G6R5_UNORM, BGR_565, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B5G5R5A1_UNORM, BGRA_5551, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(B4G4R4A4_UNORM, BGRA_4444, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(Z24_UNORM_S8_UINT, Z24X8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(Z24X8_UNORM, Z24X8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(L16_UNORM, L16, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(L8_UNORM, L8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(A16_UNORM, A16, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(A8_UNORM, A8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(I16_UNORM, I16, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(I8_UNORM, I8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(L8A8_UNORM, L8A8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(ETC1_RGB8, ETC1_RGB8, false, SWIZ(X, Y, Z, W)),
+ LIMA_TEXEL_FORMAT(R8_UNORM, L8, false, SWIZ(X, 0, 0, 1)),
+ LIMA_TEXEL_FORMAT(R8G8_UNORM, L8A8, false, SWIZ(X, W, 0, 1)),
};
static const struct lima_format lima_pixel_formats[] = {
LIMA_PIXEL_FORMAT(B5G6R5_UNORM, B5G6R5, false, 0x8565),
LIMA_PIXEL_FORMAT(B5G5R5A1_UNORM, B5G5R5A1, false, 0x8565),
LIMA_PIXEL_FORMAT(B4G4R4A4_UNORM, B4G4R4A4, false, 0x8444),
+ /* FIXME: reload doesn't work for these formats for some reason */
+ //LIMA_PIXEL_FORMAT(R8_UNORM, B8, true, 0x8888),
+ //LIMA_PIXEL_FORMAT(R8G8_UNORM, G8B8, true, 0x8888),
LIMA_PIXEL_FORMAT(Z24_UNORM_S8_UINT, Z24S8, false, 0x0000),
LIMA_PIXEL_FORMAT(Z24X8_UNORM, Z24S8, false, 0x0000),
};
return lima_pixel_formats[f].swap_r_b;
}
+const uint8_t *
+lima_format_get_texel_swizzle(enum pipe_format f)
+{
+ return lima_texel_formats[f].swizzle;
+}
+
uint32_t
lima_format_get_channel_layout(enum pipe_format f)
{
#include "lima_job.h"
#include "lima_program.h"
#include "lima_bo.h"
+#include "lima_format.h"
+
#include "ir/lima_ir.h"
static const nir_shader_compiler_options vs_nir_options = {
.lower_vector_cmp = true,
};
-static const struct nir_lower_tex_options tex_options = {
- .lower_txp = ~0u,
-};
-
const void *
lima_program_get_compiler_options(enum pipe_shader_type shader)
{
}
void
-lima_program_optimize_fs_nir(struct nir_shader *s)
+lima_program_optimize_fs_nir(struct nir_shader *s,
+ struct nir_lower_tex_options *tex_options)
{
bool progress;
NIR_PASS_V(s, nir_lower_fragcoord_wtrans);
NIR_PASS_V(s, nir_lower_io, nir_var_all, type_size, 0);
NIR_PASS_V(s, nir_lower_regs_to_ssa);
- NIR_PASS_V(s, nir_lower_tex, &tex_options);
+ NIR_PASS_V(s, nir_lower_tex, tex_options);
do {
progress = false;
nir_sweep(s);
}
+static bool
+lima_fs_compile_shader(struct lima_context *ctx,
+ struct lima_fs_shader_state *fs,
+ struct nir_lower_tex_options *tex_options)
+{
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ nir_shader *nir = nir_shader_clone(fs, fs->base.ir.nir);
+
+ lima_program_optimize_fs_nir(nir, tex_options);
+
+ if (lima_debug & LIMA_DEBUG_PP)
+ nir_print_shader(nir, stdout);
+
+ if (!ppir_compile_nir(fs, nir, screen->pp_ra, &ctx->debug)) {
+ ralloc_free(nir);
+ return false;
+ }
+
+ fs->uses_discard = nir->info.fs.uses_discard;
+ ralloc_free(nir);
+
+ return true;
+}
+
static void *
lima_create_fs_state(struct pipe_context *pctx,
const struct pipe_shader_state *cso)
{
struct lima_context *ctx = lima_context(pctx);
- struct lima_screen *screen = lima_screen(pctx->screen);
struct lima_fs_shader_state *so = rzalloc(NULL, struct lima_fs_shader_state);
if (!so)
nir_shader *nir;
if (cso->type == PIPE_SHADER_IR_NIR)
+ /* The backend takes ownership of the NIR shader on state
+ * creation.
+ */
nir = cso->ir.nir;
else {
assert(cso->type == PIPE_SHADER_IR_TGSI);
nir = tgsi_to_nir(cso->tokens, pctx->screen);
}
- lima_program_optimize_fs_nir(nir);
+ so->base.type = PIPE_SHADER_IR_NIR;
+ so->base.ir.nir = nir;
- if (lima_debug & LIMA_DEBUG_PP)
- nir_print_shader(nir, stdout);
+ uint8_t identity[4] = { PIPE_SWIZZLE_X,
+ PIPE_SWIZZLE_Y,
+ PIPE_SWIZZLE_Z,
+ PIPE_SWIZZLE_W };
+
+ struct nir_lower_tex_options tex_options = {
+ .lower_txp = ~0u,
+ .swizzle_result = 0,
+ };
- if (!ppir_compile_nir(so, nir, screen->pp_ra, &ctx->debug)) {
+ /* Initialize with identity swizzles. That should suffice for most shaders */
+ for (int i = 0; i < PIPE_MAX_SAMPLERS; i++)
+ memcpy(so->swizzles[i], identity, 4);
+
+ if (!lima_fs_compile_shader(ctx, so, &tex_options)) {
ralloc_free(so);
return NULL;
}
- so->uses_discard = nir->info.fs.uses_discard;
-
return so;
}
if (so->bo)
lima_bo_unreference(so->bo);
+ ralloc_free(so->base.ir.nir);
ralloc_free(so);
}
lima_update_fs_state(struct lima_context *ctx)
{
struct lima_fs_shader_state *fs = ctx->fs;
+ struct lima_texture_stateobj *lima_tex = &ctx->tex_stateobj;
+ struct nir_lower_tex_options tex_options = {
+ .lower_txp = ~0u,
+ .swizzle_result = 0,
+ };
+ bool needs_recompile = false;
+
+ /* Check if texture formats has changed since last compilation.
+ * If it has we need to recompile shader.
+ */
+ if (((ctx->dirty & LIMA_CONTEXT_DIRTY_TEXTURES) &&
+ lima_tex->num_samplers &&
+ lima_tex->num_textures)) {
+ uint8_t identity[4] = { PIPE_SWIZZLE_X,
+ PIPE_SWIZZLE_Y,
+ PIPE_SWIZZLE_Z,
+ PIPE_SWIZZLE_W };
+ for (int i = 0; i < lima_tex->num_samplers; i++) {
+ struct lima_sampler_view *texture = lima_sampler_view(lima_tex->textures[i]);
+ struct pipe_resource *prsc = texture->base.texture;
+ const uint8_t *swizzle = lima_format_get_texel_swizzle(prsc->format);
+ if (memcmp(fs->swizzles[i], swizzle, 4)) {
+ needs_recompile = true;
+ memcpy(fs->swizzles[i], swizzle, 4);
+ }
+
+ for (int j = 0; j < 4; j++)
+ tex_options.swizzles[i][j] = swizzle[j];
+
+ if (memcmp(swizzle, identity, 4))
+ tex_options.swizzle_result |= (1 << i);
+ }
+
+ /* Fill rest with identity swizzle */
+ for (int i = lima_tex->num_samplers; i < PIPE_MAX_SAMPLERS; i++)
+ memcpy(fs->swizzles[i], identity, 4);
+ }
+
+ if (needs_recompile) {
+ if (fs->bo) {
+ lima_bo_unreference(fs->bo);
+ fs->bo = NULL;
+ }
+
+ if (!lima_fs_compile_shader(ctx, fs, &tex_options))
+ return false;
+ }
+
if (!fs->bo) {
struct lima_screen *screen = lima_screen(ctx->base.screen);
fs->bo = lima_bo_create(screen, fs->shader_size, 0);
projects / mesa.git / commitdiff