Now dead code.
Also had to remove the show_tiles/show_subtiles because now the color
buffers are always stored in their native format, so there is no longer
an easy way to paint the tile sizes.
Depth-stencil buffers are still swizzled.
Reviewed-by: Roland Scheidegger <sroland@vmware.com>
env = env.Clone()
-env.Append(CPPPATH = ['.'])
-
-env.CodeGenerate(
- target = 'lp_tile_soa.c',
- script = 'lp_tile_soa.py',
- source = ['#src/gallium/auxiliary/util/u_format.csv'],
- command = python_cmd + ' $SCRIPT $SOURCE > $TARGET'
-)
-
-# XXX: Our dependency scanner only finds depended modules in relative dirs.
-env.Depends('lp_tile_soa.c', [
- '#src/gallium/auxiliary/util/u_format_parse.py',
- '#src/gallium/auxiliary/util/u_format_pack.py',
-])
-
-
-lp_tile_soa_os = env.SharedObject('lp_tile_soa.c')
-
-
llvmpipe = env.ConvenienceLibrary(
target = 'llvmpipe',
source = [
'lp_tex_sample.c',
'lp_texture.c',
'lp_tile_image.c',
- lp_tile_soa_os,
])
env.Alias('llvmpipe', llvmpipe)
#define DEBUG_RAST 0x20
#define DEBUG_QUERY 0x40
#define DEBUG_SCREEN 0x80
-#define DEBUG_SHOW_TILES 0x200
-#define DEBUG_SHOW_SUBTILES 0x400
#define DEBUG_COUNTERS 0x800
#define DEBUG_SCENE 0x1000
#define DEBUG_FENCE 0x2000
#include "lp_query.h"
#include "lp_rast.h"
#include "lp_rast_priv.h"
-#include "lp_tile_soa.h"
#include "gallivm/lp_bld_debug.h"
#include "lp_scene.h"
#include "lp_tex_sample.h"
lp_scene_end_rasterization( rast->curr_scene );
rast->curr_scene = NULL;
-
-#ifdef DEBUG
- if (0)
- debug_printf("Post render scene: tile unswizzle: %u tile swizzle: %u\n",
- lp_tile_unswizzle_count, lp_tile_swizzle_count);
-#endif
}
uint8_t clear_color[4];
unsigned i;
- boolean gray;
for (i = 0; i < 4; ++i) {
clear_color[i] = float_to_ubyte(arg.clear_color[i]);
clear_color[2],
clear_color[3]);
- gray =
- clear_color[0] == clear_color[1] &&
- clear_color[1] == clear_color[2] &&
- clear_color[2] == clear_color[3];
-
for (i = 0; i < scene->fb.nr_cbufs; i++) {
- if (scene->cbufs[i].unswizzled) {
- const struct lp_scene *scene = task->scene;
- union util_color uc;
-
- util_pack_color(arg.clear_color,
- scene->fb.cbufs[i]->format, &uc);
-
- util_fill_rect(scene->cbufs[i].map,
- scene->fb.cbufs[i]->format,
- scene->cbufs[i].stride,
- task->x,
- task->y,
- TILE_SIZE,
- TILE_SIZE,
- &uc);
- } else {
- const unsigned chunk = TILE_SIZE / 4;
- uint8_t *ptr;
- unsigned j;
-
- ptr = lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
-
- if (gray) {
- /* clear to grayscale value {x, x, x, x} */
-
- memset(ptr, clear_color[0], TILE_SIZE * TILE_SIZE * 4);
- } else {
- /* Non-gray color.
- * Note: if the swizzled tile layout changes (see TILE_PIXEL) this code
- * will need to change. It'll be pretty obvious when clearing no longer
- * works.
- */
-
- for (j = 0; j < 4 * TILE_SIZE; j++) {
- memset(ptr, clear_color[0], chunk);
- ptr += chunk;
- memset(ptr, clear_color[1], chunk);
- ptr += chunk;
- memset(ptr, clear_color[2], chunk);
- ptr += chunk;
- memset(ptr, clear_color[3], chunk);
- ptr += chunk;
- }
- }
- }
+ const struct lp_scene *scene = task->scene;
+ union util_color uc;
+
+ util_pack_color(arg.clear_color,
+ scene->fb.cbufs[i]->format, &uc);
+
+ util_fill_rect(scene->cbufs[i].map,
+ scene->fb.cbufs[i]->format,
+ scene->cbufs[i].stride,
+ task->x,
+ task->y,
+ TILE_SIZE,
+ TILE_SIZE,
+ &uc);
}
LP_COUNT(nr_color_tile_clear);
-/**
- * Convert the color tile from tiled to linear layout.
- * This is generally only done when we're flushing the scene just prior to
- * SwapBuffers. If we didn't do this here, we'd have to convert the entire
- * tiled color buffer to linear layout in the llvmpipe_texture_unmap()
- * function. It's better to do it here to take advantage of
- * threading/parallelism.
- * This is a bin command which is stored in all bins.
- */
-static void
-lp_rast_store_linear_color( struct lp_rasterizer_task *task )
-{
- const struct lp_scene *scene = task->scene;
- unsigned buf;
-
- for (buf = 0; buf < scene->fb.nr_cbufs; buf++) {
- struct pipe_surface *cbuf = scene->fb.cbufs[buf];
- const unsigned layer = cbuf->u.tex.first_layer;
- const unsigned level = cbuf->u.tex.level;
- struct llvmpipe_resource *lpt = llvmpipe_resource(cbuf->texture);
-
- if (scene->cbufs[buf].unswizzled || !task->color_tiles[buf])
- continue;
-
- llvmpipe_unswizzle_cbuf_tile(lpt,
- layer,
- level,
- task->x, task->y,
- task->color_tiles[buf]);
- }
-}
-
-
-
/**
* Run the shader on all blocks in a tile. This is used when a tile is
* completely contained inside a triangle.
for (i = 0; i < scene->fb.nr_cbufs; i++){
stride[i] = scene->cbufs[i].stride;
- if (scene->cbufs[i].unswizzled) {
- color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y);
- } else {
- color[i] = lp_rast_get_color_block_pointer(task, i, tile_x + x, tile_y + y);
- }
+ color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, tile_x + x, tile_y + y);
}
/* depth buffer */
lp_rast_shade_tile_opaque(struct lp_rasterizer_task *task,
const union lp_rast_cmd_arg arg)
{
- const struct lp_scene *scene = task->scene;
- unsigned i;
-
LP_DBG(DEBUG_RAST, "%s\n", __FUNCTION__);
assert(task->state);
return;
}
- /* this will prevent converting the layout from tiled to linear */
- for (i = 0; i < scene->fb.nr_cbufs; i++) {
- if (!scene->cbufs[i].unswizzled) {
- (void)lp_rast_get_color_tile_pointer(task, i, LP_TEX_USAGE_WRITE_ALL);
- }
- }
-
lp_rast_shade_tile(task, arg);
}
for (i = 0; i < scene->fb.nr_cbufs; i++) {
stride[i] = scene->cbufs[i].stride;
- if (scene->cbufs[i].unswizzled) {
- color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
- } else {
- color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
- }
+ color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
}
/* depth buffer */
-/**
- * Set top row and left column of the tile's pixels to white. For debugging.
- */
-static void
-outline_tile(uint8_t *tile)
-{
- const uint8_t val = 0xff;
- unsigned i;
-
- for (i = 0; i < TILE_SIZE; i++) {
- TILE_PIXEL(tile, i, 0, 0) = val;
- TILE_PIXEL(tile, i, 0, 1) = val;
- TILE_PIXEL(tile, i, 0, 2) = val;
- TILE_PIXEL(tile, i, 0, 3) = val;
-
- TILE_PIXEL(tile, 0, i, 0) = val;
- TILE_PIXEL(tile, 0, i, 1) = val;
- TILE_PIXEL(tile, 0, i, 2) = val;
- TILE_PIXEL(tile, 0, i, 3) = val;
- }
-}
-
-
-/**
- * Draw grid of gray lines at 16-pixel intervals across the tile to
- * show the sub-tile boundaries. For debugging.
- */
-static void
-outline_subtiles(uint8_t *tile)
-{
- const uint8_t val = 0x80;
- const unsigned step = 16;
- unsigned i, j;
-
- for (i = 0; i < TILE_SIZE; i += step) {
- for (j = 0; j < TILE_SIZE; j++) {
- TILE_PIXEL(tile, i, j, 0) = val;
- TILE_PIXEL(tile, i, j, 1) = val;
- TILE_PIXEL(tile, i, j, 2) = val;
- TILE_PIXEL(tile, i, j, 3) = val;
-
- TILE_PIXEL(tile, j, i, 0) = val;
- TILE_PIXEL(tile, j, i, 1) = val;
- TILE_PIXEL(tile, j, i, 2) = val;
- TILE_PIXEL(tile, j, i, 3) = val;
- }
- }
-
- outline_tile(tile);
-}
-
-
-
/**
* Called when we're done writing to a color tile.
*/
static void
lp_rast_tile_end(struct lp_rasterizer_task *task)
{
-#ifdef DEBUG
- if (LP_DEBUG & (DEBUG_SHOW_SUBTILES | DEBUG_SHOW_TILES)) {
- const struct lp_scene *scene = task->scene;
- unsigned buf;
-
- for (buf = 0; buf < scene->fb.nr_cbufs; buf++) {
- uint8_t *color = lp_rast_get_color_block_pointer(task, buf,
- task->x, task->y);
-
- if (LP_DEBUG & DEBUG_SHOW_SUBTILES)
- outline_subtiles(color);
- else if (LP_DEBUG & DEBUG_SHOW_TILES)
- outline_tile(color);
- }
- }
-#else
- (void) outline_subtiles;
-#endif
-
- lp_rast_store_linear_color(task);
-
if (task->query) {
union lp_rast_cmd_arg dummy = {0};
lp_rast_end_query(task, dummy);
#include "lp_scene.h"
#include "lp_state.h"
#include "lp_texture.h"
-#include "lp_tile_soa.h"
+#include "lp_tile_image.h"
#include "lp_limits.h"
}
-/**
- * Get pointer to the swizzled color tile
- */
-static INLINE uint8_t *
-lp_rast_get_color_tile_pointer(struct lp_rasterizer_task *task,
- unsigned buf, enum lp_texture_usage usage)
-{
- const struct lp_scene *scene = task->scene;
-
- assert(task->x < scene->tiles_x * TILE_SIZE);
- assert(task->y < scene->tiles_y * TILE_SIZE);
- assert(task->x % TILE_SIZE == 0);
- assert(task->y % TILE_SIZE == 0);
- assert(buf < scene->fb.nr_cbufs);
- assert(scene->cbufs[buf].unswizzled == 0);
-
- if (!task->color_tiles[buf]) {
- struct pipe_surface *cbuf = scene->fb.cbufs[buf];
- struct llvmpipe_resource *lpt;
- assert(cbuf);
- lpt = llvmpipe_resource(cbuf->texture);
- task->color_tiles[buf] = lp_swizzled_cbuf[task->thread_index][buf];
-
- if (usage != LP_TEX_USAGE_WRITE_ALL) {
- llvmpipe_swizzle_cbuf_tile(lpt,
- cbuf->u.tex.first_layer,
- cbuf->u.tex.level,
- task->x, task->y,
- task->color_tiles[buf]);
- }
- }
-
- return task->color_tiles[buf];
-}
-
-
/**
* Get pointer to the unswizzled color tile
*/
assert(task->x % TILE_SIZE == 0);
assert(task->y % TILE_SIZE == 0);
assert(buf < scene->fb.nr_cbufs);
- assert(scene->cbufs[buf].unswizzled);
if (!task->color_tiles[buf]) {
struct pipe_surface *cbuf = scene->fb.cbufs[buf];
}
-/**
- * Get the pointer to a 4x4 color block (within a 64x64 tile).
- * We'll map the color buffer on demand here.
- * Note that this may be called even when there's no color buffers - return
- * NULL in that case.
- * \param x, y location of 4x4 block in window coords
- */
-static INLINE uint8_t *
-lp_rast_get_color_block_pointer(struct lp_rasterizer_task *task,
- unsigned buf, unsigned x, unsigned y)
-{
- unsigned px, py, pixel_offset;
- uint8_t *color;
-
- assert(x < task->scene->tiles_x * TILE_SIZE);
- assert(y < task->scene->tiles_y * TILE_SIZE);
- assert((x % TILE_VECTOR_WIDTH) == 0);
- assert((y % TILE_VECTOR_HEIGHT) == 0);
- assert(buf < task->scene->fb.nr_cbufs);
- assert(task->scene->cbufs[buf].unswizzled == 0);
-
- color = lp_rast_get_color_tile_pointer(task, buf, LP_TEX_USAGE_READ_WRITE);
- assert(color);
-
- px = x % TILE_SIZE;
- py = y % TILE_SIZE;
- pixel_offset = tile_pixel_offset(px, py, 0);
-
- color = color + pixel_offset;
-
- assert(lp_check_alignment(color, 16));
- return color;
-}
-
-
/**
* Get the pointer to an unswizzled 4x4 color block (within an unswizzled 64x64 tile).
* \param x, y location of 4x4 block in window coords
assert((x % TILE_VECTOR_WIDTH) == 0);
assert((y % TILE_VECTOR_HEIGHT) == 0);
assert(buf < task->scene->fb.nr_cbufs);
- assert(task->scene->cbufs[buf].unswizzled);
format_bytes = util_format_description(task->scene->fb.cbufs[buf]->format)->block.bits / 8;
for (i = 0; i < scene->fb.nr_cbufs; i++) {
stride[i] = scene->cbufs[i].stride;
- if (scene->cbufs[i].unswizzled) {
- color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
- } else {
- color[i] = lp_rast_get_color_block_pointer(task, i, x, y);
- }
+ color[i] = lp_rast_get_unswizzled_color_block_pointer(task, i, x, y);
}
depth = lp_rast_get_depth_block_pointer(task, x, y);
#include "lp_debug.h"
#include "lp_perf.h"
#include "lp_rast_priv.h"
-#include "lp_tile_soa.h"
cbuf->u.tex.first_layer,
LP_TEX_USAGE_READ_WRITE,
LP_TEX_LAYOUT_LINEAR);
-
- scene->cbufs[i].unswizzled = llvmpipe_is_format_unswizzled(cbuf->format);
}
if (fb->zsbuf) {
#define LP_SCENE_H
#include "os/os_thread.h"
-#include "lp_tile_soa.h"
#include "lp_rast.h"
#include "lp_debug.h"
uint8_t *map;
unsigned stride;
unsigned blocksize;
- unsigned unswizzled;
} zsbuf, cbufs[PIPE_MAX_COLOR_BUFS];
/** the framebuffer to render the scene into */
{ "rast", DEBUG_RAST, NULL },
{ "query", DEBUG_QUERY, NULL },
{ "screen", DEBUG_SCREEN, NULL },
- { "show_tiles", DEBUG_SHOW_TILES, NULL },
- { "show_subtiles", DEBUG_SHOW_SUBTILES, NULL },
{ "counters", DEBUG_COUNTERS, NULL },
{ "scene", DEBUG_SCENE, NULL },
{ "fence", DEBUG_FENCE, NULL },
#include "lp_setup.h"
#include "lp_rast.h"
-#include "lp_tile_soa.h" /* for TILE_SIZE */
#include "lp_scene.h"
#include "lp_bld_interp.h" /* for struct lp_shader_input */
}
-/**
- * Generate color blending and color output.
- * \param rt the render target index (to index blend, colormask state)
- * \param type the pixel color type
- * \param context_ptr pointer to the runtime JIT context
- * \param mask execution mask (active fragment/pixel mask)
- * \param src colors from the fragment shader
- * \param dst_ptr the destination color buffer pointer
- */
-static void
-generate_blend(struct gallivm_state *gallivm,
- const struct pipe_blend_state *blend,
- unsigned rt,
- LLVMBuilderRef builder,
- struct lp_type type,
- LLVMValueRef context_ptr,
- LLVMValueRef mask,
- LLVMValueRef *src,
- LLVMValueRef dst_ptr,
- boolean do_branch)
-{
- struct lp_build_context bld;
- struct lp_build_mask_context mask_ctx;
- LLVMTypeRef vec_type;
- LLVMValueRef const_ptr;
- LLVMValueRef con[4];
- LLVMValueRef dst[4];
- LLVMValueRef res[4];
- unsigned chan;
-
- lp_build_context_init(&bld, gallivm, type);
-
- lp_build_mask_begin(&mask_ctx, gallivm, type, mask);
- if (do_branch)
- lp_build_mask_check(&mask_ctx);
-
- vec_type = lp_build_vec_type(gallivm, type);
-
- const_ptr = lp_jit_context_u8_blend_color(gallivm, context_ptr);
- const_ptr = LLVMBuildBitCast(builder, const_ptr,
- LLVMPointerType(vec_type, 0), "");
-
- /* load constant blend color and colors from the dest color buffer */
- for(chan = 0; chan < 4; ++chan) {
- LLVMValueRef index = lp_build_const_int32(gallivm, chan);
- con[chan] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, const_ptr, &index, 1, ""), "");
-
- dst[chan] = LLVMBuildLoad(builder, LLVMBuildGEP(builder, dst_ptr, &index, 1, ""), "");
-
- lp_build_name(con[chan], "con.%c", "rgba"[chan]);
- lp_build_name(dst[chan], "dst.%c", "rgba"[chan]);
- }
-
- /* do blend */
- lp_build_blend_soa(gallivm, blend, type, rt, src, dst, con, res);
-
- /* store results to color buffer */
- for(chan = 0; chan < 4; ++chan) {
- if(blend->rt[rt].colormask & (1 << chan)) {
- LLVMValueRef index = lp_build_const_int32(gallivm, chan);
- lp_build_name(res[chan], "res.%c", "rgba"[chan]);
- res[chan] = lp_build_select(&bld, mask, res[chan], dst[chan]);
- LLVMBuildStore(builder, res[chan], LLVMBuildGEP(builder, dst_ptr, &index, 1, ""));
- }
- }
-
- lp_build_mask_end(&mask_ctx);
-}
-
-
/**
* This function will reorder pixels from the fragment shader SoA to memory layout AoS
*
struct lp_build_interp_soa_context interp;
LLVMValueRef fs_mask[16 / 4];
LLVMValueRef fs_out_color[PIPE_MAX_COLOR_BUFS][TGSI_NUM_CHANNELS][16 / 4];
- LLVMValueRef blend_mask;
LLVMValueRef function;
LLVMValueRef facing;
const struct util_format_description *zs_format_desc;
*/
for(cbuf = 0; cbuf < key->nr_cbufs; cbuf++) {
LLVMValueRef color_ptr;
+ LLVMValueRef stride;
LLVMValueRef index = lp_build_const_int32(gallivm, cbuf);
- LLVMValueRef blend_in_color[TGSI_NUM_CHANNELS];
unsigned rt = key->blend.independent_blend_enable ? cbuf : 0;
boolean do_branch = ((key->depth.enabled
lp_build_name(color_ptr, "color_ptr%d", cbuf);
- if (variant->unswizzled_cbufs & (1 << cbuf)) {
- LLVMValueRef stride = LLVMBuildLoad(builder,
- LLVMBuildGEP(builder, stride_ptr, &index, 1, ""),
- "");
-
- generate_unswizzled_blend(gallivm, rt, variant, key->cbuf_format[cbuf],
- num_fs, fs_type, fs_mask, fs_out_color[cbuf],
- context_ptr, color_ptr, stride, partial_mask, do_branch);
- } else {
- /*
- * Convert the fs's output color and mask to fit to the blending type.
- */
- for(chan = 0; chan < TGSI_NUM_CHANNELS; ++chan) {
- LLVMValueRef fs_color_vals[LP_MAX_VECTOR_LENGTH];
-
- for (i = 0; i < num_fs; i++) {
- fs_color_vals[i] =
- LLVMBuildLoad(builder, fs_out_color[cbuf][chan][i], "fs_color_vals");
- }
-
- lp_build_conv(gallivm, fs_type, blend_type,
- fs_color_vals,
- num_fs,
- &blend_in_color[chan], 1);
-
- lp_build_name(blend_in_color[chan], "color%d.%c", cbuf, "rgba"[chan]);
- }
-
- if (partial_mask || !variant->opaque) {
- lp_build_conv_mask(gallivm, fs_type, blend_type,
- fs_mask, num_fs,
- &blend_mask, 1);
- } else {
- blend_mask = lp_build_const_int_vec(gallivm, blend_type, ~0);
- }
+ stride = LLVMBuildLoad(builder,
+ LLVMBuildGEP(builder, stride_ptr, &index, 1, ""),
+ "");
- generate_blend(gallivm,
- &key->blend,
- rt,
- builder,
- blend_type,
- context_ptr,
- blend_mask,
- blend_in_color,
- color_ptr,
- do_branch);
- }
+ generate_unswizzled_blend(gallivm, rt, variant, key->cbuf_format[cbuf],
+ num_fs, fs_type, fs_mask, fs_out_color[cbuf],
+ context_ptr, color_ptr, stride, partial_mask, do_branch);
}
LLVMBuildRetVoid(builder);
struct lp_fragment_shader_variant *variant;
const struct util_format_description *cbuf0_format_desc;
boolean fullcolormask;
- unsigned i;
variant = CALLOC_STRUCT(lp_fragment_shader_variant);
if(!variant)
!shader->info.base.uses_kill
? TRUE : FALSE;
- for (i = 0; i < key->nr_cbufs; ++i) {
- variant->unswizzled_cbufs |= llvmpipe_is_format_unswizzled(key->cbuf_format[i]) << i;
- }
-
if ((LP_DEBUG & DEBUG_FS) || (gallivm_debug & GALLIVM_DEBUG_IR)) {
lp_debug_fs_variant(variant);
}
lp_jit_frag_func jit_function[2];
- /* Bitmask to say what cbufs are unswizzled */
- unsigned unswizzled_cbufs;
-
/* Total number of LLVM instructions generated */
unsigned nr_instrs;
return lp_setup_is_resource_referenced(llvmpipe->setup, presource);
}
-boolean
-llvmpipe_is_format_unswizzled( enum pipe_format format )
-{
- const struct util_format_description *desc = util_format_description(format);
-
- if (desc->layout != UTIL_FORMAT_LAYOUT_PLAIN ||
- (desc->colorspace != UTIL_FORMAT_COLORSPACE_RGB &&
- desc->colorspace != UTIL_FORMAT_COLORSPACE_SRGB) ||
- desc->block.width != 1 ||
- desc->block.height != 1 ||
- desc->is_mixed ||
- (!desc->is_array && !desc->is_bitmask)) {
- assert(0);
- return FALSE;
- }
-
- return TRUE;
-}
-
/**
* Returns the largest possible alignment for a format in llvmpipe
}
-/**
- * Get pointer to tiled data for rendering.
- * \return pointer to the tiled data at the given tile position
- */
-void
-llvmpipe_unswizzle_cbuf_tile(struct llvmpipe_resource *lpr,
- unsigned face_slice, unsigned level,
- unsigned x, unsigned y,
- uint8_t *tile)
-{
- struct llvmpipe_texture_image *linear_img = &lpr->linear_img;
- const unsigned tx = x / TILE_SIZE, ty = y / TILE_SIZE;
- uint8_t *linear_image;
-
- assert(x % TILE_SIZE == 0);
- assert(y % TILE_SIZE == 0);
-
- if (!linear_img->data) {
- /* allocate memory for the linear image now */
- alloc_image_data(lpr, LP_TEX_LAYOUT_LINEAR);
- }
-
- /* compute address of the slice/face of the image that contains the tile */
- linear_image = llvmpipe_get_texture_image_address(lpr, face_slice, level,
- LP_TEX_LAYOUT_LINEAR);
-
- {
- uint ii = x, jj = y;
- uint tile_offset = jj / TILE_SIZE + ii / TILE_SIZE;
- uint byte_offset = tile_offset * TILE_SIZE * TILE_SIZE * 4;
-
- /* Note that lp_tiled_to_linear expects the tile parameter to
- * point at the first tile in a whole-image sized array. In
- * this code, we have only a single tile and have to do some
- * pointer arithmetic to figure out where the "image" would have
- * started.
- */
- lp_tiled_to_linear(tile - byte_offset, linear_image,
- x, y, TILE_SIZE, TILE_SIZE,
- lpr->base.format,
- lpr->row_stride[level],
- 1); /* tiles per row */
- }
-
- llvmpipe_set_texture_tile_layout(lpr, face_slice, level, tx, ty,
- LP_TEX_LAYOUT_LINEAR);
-}
-
-
-/**
- * Get pointer to tiled data for rendering.
- * \return pointer to the tiled data at the given tile position
- */
-void
-llvmpipe_swizzle_cbuf_tile(struct llvmpipe_resource *lpr,
- unsigned face_slice, unsigned level,
- unsigned x, unsigned y,
- uint8_t *tile)
-{
- uint8_t *linear_image;
-
- assert(x % TILE_SIZE == 0);
- assert(y % TILE_SIZE == 0);
-
- /* compute address of the slice/face of the image that contains the tile */
- linear_image = llvmpipe_get_texture_image_address(lpr, face_slice, level,
- LP_TEX_LAYOUT_LINEAR);
-
- if (linear_image) {
- uint ii = x, jj = y;
- uint tile_offset = jj / TILE_SIZE + ii / TILE_SIZE;
- uint byte_offset = tile_offset * TILE_SIZE * TILE_SIZE * 4;
-
- /* Note that lp_linear_to_tiled expects the tile parameter to
- * point at the first tile in a whole-image sized array. In
- * this code, we have only a single tile and have to do some
- * pointer arithmetic to figure out where the "image" would have
- * started.
- */
- lp_linear_to_tiled(linear_image, tile - byte_offset,
- x, y, TILE_SIZE, TILE_SIZE,
- lpr->base.format,
- lpr->row_stride[level],
- 1); /* tiles per row */
- }
-}
-
-
/**
* Return size of resource in bytes
*/
unsigned x, unsigned y);
-void
-llvmpipe_unswizzle_cbuf_tile(struct llvmpipe_resource *lpr,
- unsigned face_slice, unsigned level,
- unsigned x, unsigned y,
- uint8_t *tile);
-
-void
-llvmpipe_swizzle_cbuf_tile(struct llvmpipe_resource *lpr,
- unsigned face_slice, unsigned level,
- unsigned x, unsigned y,
- uint8_t *tile);
-
extern void
llvmpipe_print_resources(void);
struct pipe_resource *presource,
unsigned level, int layer);
-boolean
-llvmpipe_is_format_unswizzled(enum pipe_format format);
-
unsigned
llvmpipe_get_format_alignment(enum pipe_format format);
#include "util/u_format.h"
#include "util/u_memory.h"
-#include "lp_tile_soa.h"
+#include "lp_limits.h"
#include "lp_tile_image.h"
}
}
else {
- /* color image */
- const uint bpp = 4;
- const uint tile_w = TILE_SIZE, tile_h = TILE_SIZE;
- const uint bytes_per_tile = tile_w * tile_h * bpp;
- uint i, j;
-
assert(0);
-
- for (j = 0; j < height; j += tile_h) {
- for (i = 0; i < width; i += tile_w) {
- uint ii = i + x, jj = j + y;
- uint tile_offset = ((jj / tile_h) * tiles_per_row + ii / tile_w);
- uint byte_offset = tile_offset * bytes_per_tile;
- const uint8_t *src_tile = (uint8_t *) src + byte_offset;
-
- lp_tile_unswizzle_4ub(format,
- src_tile,
- dst, dst_stride,
- ii, jj);
- }
- }
}
}
}
}
else {
- const uint bpp = 4;
- const uint tile_w = TILE_SIZE, tile_h = TILE_SIZE;
- const uint bytes_per_tile = tile_w * tile_h * bpp;
- uint i, j;
-
assert(0);
-
- for (j = 0; j < height; j += TILE_SIZE) {
- for (i = 0; i < width; i += TILE_SIZE) {
- uint ii = i + x, jj = j + y;
- uint tile_offset = ((jj / tile_h) * tiles_per_row + ii / tile_w);
- uint byte_offset = tile_offset * bytes_per_tile;
- uint8_t *dst_tile = (uint8_t *) dst + byte_offset;
-
- lp_tile_swizzle_4ub(format,
- dst_tile,
- src, src_stride,
- ii, jj);
- }
- }
}
}
#define LP_TILE_IMAGE_H
+#define TILE_VECTOR_HEIGHT 4
+#define TILE_VECTOR_WIDTH 4
+
+
void
lp_tiled_to_linear(const void *src, void *dst,
unsigned x, unsigned y,
+++ /dev/null
-/**************************************************************************
- *
- * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-#ifndef LP_TILE_SOA_H
-#define LP_TILE_SOA_H
-
-#include "pipe/p_compiler.h"
-#include "tgsi/tgsi_exec.h" /* for TGSI_NUM_CHANNELS */
-#include "lp_limits.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-struct pipe_transfer;
-
-
-#define TILE_VECTOR_HEIGHT 4
-#define TILE_VECTOR_WIDTH 4
-
-extern const unsigned char
-tile_offset[TILE_VECTOR_HEIGHT][TILE_VECTOR_WIDTH];
-
-#define TILE_C_STRIDE (TILE_VECTOR_HEIGHT * TILE_VECTOR_WIDTH) //16
-#define TILE_X_STRIDE (TGSI_NUM_CHANNELS * TILE_C_STRIDE) //64
-#define TILE_Y_STRIDE (TILE_VECTOR_HEIGHT * TILE_SIZE * TGSI_NUM_CHANNELS) //1024
-
-
-#ifdef DEBUG
-extern unsigned lp_tile_unswizzle_count;
-extern unsigned lp_tile_swizzle_count;
-#endif
-
-
-/**
- * Return offset of the given pixel (and color channel) from the start
- * of a tile, in bytes.
- */
-static INLINE unsigned
-tile_pixel_offset(unsigned x, unsigned y, unsigned c)
-{
- unsigned ix = (x / TILE_VECTOR_WIDTH) * TILE_X_STRIDE;
- unsigned iy = (y / TILE_VECTOR_HEIGHT) * TILE_Y_STRIDE;
- unsigned offset = iy + ix + c * TILE_C_STRIDE +
- tile_offset[y % TILE_VECTOR_HEIGHT][x % TILE_VECTOR_WIDTH];
- return offset;
-}
-
-
-#define TILE_PIXEL(_p, _x, _y, _c) ((_p)[tile_pixel_offset(_x, _y, _c)])
-
-
-void
-lp_tile_swizzle_4ub(enum pipe_format format,
- uint8_t *dst,
- const void *src, unsigned src_stride,
- unsigned x, unsigned y);
-
-
-void
-lp_tile_unswizzle_4ub(enum pipe_format format,
- const uint8_t *src,
- void *dst, unsigned dst_stride,
- unsigned x, unsigned y);
-
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+++ /dev/null
-#!/usr/bin/env python
-
-CopyRight = '''
-/**************************************************************************
- *
- * Copyright 2009 VMware, Inc.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- **************************************************************************/
-
-/**
- * @file
- * Pixel format accessor functions.
- *
- * @author Jose Fonseca <jfonseca@vmware.com>
- */
-'''
-
-
-import sys
-import os.path
-
-sys.path.insert(0, os.path.join(os.path.dirname(sys.argv[0]), '../../auxiliary/util'))
-
-from u_format_pack import *
-
-
-def is_format_supported(format):
- '''Determines whether we actually have the plumbing necessary to generate the
- to read/write to/from this format.'''
-
- # FIXME: Ideally we would support any format combination here.
-
- if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT':
- return True;
-
- if format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT':
- return True;
-
- if format.layout != PLAIN:
- return False
-
- for i in range(4):
- channel = format.channels[i]
- if channel.type not in (VOID, UNSIGNED, SIGNED, FLOAT):
- return False
- if channel.type == FLOAT and channel.size not in (16, 32 ,64):
- return False
-
- if format.colorspace not in ('rgb', 'srgb'):
- return False
-
- return True
-
-
-def generate_format_read(format, dst_channel, dst_native_type, dst_suffix):
- '''Generate the function to read pixels from a particular format'''
-
- name = format.short_name()
-
- src_native_type = native_type(format)
-
- print 'static void'
- print 'lp_tile_%s_swizzle_%s(%s * restrict dst, const uint8_t * restrict src, unsigned src_stride, unsigned x0, unsigned y0)' % (name, dst_suffix, dst_native_type)
- print '{'
- print ' unsigned x, y;'
- print ' const uint8_t *src_row = src + y0*src_stride;'
- print ' for (y = 0; y < TILE_SIZE; ++y) {'
- print ' const %s *src_pixel = (const %s *)(src_row + x0*%u);' % (src_native_type, src_native_type, format.stride())
- print ' for (x = 0; x < TILE_SIZE; ++x) {'
-
- names = ['']*4
- if format.colorspace in ('rgb', 'srgb'):
- for i in range(4):
- swizzle = format.swizzles[i]
- if swizzle < 4:
- names[swizzle] += 'rgba'[i]
- elif format.colorspace == 'zs':
- swizzle = format.swizzles[0]
- if swizzle < 4:
- names[swizzle] = 'z'
- else:
- assert False
- else:
- assert False
-
- if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT':
- print ' float tmp[3];'
- print ' uint8_t r, g, b;'
- print ' r11g11b10f_to_float3(*src_pixel++, tmp);'
- for i in range(3):
- print ' %s = tmp[%d] * 0xff;' % (names[i], i)
- elif format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT':
- print ' float tmp[3];'
- print ' uint8_t r, g, b;'
- print ' rgb9e5_to_float3(*src_pixel++, tmp);'
- for i in range(3):
- print ' %s = tmp[%d] * 0xff;' % (names[i], i)
- elif format.layout == PLAIN:
- if not format.is_array():
- print ' %s pixel = *src_pixel++;' % src_native_type
- shift = 0;
- for i in range(4):
- src_channel = format.channels[i]
- width = src_channel.size
- if names[i]:
- value = 'pixel'
- mask = (1 << width) - 1
- if shift:
- value = '(%s >> %u)' % (value, shift)
- if shift + width < format.block_size():
- value = '(%s & 0x%x)' % (value, mask)
- value = conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=False)
- print ' %s %s = %s;' % (dst_native_type, names[i], value)
- shift += width
- else:
- for i in range(4):
- if names[i]:
- print ' %s %s;' % (dst_native_type, names[i])
- for i in range(4):
- src_channel = format.channels[i]
- if names[i]:
- value = '(*src_pixel++)'
- value = conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=False)
- print ' %s = %s;' % (names[i], value)
- elif src_channel.size:
- print ' ++src_pixel;'
- else:
- assert False
-
- for i in range(4):
- if format.colorspace in ('rgb', 'srgb'):
- swizzle = format.swizzles[i]
- if swizzle < 4:
- value = names[swizzle]
- elif swizzle == SWIZZLE_0:
- value = '0'
- elif swizzle == SWIZZLE_1:
- value = get_one(dst_channel)
- else:
- assert False
- elif format.colorspace == 'zs':
- if i < 3:
- value = 'z'
- else:
- value = get_one(dst_channel)
- else:
- assert False
- print ' TILE_PIXEL(dst, x, y, %u) = %s; /* %s */' % (i, value, 'rgba'[i])
-
- print ' }'
- print ' src_row += src_stride;'
- print ' }'
- print '}'
- print
-
-
-def pack_rgba(format, src_channel, r, g, b, a):
- """Return an expression for packing r, g, b, a into a pixel of the
- given format. Ex: '(b << 24) | (g << 16) | (r << 8) | (a << 0)'
- """
- assert format.colorspace in ('rgb', 'srgb')
- inv_swizzle = format.inv_swizzles()
- shift = 0
- expr = None
- for i in range(4):
- # choose r, g, b, or a depending on the inverse swizzle term
- if inv_swizzle[i] == 0:
- value = r
- elif inv_swizzle[i] == 1:
- value = g
- elif inv_swizzle[i] == 2:
- value = b
- elif inv_swizzle[i] == 3:
- value = a
- else:
- value = None
-
- if value:
- dst_channel = format.channels[i]
- dst_native_type = native_type(format)
- value = conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=False)
- term = "((%s) << %d)" % (value, shift)
- if expr:
- expr = expr + " | " + term
- else:
- expr = term
-
- width = format.channels[i].size
- shift = shift + width
- return expr
-
-
-def emit_unrolled_unswizzle_code(format, src_channel):
- '''Emit code for writing a block based on unrolled loops.
- This is considerably faster than the TILE_PIXEL-based code below.
- '''
- dst_native_type = 'uint%u_t' % format.block_size()
- print ' const unsigned dstpix_stride = dst_stride / %d;' % format.stride()
- print ' %s *dstpix = (%s *) dst;' % (dst_native_type, dst_native_type)
- print ' unsigned int qx, qy, i;'
- print
- print ' for (qy = 0; qy < TILE_SIZE; qy += TILE_VECTOR_HEIGHT) {'
- print ' const unsigned py = y0 + qy;'
- print ' for (qx = 0; qx < TILE_SIZE; qx += TILE_VECTOR_WIDTH) {'
- print ' const unsigned px = x0 + qx;'
- print ' const uint8_t *r = src + 0 * TILE_C_STRIDE;'
- print ' const uint8_t *g = src + 1 * TILE_C_STRIDE;'
- print ' const uint8_t *b = src + 2 * TILE_C_STRIDE;'
- print ' const uint8_t *a = src + 3 * TILE_C_STRIDE;'
- print ' (void) r; (void) g; (void) b; (void) a; /* silence warnings */'
- print ' for (i = 0; i < TILE_C_STRIDE; i += 2) {'
- print ' const uint32_t pixel0 = %s;' % pack_rgba(format, src_channel, "r[i+0]", "g[i+0]", "b[i+0]", "a[i+0]")
- print ' const uint32_t pixel1 = %s;' % pack_rgba(format, src_channel, "r[i+1]", "g[i+1]", "b[i+1]", "a[i+1]")
- print ' const unsigned offset = (py + tile_y_offset[i]) * dstpix_stride + (px + tile_x_offset[i]);'
- print ' dstpix[offset + 0] = pixel0;'
- print ' dstpix[offset + 1] = pixel1;'
- print ' }'
- print ' src += TILE_X_STRIDE;'
- print ' }'
- print ' }'
-
-
-def emit_tile_pixel_unswizzle_code(format, src_channel):
- '''Emit code for writing a block based on the TILE_PIXEL macro.'''
- dst_native_type = native_type(format)
-
- inv_swizzle = format.inv_swizzles()
-
- print ' unsigned x, y;'
- print ' uint8_t *dst_row = dst + y0*dst_stride;'
- print ' for (y = 0; y < TILE_SIZE; ++y) {'
- print ' %s *dst_pixel = (%s *)(dst_row + x0*%u);' % (dst_native_type, dst_native_type, format.stride())
- print ' for (x = 0; x < TILE_SIZE; ++x) {'
-
- if format.name == 'PIPE_FORMAT_R11G11B10_FLOAT':
- print ' float tmp[3];'
- for i in range(3):
- print ' tmp[%d] = ubyte_to_float(TILE_PIXEL(src, x, y, %u));' % (i, inv_swizzle[i])
- print ' *dst_pixel++ = float3_to_r11g11b10f(tmp);'
- elif format.name == 'PIPE_FORMAT_R9G9B9E5_FLOAT':
- print ' float tmp[3];'
- for i in range(3):
- print ' tmp[%d] = ubyte_to_float(TILE_PIXEL(src, x, y, %u));' % (i, inv_swizzle[i])
- print ' *dst_pixel++ = float3_to_rgb9e5(tmp);'
- elif format.layout == PLAIN:
- if not format.is_array():
- print ' %s pixel = 0;' % dst_native_type
- shift = 0;
- for i in range(4):
- dst_channel = format.channels[i]
- width = dst_channel.size
- if inv_swizzle[i] is not None:
- value = 'TILE_PIXEL(src, x, y, %u)' % inv_swizzle[i]
- value = conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=False)
- if shift:
- value = '(%s << %u)' % (value, shift)
- print ' pixel |= %s;' % value
- shift += width
- print ' *dst_pixel++ = pixel;'
- else:
- for i in range(4):
- dst_channel = format.channels[i]
- if inv_swizzle[i] is not None:
- value = 'TILE_PIXEL(src, x, y, %u)' % inv_swizzle[i]
- value = conversion_expr(src_channel, dst_channel, dst_native_type, value, clamp=False)
- print ' *dst_pixel++ = %s;' % value
- elif dst_channel.size:
- print ' ++dst_pixel;'
- else:
- assert False
-
- print ' }'
- print ' dst_row += dst_stride;'
- print ' }'
-
-
-def generate_format_write(format, src_channel, src_native_type, src_suffix):
- '''Generate the function to write pixels to a particular format'''
-
- name = format.short_name()
-
- print 'static void'
- print 'lp_tile_%s_unswizzle_%s(const %s * restrict src, uint8_t * restrict dst, unsigned dst_stride, unsigned x0, unsigned y0)' % (name, src_suffix, src_native_type)
- print '{'
- if format.layout == PLAIN \
- and format.colorspace == 'rgb' \
- and format.block_size() <= 32 \
- and format.is_pot() \
- and not format.is_mixed() \
- and (format.channels[0].type == UNSIGNED \
- or format.channels[1].type == UNSIGNED):
- emit_unrolled_unswizzle_code(format, src_channel)
- else:
- emit_tile_pixel_unswizzle_code(format, src_channel)
- print '}'
- print
-
-
-def generate_sse2():
- print '''
-#if defined(PIPE_ARCH_SSE)
-
-#include "util/u_sse.h"
-
-static ALWAYS_INLINE void
-swz4( const __m128i * restrict x,
- const __m128i * restrict y,
- const __m128i * restrict z,
- const __m128i * restrict w,
- __m128i * restrict a,
- __m128i * restrict b,
- __m128i * restrict c,
- __m128i * restrict d)
-{
- __m128i i, j, k, l;
- __m128i m, n, o, p;
- __m128i e, f, g, h;
-
- m = _mm_unpacklo_epi8(*x,*y);
- n = _mm_unpackhi_epi8(*x,*y);
- o = _mm_unpacklo_epi8(*z,*w);
- p = _mm_unpackhi_epi8(*z,*w);
-
- i = _mm_unpacklo_epi16(m,n);
- j = _mm_unpackhi_epi16(m,n);
- k = _mm_unpacklo_epi16(o,p);
- l = _mm_unpackhi_epi16(o,p);
-
- e = _mm_unpacklo_epi8(i,j);
- f = _mm_unpackhi_epi8(i,j);
- g = _mm_unpacklo_epi8(k,l);
- h = _mm_unpackhi_epi8(k,l);
-
- *a = _mm_unpacklo_epi64(e,g);
- *b = _mm_unpackhi_epi64(e,g);
- *c = _mm_unpacklo_epi64(f,h);
- *d = _mm_unpackhi_epi64(f,h);
-}
-
-static ALWAYS_INLINE void
-unswz4( const __m128i * restrict a,
- const __m128i * restrict b,
- const __m128i * restrict c,
- const __m128i * restrict d,
- __m128i * restrict x,
- __m128i * restrict y,
- __m128i * restrict z,
- __m128i * restrict w)
-{
- __m128i i, j, k, l;
- __m128i m, n, o, p;
-
- i = _mm_unpacklo_epi8(*a,*b);
- j = _mm_unpackhi_epi8(*a,*b);
- k = _mm_unpacklo_epi8(*c,*d);
- l = _mm_unpackhi_epi8(*c,*d);
-
- m = _mm_unpacklo_epi16(i,k);
- n = _mm_unpackhi_epi16(i,k);
- o = _mm_unpacklo_epi16(j,l);
- p = _mm_unpackhi_epi16(j,l);
-
- *x = _mm_unpacklo_epi64(m,n);
- *y = _mm_unpackhi_epi64(m,n);
- *z = _mm_unpacklo_epi64(o,p);
- *w = _mm_unpackhi_epi64(o,p);
-}
-
-static void
-lp_tile_b8g8r8a8_unorm_swizzle_4ub_sse2(uint8_t * restrict dst,
- const uint8_t * restrict src, unsigned src_stride,
- unsigned x0, unsigned y0)
-{
- __m128i *dst128 = (__m128i *) dst;
- unsigned x, y;
-
- src += y0 * src_stride;
- src += x0 * sizeof(uint32_t);
-
- for (y = 0; y < TILE_SIZE; y += 4) {
- const uint8_t *src_row = src;
-
- for (x = 0; x < TILE_SIZE; x += 4) {
- swz4((const __m128i *) (src_row + 0 * src_stride),
- (const __m128i *) (src_row + 1 * src_stride),
- (const __m128i *) (src_row + 2 * src_stride),
- (const __m128i *) (src_row + 3 * src_stride),
- dst128 + 2, /* b */
- dst128 + 1, /* g */
- dst128 + 0, /* r */
- dst128 + 3); /* a */
-
- dst128 += 4;
- src_row += sizeof(__m128i);
- }
-
- src += 4 * src_stride;
- }
-}
-
-static void
-lp_tile_b8g8r8a8_unorm_unswizzle_4ub_sse2(const uint8_t * restrict src,
- uint8_t * restrict dst, unsigned dst_stride,
- unsigned x0, unsigned y0)
-{
- unsigned int x, y;
- const __m128i *src128 = (const __m128i *) src;
-
- dst += y0 * dst_stride;
- dst += x0 * sizeof(uint32_t);
-
- for (y = 0; y < TILE_SIZE; y += 4) {
- const uint8_t *dst_row = dst;
-
- for (x = 0; x < TILE_SIZE; x += 4) {
- unswz4( &src128[2], /* b */
- &src128[1], /* g */
- &src128[0], /* r */
- &src128[3], /* a */
- (__m128i *) (dst_row + 0 * dst_stride),
- (__m128i *) (dst_row + 1 * dst_stride),
- (__m128i *) (dst_row + 2 * dst_stride),
- (__m128i *) (dst_row + 3 * dst_stride));
-
- src128 += 4;
- dst_row += sizeof(__m128i);;
- }
-
- dst += 4 * dst_stride;
- }
-}
-
-static void
-lp_tile_b8g8r8x8_unorm_swizzle_4ub_sse2(uint8_t * restrict dst,
- const uint8_t * restrict src, unsigned src_stride,
- unsigned x0, unsigned y0)
-{
- __m128i *dst128 = (__m128i *) dst;
- unsigned x, y;
-
- src += y0 * src_stride;
- src += x0 * sizeof(uint32_t);
-
- for (y = 0; y < TILE_SIZE; y += 4) {
- const uint8_t *src_row = src;
-
- for (x = 0; x < TILE_SIZE; x += 4) {
- swz4((const __m128i *) (src_row + 0 * src_stride),
- (const __m128i *) (src_row + 1 * src_stride),
- (const __m128i *) (src_row + 2 * src_stride),
- (const __m128i *) (src_row + 3 * src_stride),
- dst128 + 2, /* b */
- dst128 + 1, /* g */
- dst128 + 0, /* r */
- dst128 + 3); /* a */
-
- dst128 += 4;
- src_row += sizeof(__m128i);
- }
-
- src += 4 * src_stride;
- }
-}
-
-static void
-lp_tile_b8g8r8x8_unorm_unswizzle_4ub_sse2(const uint8_t * restrict src,
- uint8_t * restrict dst, unsigned dst_stride,
- unsigned x0, unsigned y0)
-{
- unsigned int x, y;
- const __m128i *src128 = (const __m128i *) src;
-
- dst += y0 * dst_stride;
- dst += x0 * sizeof(uint32_t);
-
- for (y = 0; y < TILE_SIZE; y += 4) {
- const uint8_t *dst_row = dst;
-
- for (x = 0; x < TILE_SIZE; x += 4) {
- unswz4( &src128[2], /* b */
- &src128[1], /* g */
- &src128[0], /* r */
- &src128[3], /* a */
- (__m128i *) (dst_row + 0 * dst_stride),
- (__m128i *) (dst_row + 1 * dst_stride),
- (__m128i *) (dst_row + 2 * dst_stride),
- (__m128i *) (dst_row + 3 * dst_stride));
-
- src128 += 4;
- dst_row += sizeof(__m128i);;
- }
-
- dst += 4 * dst_stride;
- }
-}
-
-#endif /* PIPE_ARCH_SSE */
-'''
-
-
-def generate_swizzle(formats, dst_channel, dst_native_type, dst_suffix):
- '''Generate the dispatch function to read pixels from any format'''
-
- for format in formats:
- if is_format_supported(format):
- generate_format_read(format, dst_channel, dst_native_type, dst_suffix)
-
- print 'void'
- print 'lp_tile_swizzle_%s(enum pipe_format format, %s *dst, const void *src, unsigned src_stride, unsigned x, unsigned y)' % (dst_suffix, dst_native_type)
- print '{'
- print ' void (*func)(%s * restrict dst, const uint8_t * restrict src, unsigned src_stride, unsigned x0, unsigned y0);' % dst_native_type
- print '#ifdef DEBUG'
- print ' lp_tile_swizzle_count += 1;'
- print '#endif'
- print ' switch(format) {'
- for format in formats:
- if is_format_supported(format):
- print ' case %s:' % format.name
- func_name = 'lp_tile_%s_swizzle_%s' % (format.short_name(), dst_suffix)
- if format.name == 'PIPE_FORMAT_B8G8R8A8_UNORM' or format.name == 'PIPE_FORMAT_B8G8R8X8_UNORM':
- print '#ifdef PIPE_ARCH_SSE'
- print ' func = util_cpu_caps.has_sse2 ? %s_sse2 : %s;' % (func_name, func_name)
- print '#else'
- print ' func = %s;' % (func_name,)
- print '#endif'
- else:
- print ' func = %s;' % (func_name,)
- print ' break;'
- print ' default:'
- print ' debug_printf("%s: unsupported format %s\\n", __FUNCTION__, util_format_name(format));'
- print ' return;'
- print ' }'
- print ' func(dst, (const uint8_t *)src, src_stride, x, y);'
- print '}'
- print
-
-
-def generate_unswizzle(formats, src_channel, src_native_type, src_suffix):
- '''Generate the dispatch function to write pixels to any format'''
-
- for format in formats:
- if is_format_supported(format):
- generate_format_write(format, src_channel, src_native_type, src_suffix)
-
- print 'void'
- print 'lp_tile_unswizzle_%s(enum pipe_format format, const %s *src, void *dst, unsigned dst_stride, unsigned x, unsigned y)' % (src_suffix, src_native_type)
-
- print '{'
- print ' void (*func)(const %s * restrict src, uint8_t * restrict dst, unsigned dst_stride, unsigned x0, unsigned y0);' % src_native_type
- print '#ifdef DEBUG'
- print ' lp_tile_unswizzle_count += 1;'
- print '#endif'
- print ' switch(format) {'
- for format in formats:
- if is_format_supported(format):
- print ' case %s:' % format.name
- func_name = 'lp_tile_%s_unswizzle_%s' % (format.short_name(), src_suffix)
- if format.name == 'PIPE_FORMAT_B8G8R8A8_UNORM' or format.name == 'PIPE_FORMAT_B8G8R8X8_UNORM':
- print '#ifdef PIPE_ARCH_SSE'
- print ' func = util_cpu_caps.has_sse2 ? %s_sse2 : %s;' % (func_name, func_name)
- print '#else'
- print ' func = %s;' % (func_name,)
- print '#endif'
- else:
- print ' func = %s;' % (func_name,)
- print ' break;'
- print ' default:'
- print ' debug_printf("%s: unsupported format %s\\n", __FUNCTION__, util_format_name(format));'
- print ' return;'
- print ' }'
- print ' func(src, (uint8_t *)dst, dst_stride, x, y);'
- print '}'
- print
-
-
-def main():
- formats = []
- for arg in sys.argv[1:]:
- formats.extend(parse(arg))
-
- print '/* This file is autogenerated by lp_tile_soa.py from u_format.csv. Do not edit directly. */'
- print
- # This will print the copyright message on the top of this file
- print CopyRight.strip()
- print
- print '#include "pipe/p_compiler.h"'
- print '#include "util/u_math.h"'
- print '#include "util/u_format.h"'
- print '#include "util/u_format_r11g11b10f.h"'
- print '#include "util/u_format_rgb9e5.h"'
- print '#include "util/u_half.h"'
- print '#include "util/u_cpu_detect.h"'
- print '#include "lp_tile_soa.h"'
- print
- print '#ifdef DEBUG'
- print 'unsigned lp_tile_unswizzle_count = 0;'
- print 'unsigned lp_tile_swizzle_count = 0;'
- print '#endif'
- print
- print 'const unsigned char'
- print 'tile_offset[TILE_VECTOR_HEIGHT][TILE_VECTOR_WIDTH] = {'
- print ' { 0, 1, 4, 5},'
- print ' { 2, 3, 6, 7},'
- print ' { 8, 9, 12, 13},'
- print ' { 10, 11, 14, 15}'
- print '};'
- print
- print '/* Note: these lookup tables could be replaced with some'
- print ' * bit-twiddling code, but this is a little faster.'
- print ' */'
- print 'static unsigned tile_x_offset[TILE_VECTOR_WIDTH * TILE_VECTOR_HEIGHT] = {'
- print ' 0, 1, 0, 1, 2, 3, 2, 3,'
- print ' 0, 1, 0, 1, 2, 3, 2, 3'
- print '};'
- print
- print 'static unsigned tile_y_offset[TILE_VECTOR_WIDTH * TILE_VECTOR_HEIGHT] = {'
- print ' 0, 0, 1, 1, 0, 0, 1, 1,'
- print ' 2, 2, 3, 3, 2, 2, 3, 3'
- print '};'
- print
-
- generate_sse2()
-
- channel = Channel(UNSIGNED, True, False, 8)
- native_type = 'uint8_t'
- suffix = '4ub'
-
- generate_swizzle(formats, channel, native_type, suffix)
- generate_unswizzle(formats, channel, native_type, suffix)
-
-
-if __name__ == '__main__':
- main()
projects / mesa.git / commitdiff