xf86-video-intel: 3 commits - src/i965_render.c
Eric Anholt
anholt at kemper.freedesktop.org
Fri Apr 11 14:11:54 PDT 2008
src/i965_render.c | 458 +++++++++++++++++++++++++++++++-----------------------
1 file changed, 267 insertions(+), 191 deletions(-)
New commits:
commit 03836067b77606c134c71b30c7078d09d77c95fa
Author: Eric Anholt <eric at anholt.net>
Date: Fri Apr 11 12:17:28 2008 -0700
Fix the offset to sampler default color, and a compiler warning.
diff --git a/src/i965_render.c b/src/i965_render.c
index 59af52f..efbfc49 100644
--- a/src/i965_render.c
+++ b/src/i965_render.c
@@ -283,7 +283,7 @@ static int binding_table_entries;
static int dest_surf_offset, src_surf_offset, mask_surf_offset;
static int vs_offset;
-static int sf_offset, cc_offset, vb_offset;
+static int sf_offset, vb_offset;
static int binding_table_offset;
static int next_offset, total_state_size;
static char *state_base;
@@ -668,10 +668,12 @@ gen4_state_init (gen4_state_t *state, uint32_t state_base_offset)
for (l = 0; l < SAMPLER_STATE_EXTEND_COUNT; l++) {
sampler_state_init (&state->sampler_state[i][j][k][l][0],
i, j,
+ state_base_offset +
offsetof (gen4_state_t,
sampler_default_color));
sampler_state_init (&state->sampler_state[i][j][k][l][1],
k, l,
+ state_base_offset +
offsetof (gen4_state_t,
sampler_default_color));
}
commit d3138d9ff0f821fb3adbd27684b0c22a8a910c3e
Author: Carl Worth <cworth at cworth.org>
Date: Tue Nov 13 12:37:13 2007 -0800
Enumerate all possible wm_state objects
We have a collection of wm_state objects for each ps kernel,
(one for each combination of src and mask extend and repeat
values).
Thanks to Dave Airlie for noticing an errant write through a
wild wm_state pointer in an early version of this commit.
(cherry picked from 7763706a93d3021907273f9b330750ba110e2fc3 commit)
This cherry-pick required more reformatting than most, due to the
projective texturing merge.
diff --git a/src/i965_render.c b/src/i965_render.c
index 672c433..59af52f 100644
--- a/src/i965_render.c
+++ b/src/i965_render.c
@@ -277,15 +277,13 @@ static struct brw_surface_state *mask_surf_state, mask_surf_state_local;
static struct brw_vs_unit_state *vs_state, vs_state_local;
static struct brw_sf_unit_state *sf_state, sf_state_local;
-static struct brw_wm_unit_state *wm_state, wm_state_local;
static uint32_t *binding_table;
static int binding_table_entries;
static int dest_surf_offset, src_surf_offset, mask_surf_offset;
static int vs_offset;
-static int sf_offset, wm_offset, cc_offset, vb_offset;
-static int wm_scratch_offset;
+static int sf_offset, cc_offset, vb_offset;
static int binding_table_offset;
static int next_offset, total_state_size;
static char *state_base;
@@ -420,6 +418,12 @@ static const uint32_t ps_kernel_masknoca_projective_static [][4] = {
#define KERNEL_DECL(template) \
uint32_t template [((sizeof (template ## _static) + 63) & ~63) / 16][4];
+#define WM_STATE_DECL(kernel) \
+ struct brw_wm_unit_state wm_state_ ## kernel[SAMPLER_STATE_FILTER_COUNT] \
+ [SAMPLER_STATE_EXTEND_COUNT] \
+ [SAMPLER_STATE_FILTER_COUNT] \
+ [SAMPLER_STATE_EXTEND_COUNT]
+
/* Many of the fields in the state structure must be aligned to a
* 64-byte boundary, (or a 32-byte boundary, but 64 is good enough for
* those too).
@@ -467,6 +471,17 @@ typedef struct _gen4_state {
KERNEL_DECL (ps_kernel_masknoca_affine);
KERNEL_DECL (ps_kernel_masknoca_projective);
+ uint8_t wm_scratch[128 * PS_MAX_THREADS];
+
+ WM_STATE_DECL (nomask_affine);
+ WM_STATE_DECL (nomask_projective);
+ WM_STATE_DECL (maskca_affine);
+ WM_STATE_DECL (maskca_projective);
+ WM_STATE_DECL (maskca_srcalpha_affine);
+ WM_STATE_DECL (maskca_srcalpha_projective);
+ WM_STATE_DECL (masknoca_affine);
+ WM_STATE_DECL (masknoca_projective);
+
/* Index by [src_filter][src_extend][mask_filter][mask_extend] */
struct brw_sampler_state sampler_state[SAMPLER_STATE_FILTER_COUNT]
[SAMPLER_STATE_EXTEND_COUNT]
@@ -564,6 +579,55 @@ cc_state_init (struct brw_cc_unit_state *cc_state,
cc_state->cc6.dest_blend_factor = dst_blend;
}
+static void
+wm_state_init (struct brw_wm_unit_state *wm_state,
+ Bool has_mask,
+ int scratch_offset,
+ int kernel_offset,
+ int sampler_state_offset)
+{
+ memset(wm_state, 0, sizeof (*wm_state));
+ wm_state->thread0.grf_reg_count = BRW_GRF_BLOCKS(PS_KERNEL_NUM_GRF);
+ wm_state->thread1.single_program_flow = 0;
+
+ assert((scratch_offset & 1023) == 0);
+ wm_state->thread2.scratch_space_base_pointer = scratch_offset >> 10;
+
+ wm_state->thread2.per_thread_scratch_space = PS_SCRATCH_SPACE_LOG;
+ wm_state->thread3.const_urb_entry_read_length = 0;
+ wm_state->thread3.const_urb_entry_read_offset = 0;
+
+ wm_state->thread3.urb_entry_read_offset = 0;
+ /* wm kernel use urb from 3, see wm_program in compiler module */
+ wm_state->thread3.dispatch_grf_start_reg = 3; /* must match kernel */
+
+ wm_state->wm4.stats_enable = 1; /* statistic */
+ assert((sampler_state_offset & 31) == 0);
+ wm_state->wm4.sampler_state_pointer = sampler_state_offset >> 5;
+ wm_state->wm4.sampler_count = 1; /* 1-4 samplers used */
+ wm_state->wm5.max_threads = PS_MAX_THREADS - 1;
+ wm_state->wm5.transposed_urb_read = 0;
+ wm_state->wm5.thread_dispatch_enable = 1;
+ /* just use 16-pixel dispatch (4 subspans), don't need to change kernel
+ * start point
+ */
+ wm_state->wm5.enable_16_pix = 1;
+ wm_state->wm5.enable_8_pix = 0;
+ wm_state->wm5.early_depth_test = 1;
+
+ assert((kernel_offset & 63) == 0);
+ wm_state->thread0.kernel_start_pointer = kernel_offset >> 6;
+
+ /* Each pair of attributes (src/mask coords) is two URB entries */
+ if (has_mask) {
+ wm_state->thread1.binding_table_entry_count = 3; /* 2 tex and fb */
+ wm_state->thread3.urb_entry_read_length = 4;
+ } else {
+ wm_state->thread1.binding_table_entry_count = 2; /* 1 tex and fb */
+ wm_state->thread3.urb_entry_read_length = 2;
+ }
+}
+
/**
* Called at EnterVT to fill in our state buffer with any static information.
*/
@@ -586,6 +650,7 @@ gen4_state_init (gen4_state_t *state, uint32_t state_base_offset)
KERNEL_COPY (ps_kernel_maskca_srcalpha_projective);
KERNEL_COPY (ps_kernel_masknoca_affine);
KERNEL_COPY (ps_kernel_masknoca_projective);
+#undef KERNEL_COPY
memset(&state->sampler_default_color, 0,
sizeof(state->sampler_default_color));
@@ -623,7 +688,34 @@ gen4_state_init (gen4_state_t *state, uint32_t state_base_offset)
}
}
-#undef KERNEL_COPY
+#define SETUP_WM_STATE(kernel, has_mask) \
+ wm_state_init(&state->wm_state_ ## kernel [i][j][k][l], \
+ has_mask, \
+ state_base_offset + offsetof(gen4_state_t, \
+ wm_scratch), \
+ state_base_offset + offsetof(gen4_state_t, \
+ ps_kernel_ ## kernel), \
+ state_base_offset + offsetof(gen4_state_t, \
+ sampler_state[i][j][k][l]));
+
+
+ for (i = 0; i < SAMPLER_STATE_FILTER_COUNT; i++) {
+ for (j = 0; j < SAMPLER_STATE_EXTEND_COUNT; j++) {
+ for (k = 0; k < SAMPLER_STATE_FILTER_COUNT; k++) {
+ for (l = 0; l < SAMPLER_STATE_EXTEND_COUNT; l++) {
+ SETUP_WM_STATE (nomask_affine, FALSE);
+ SETUP_WM_STATE (nomask_projective, FALSE);
+ SETUP_WM_STATE (maskca_affine, TRUE);
+ SETUP_WM_STATE (maskca_projective, TRUE);
+ SETUP_WM_STATE (maskca_srcalpha_affine, TRUE);
+ SETUP_WM_STATE (maskca_srcalpha_projective, TRUE);
+ SETUP_WM_STATE (masknoca_affine, TRUE);
+ SETUP_WM_STATE (masknoca_projective, TRUE);
+ }
+ }
+ }
+ }
+#undef SETUP_WM_STATE
}
static uint32_t
@@ -737,12 +829,6 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
sf_offset = ALIGN(next_offset, 32);
next_offset = sf_offset + sizeof(*sf_state);
- wm_offset = ALIGN(next_offset, 32);
- next_offset = wm_offset + sizeof(*wm_state);
-
- wm_scratch_offset = ALIGN(next_offset, 1024);
- next_offset = wm_scratch_offset + PS_SCRATCH_SPACE * PS_MAX_THREADS;
-
/* Align VB to native size of elements, for safety */
vb_offset = ALIGN(next_offset, 32);
next_offset = vb_offset + vb_size;
@@ -982,108 +1068,6 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
sf_state = (void *)(state_base + sf_offset);
memcpy (sf_state, &sf_state_local, sizeof (sf_state_local));
- /* Set up the PS kernel (dispatched by WM) */
- wm_state = &wm_state_local;
- memset(wm_state, 0, sizeof (*wm_state));
- if (pMask) {
- if (pMaskPicture->componentAlpha &&
- PICT_FORMAT_RGB(pMaskPicture->format))
- {
- if (i965_blend_op[op].src_alpha) {
- if (is_affine) {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_maskca_srcalpha_affine)) >> 6;
- } else {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_maskca_srcalpha_projective)) >> 6;
- }
- } else {
- if (is_affine) {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_maskca_affine)) >> 6;
- } else {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_maskca_projective)) >> 6;
- }
- }
- } else {
- if (is_affine) {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_masknoca_affine)) >> 6;
- } else {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_masknoca_projective)) >> 6;
- }
- }
- } else {
- if (is_affine) {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_nomask_affine)) >> 6;
- } else {
- wm_state->thread0.kernel_start_pointer =
- (state_base_offset +
- offsetof(gen4_state_t,
- ps_kernel_nomask_projective)) >> 6;
- }
- }
-
- wm_state->thread0.grf_reg_count = BRW_GRF_BLOCKS(PS_KERNEL_NUM_GRF);
- wm_state->thread1.single_program_flow = 0;
- if (!pMask)
- wm_state->thread1.binding_table_entry_count = 2; /* 1 tex and fb */
- else
- wm_state->thread1.binding_table_entry_count = 3; /* 2 tex and fb */
-
- wm_state->thread2.scratch_space_base_pointer = (state_base_offset +
- wm_scratch_offset)>>10;
- wm_state->thread2.per_thread_scratch_space = PS_SCRATCH_SPACE_LOG;
- wm_state->thread3.const_urb_entry_read_length = 0;
- wm_state->thread3.const_urb_entry_read_offset = 0;
- /* Each pair of attributes (src/mask coords) is one URB entry */
- if (pMask)
- wm_state->thread3.urb_entry_read_length = 4;
- else
- wm_state->thread3.urb_entry_read_length = 2;
- wm_state->thread3.urb_entry_read_offset = 0;
- /* wm kernel use urb from 3, see wm_program in compiler module */
- wm_state->thread3.dispatch_grf_start_reg = 3; /* must match kernel */
-
- wm_state->wm4.stats_enable = 1; /* statistic */
- wm_state->wm4.sampler_state_pointer = (state_base_offset +
- offsetof(gen4_state_t,
- sampler_state
- [src_filter]
- [src_extend]
- [mask_filter]
- [mask_extend][0])) >> 5;
- wm_state->wm4.sampler_count = 1; /* 1-4 samplers used */
- wm_state->wm5.max_threads = PS_MAX_THREADS - 1;
- wm_state->wm5.transposed_urb_read = 0;
- wm_state->wm5.thread_dispatch_enable = 1;
- /* just use 16-pixel dispatch (4 subspans), don't need to change kernel
- * start point
- */
- wm_state->wm5.enable_16_pix = 1;
- wm_state->wm5.enable_8_pix = 0;
- wm_state->wm5.early_depth_test = 1;
-
- wm_state = (void *)(state_base + wm_offset);
- memcpy (wm_state, &wm_state_local, sizeof (wm_state_local));
-
/* Begin the long sequence of commands needed to set up the 3D
* rendering pipe
*/
@@ -1166,7 +1150,49 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
OUT_BATCH(BRW_GS_DISABLE); /* disable GS, resulting in passthrough */
OUT_BATCH(BRW_CLIP_DISABLE); /* disable CLIP, resulting in passthrough */
OUT_BATCH(state_base_offset + sf_offset); /* 32 byte aligned */
- OUT_BATCH(state_base_offset + wm_offset); /* 32 byte aligned */
+
+ /* Shorthand for long array lookup */
+#define OUT_WM_KERNEL(kernel) do { \
+ uint32_t offset = state_base_offset + \
+ offsetof(gen4_state_t, \
+ wm_state_ ## kernel \
+ [src_filter] \
+ [src_extend] \
+ [mask_filter] \
+ [mask_extend]); \
+ assert((offset & 31) == 0); \
+ OUT_BATCH(offset); \
+} while (0)
+
+ if (pMask) {
+ if (pMaskPicture->componentAlpha &&
+ PICT_FORMAT_RGB(pMaskPicture->format))
+ {
+ if (i965_blend_op[op].src_alpha) {
+ if (is_affine)
+ OUT_WM_KERNEL(maskca_srcalpha_affine);
+ else
+ OUT_WM_KERNEL(maskca_srcalpha_projective);
+ } else {
+ if (is_affine)
+ OUT_WM_KERNEL(maskca_affine);
+ else
+ OUT_WM_KERNEL(maskca_projective);
+ }
+ } else {
+ if (is_affine)
+ OUT_WM_KERNEL(masknoca_affine);
+ else
+ OUT_WM_KERNEL(masknoca_projective);
+ }
+ } else {
+ if (is_affine)
+ OUT_WM_KERNEL(nomask_affine);
+ else
+ OUT_WM_KERNEL(nomask_projective);
+ }
+#undef OUT_WM_KERNEL
+
/* 64 byte aligned */
OUT_BATCH(state_base_offset +
offsetof(gen4_state_t, cc_state[src_blend][dst_blend]));
commit 2293a3677d1dcf294de6a8712bf0d2f65b50dcc3
Author: Carl Worth <cworth at cworth.org>
Date: Mon Nov 12 16:09:00 2007 -0800
Enumerate all possible src,mask sampler state pairs
This will eventually allow for the elimination of sampler state
updates while compositing---and initializing everything in the
initialization function.
(cherry picked from commit d0874697be8086cd64740c24698df8cd4d31c76f)
diff --git a/src/i965_render.c b/src/i965_render.c
index 1a3237b..672c433 100644
--- a/src/i965_render.c
+++ b/src/i965_render.c
@@ -274,8 +274,6 @@ static int urb_cs_start, urb_cs_size;
static struct brw_surface_state *dest_surf_state, dest_surf_state_local;
static struct brw_surface_state *src_surf_state, src_surf_state_local;
static struct brw_surface_state *mask_surf_state, mask_surf_state_local;
-static struct brw_sampler_state *src_sampler_state, src_sampler_state_local;
-static struct brw_sampler_state *mask_sampler_state, mask_sampler_state_local;
static struct brw_vs_unit_state *vs_state, vs_state_local;
static struct brw_sf_unit_state *sf_state, sf_state_local;
@@ -285,7 +283,7 @@ static uint32_t *binding_table;
static int binding_table_entries;
static int dest_surf_offset, src_surf_offset, mask_surf_offset;
-static int src_sampler_offset, mask_sampler_offset,vs_offset;
+static int vs_offset;
static int sf_offset, wm_offset, cc_offset, vb_offset;
static int wm_scratch_offset;
static int binding_table_offset;
@@ -429,6 +427,18 @@ static const uint32_t ps_kernel_masknoca_projective_static [][4] = {
#define PAD64_MULTI(previous, idx, factor) char previous ## _pad ## idx [(64 - (sizeof(struct previous) * (factor)) % 64) % 64]
#define PAD64(previous, idx) PAD64_MULTI(previous, idx, 1)
+typedef enum {
+ SAMPLER_STATE_FILTER_NEAREST,
+ SAMPLER_STATE_FILTER_BILINEAR,
+ SAMPLER_STATE_FILTER_COUNT
+} sampler_state_filter_t;
+
+typedef enum {
+ SAMPLER_STATE_EXTEND_NONE,
+ SAMPLER_STATE_EXTEND_REPEAT,
+ SAMPLER_STATE_EXTEND_COUNT
+} sampler_state_extend_t;
+
typedef struct _brw_cc_unit_state_padded {
struct brw_cc_unit_state state;
char pad[64 - sizeof (struct brw_cc_unit_state)];
@@ -457,6 +467,12 @@ typedef struct _gen4_state {
KERNEL_DECL (ps_kernel_masknoca_affine);
KERNEL_DECL (ps_kernel_masknoca_projective);
+ /* Index by [src_filter][src_extend][mask_filter][mask_extend] */
+ struct brw_sampler_state sampler_state[SAMPLER_STATE_FILTER_COUNT]
+ [SAMPLER_STATE_EXTEND_COUNT]
+ [SAMPLER_STATE_FILTER_COUNT]
+ [SAMPLER_STATE_EXTEND_COUNT][2];
+
struct brw_sampler_default_color sampler_default_color;
PAD64 (brw_sampler_default_color, 0);
@@ -470,6 +486,50 @@ typedef struct _gen4_state {
} gen4_state_t;
static void
+sampler_state_init (struct brw_sampler_state *sampler_state,
+ sampler_state_filter_t filter,
+ sampler_state_extend_t extend,
+ int default_color_offset)
+{
+ /* PS kernel use this sampler */
+ memset(sampler_state, 0, sizeof(*sampler_state));
+
+ sampler_state->ss0.lod_preclamp = 1; /* GL mode */
+ sampler_state->ss0.default_color_mode = 0; /* GL mode */
+
+ switch(filter) {
+ default:
+ case SAMPLER_STATE_FILTER_NEAREST:
+ sampler_state->ss0.min_filter = BRW_MAPFILTER_NEAREST;
+ sampler_state->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
+ break;
+ case SAMPLER_STATE_FILTER_BILINEAR:
+ sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
+ sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
+ break;
+ }
+
+ switch (extend) {
+ default:
+ case SAMPLER_STATE_EXTEND_NONE:
+ sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
+ sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
+ sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
+ break;
+ case SAMPLER_STATE_EXTEND_REPEAT:
+ sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_WRAP;
+ sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_WRAP;
+ sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
+ break;
+ }
+
+ assert((default_color_offset & 31) == 0);
+ sampler_state->ss2.default_color_pointer = default_color_offset >> 5;
+
+ sampler_state->ss3.chroma_key_enable = 0; /* disable chromakey */
+}
+
+static void
cc_state_init (struct brw_cc_unit_state *cc_state,
int src_blend,
int dst_blend,
@@ -510,7 +570,7 @@ cc_state_init (struct brw_cc_unit_state *cc_state,
static void
gen4_state_init (gen4_state_t *state, uint32_t state_base_offset)
{
- int i, j;
+ int i, j, k, l;
#define KERNEL_COPY(kernel) \
memcpy(state->kernel, kernel ## _static, sizeof(kernel ## _static))
@@ -537,6 +597,24 @@ gen4_state_init (gen4_state_t *state, uint32_t state_base_offset)
state->cc_viewport.min_depth = -1.e35;
state->cc_viewport.max_depth = 1.e35;
+ for (i = 0; i < SAMPLER_STATE_FILTER_COUNT; i++) {
+ for (j = 0; j < SAMPLER_STATE_EXTEND_COUNT; j++) {
+ for (k = 0; k < SAMPLER_STATE_FILTER_COUNT; k++) {
+ for (l = 0; l < SAMPLER_STATE_EXTEND_COUNT; l++) {
+ sampler_state_init (&state->sampler_state[i][j][k][l][0],
+ i, j,
+ offsetof (gen4_state_t,
+ sampler_default_color));
+ sampler_state_init (&state->sampler_state[i][j][k][l][1],
+ k, l,
+ offsetof (gen4_state_t,
+ sampler_default_color));
+ }
+ }
+ }
+ }
+
+
for (i = 0; i < BRW_BLENDFACTOR_COUNT; i++) {
for (j = 0; j < BRW_BLENDFACTOR_COUNT; j++) {
cc_state_init (&state->cc_state[i][j].state, i, j,
@@ -562,6 +640,32 @@ i965_get_card_format(PicturePtr pPict)
return i965_tex_formats[i].card_fmt;
}
+static sampler_state_filter_t
+sampler_state_filter_from_picture (int filter)
+{
+ switch (filter) {
+ case PictFilterNearest:
+ return SAMPLER_STATE_FILTER_NEAREST;
+ case PictFilterBilinear:
+ return SAMPLER_STATE_FILTER_BILINEAR;
+ default:
+ return -1;
+ }
+}
+
+static sampler_state_extend_t
+sampler_state_extend_from_picture (int repeat)
+{
+ switch (repeat) {
+ case RepeatNone:
+ return SAMPLER_STATE_EXTEND_NONE;
+ case RepeatNormal:
+ return SAMPLER_STATE_EXTEND_REPEAT;
+ default:
+ return -1;
+ }
+}
+
Bool
i965_prepare_composite(int op, PicturePtr pSrcPicture,
PicturePtr pMaskPicture, PicturePtr pDstPicture,
@@ -574,6 +678,8 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
mask_tiled = 0;
uint32_t dst_format, dst_offset, dst_pitch, dst_tile_format = 0,
dst_tiled = 0;
+ sampler_state_filter_t src_filter, mask_filter;
+ sampler_state_extend_t src_extend, mask_extend;
Bool is_affine_src, is_affine_mask, is_affine;
IntelEmitInvarientState(pScrn);
@@ -637,14 +743,6 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
wm_scratch_offset = ALIGN(next_offset, 1024);
next_offset = wm_scratch_offset + PS_SCRATCH_SPACE * PS_MAX_THREADS;
- /* for texture sampler */
- src_sampler_offset = ALIGN(next_offset, 32);
- next_offset = src_sampler_offset + sizeof(*src_sampler_state);
-
- if (pMask) {
- mask_sampler_offset = ALIGN(next_offset, 32);
- next_offset = mask_sampler_offset + sizeof(*mask_sampler_state);
- }
/* Align VB to native size of elements, for safety */
vb_offset = ALIGN(next_offset, 32);
next_offset = vb_offset + vb_size;
@@ -809,79 +907,24 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
if (pMask)
binding_table[2] = state_base_offset + mask_surf_offset;
- /* PS kernel use this sampler */
- src_sampler_state = &src_sampler_state_local;
- memset(src_sampler_state, 0, sizeof(*src_sampler_state));
- src_sampler_state->ss0.lod_preclamp = 1; /* GL mode */
- switch(pSrcPicture->filter) {
- case PictFilterNearest:
- src_sampler_state->ss0.min_filter = BRW_MAPFILTER_NEAREST;
- src_sampler_state->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
- break;
- case PictFilterBilinear:
- src_sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
- src_sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
- break;
- default:
- I830FALLBACK("Bad filter 0x%x\n", pSrcPicture->filter);
- }
- src_sampler_state->ss0.default_color_mode = 0; /* GL mode */
-
- if (!pSrcPicture->repeat) {
- src_sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
- src_sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
- src_sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_CLAMP_BORDER;
- src_sampler_state->ss2.default_color_pointer =
- (state_base_offset +
- offsetof(gen4_state_t, sampler_default_color)) >> 5;
+ src_filter = sampler_state_filter_from_picture (pSrcPicture->filter);
+ if (src_filter < 0)
+ I830FALLBACK ("Bad src filter 0x%x\n", pSrcPicture->filter);
+ src_extend = sampler_state_extend_from_picture (pSrcPicture->repeat);
+ if (src_extend < 0)
+ I830FALLBACK ("Bad src repeat 0x%x\n", pSrcPicture->repeat);
+
+ if (pMaskPicture) {
+ mask_filter = sampler_state_filter_from_picture (pMaskPicture->filter);
+ if (mask_filter < 0)
+ I830FALLBACK ("Bad mask filter 0x%x\n", pMaskPicture->filter);
+ mask_extend = sampler_state_extend_from_picture (pMaskPicture->repeat);
+ if (mask_extend < 0)
+ I830FALLBACK ("Bad mask repeat 0x%x\n", pMaskPicture->repeat);
} else {
- src_sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- src_sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- src_sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- }
- src_sampler_state->ss3.chroma_key_enable = 0; /* disable chromakey */
-
- src_sampler_state = (void *)(state_base + src_sampler_offset);
- memcpy (src_sampler_state, &src_sampler_state_local, sizeof (src_sampler_state_local));
-
- if (pMask) {
- mask_sampler_state = &mask_sampler_state_local;
- memset(mask_sampler_state, 0, sizeof(*mask_sampler_state));
- mask_sampler_state->ss0.lod_preclamp = 1; /* GL mode */
- switch(pMaskPicture->filter) {
- case PictFilterNearest:
- mask_sampler_state->ss0.min_filter = BRW_MAPFILTER_NEAREST;
- mask_sampler_state->ss0.mag_filter = BRW_MAPFILTER_NEAREST;
- break;
- case PictFilterBilinear:
- mask_sampler_state->ss0.min_filter = BRW_MAPFILTER_LINEAR;
- mask_sampler_state->ss0.mag_filter = BRW_MAPFILTER_LINEAR;
- break;
- default:
- I830FALLBACK("Bad filter 0x%x\n", pMaskPicture->filter);
- }
-
- mask_sampler_state->ss0.default_color_mode = 0; /* GL mode */
- if (!pMaskPicture->repeat) {
- mask_sampler_state->ss1.r_wrap_mode =
- BRW_TEXCOORDMODE_CLAMP_BORDER;
- mask_sampler_state->ss1.s_wrap_mode =
- BRW_TEXCOORDMODE_CLAMP_BORDER;
- mask_sampler_state->ss1.t_wrap_mode =
- BRW_TEXCOORDMODE_CLAMP_BORDER;
- mask_sampler_state->ss2.default_color_pointer =
- (state_base_offset +
- offsetof(gen4_state_t, sampler_default_color)) >> 5;
- } else {
- mask_sampler_state->ss1.r_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- mask_sampler_state->ss1.s_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- mask_sampler_state->ss1.t_wrap_mode = BRW_TEXCOORDMODE_WRAP;
- }
- mask_sampler_state->ss3.chroma_key_enable = 0; /* disable chromakey */
-
- mask_sampler_state = (void *)(state_base + mask_sampler_offset);
- memcpy (mask_sampler_state, &mask_sampler_state_local, sizeof (mask_sampler_state_local));
+ mask_filter = SAMPLER_STATE_FILTER_NEAREST;
+ mask_extend = SAMPLER_STATE_EXTEND_NONE;
}
/* Set up the vertex shader to be disabled (passthrough) */
@@ -1021,7 +1064,12 @@ i965_prepare_composite(int op, PicturePtr pSrcPicture,
wm_state->wm4.stats_enable = 1; /* statistic */
wm_state->wm4.sampler_state_pointer = (state_base_offset +
- src_sampler_offset) >> 5;
+ offsetof(gen4_state_t,
+ sampler_state
+ [src_filter]
+ [src_extend]
+ [mask_filter]
+ [mask_extend][0])) >> 5;
wm_state->wm4.sampler_count = 1; /* 1-4 samplers used */
wm_state->wm5.max_threads = PS_MAX_THREADS - 1;
wm_state->wm5.transposed_urb_read = 0;
More information about the xorg-commit
mailing list