sp_tile_cache.h File Reference

Include dependency graph for sp_tile_cache.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	softpipe_cached_tile
Defines
#define	TILE_CLEAR_OPTIMIZATION   1
#define	TILE_SIZE   64
	Cache tile size (width and height).
Functions
struct softpipe_tile_cache *	sp_create_tile_cache (struct pipe_screen *screen)
void	sp_destroy_tile_cache (struct softpipe_tile_cache *tc)
void	sp_tile_cache_set_surface (struct softpipe_tile_cache *tc, struct pipe_surface *sps)
	Specify the surface to cache.
struct pipe_surface *	sp_tile_cache_get_surface (struct softpipe_tile_cache *tc)
	Return the surface being cached.
void	sp_tile_cache_map_surfaces (struct softpipe_tile_cache *tc)
void	sp_tile_cache_unmap_surfaces (struct softpipe_tile_cache *tc)
void	sp_tile_cache_set_texture (struct pipe_context *pipe, struct softpipe_tile_cache *tc, struct pipe_texture *texture)
	Specify the texture to cache.
void	sp_flush_tile_cache (struct softpipe_context *softpipe, struct softpipe_tile_cache *tc)
	Flush the tile cache: write all dirty tiles back to the surface.
void	sp_tile_cache_clear (struct softpipe_tile_cache *tc, uint clearValue)
	When a whole surface is being cleared to a value we can avoid fetching tiles above.
struct softpipe_cached_tile *	sp_get_cached_tile (struct softpipe_context *softpipe, struct softpipe_tile_cache *tc, int x, int y)
	Get a tile from the cache.
struct softpipe_cached_tile *	sp_get_cached_tile_tex (struct pipe_context *pipe, struct softpipe_tile_cache *tc, int x, int y, int z, int face, int level)
	Similar to sp_get_cached_tile() but for textures.

---

Define Documentation

#define TILE_CLEAR_OPTIMIZATION   1

Definition at line 31 of file sp_tile_cache.h.

#define TILE_SIZE   64

Cache tile size (width and height).

This needs to be a power of two.

Definition at line 44 of file sp_tile_cache.h.

---

Function Documentation

struct softpipe_tile_cache* sp_create_tile_cache

(

struct pipe_screen *

screen

)

[read]

Definition at line 114 of file sp_tile_cache.c.

References CALLOC_STRUCT, softpipe_tile_cache::entries, NUM_ENTRIES, softpipe_tile_cache::screen, softpipe_cached_tile::x, and softpipe_cached_tile::y.

{
   struct softpipe_tile_cache *tc;
   uint pos;

   tc = CALLOC_STRUCT( softpipe_tile_cache );
   if (tc) {
      tc->screen = screen;
      for (pos = 0; pos < NUM_ENTRIES; pos++) {
         tc->entries[pos].x =
         tc->entries[pos].y = -1;
      }
   }
   return tc;
}

void sp_destroy_tile_cache

(

struct softpipe_tile_cache *

tc

)

Definition at line 132 of file sp_tile_cache.c.

References FREE, NUM_ENTRIES, pipe_surface_reference(), softpipe_tile_cache::surface, and softpipe_tile_cache::tex_surf.

{
   uint pos;

   for (pos = 0; pos < NUM_ENTRIES; pos++) {
      /*assert(tc->entries[pos].x < 0);*/
   }
   if (tc->surface) {
      pipe_surface_reference(&tc->surface, NULL);
   }
   if (tc->tex_surf) {
      pipe_surface_reference(&tc->tex_surf, NULL);
   }

   FREE( tc );
}

void sp_flush_tile_cache	(	struct softpipe_context *	softpipe,
		struct softpipe_tile_cache *	tc
	)

Flush the tile cache: write all dirty tiles back to the surface.

any tiles "flagged" as cleared will be "really" cleared.

Definition at line 366 of file sp_tile_cache.c.

References pipe_surface::buffer, softpipe_cached_tile::color, softpipe_cached_tile::data, debug_printf(), softpipe_cached_tile::depth32, softpipe_tile_cache::depth_stencil, softpipe_tile_cache::entries, NUM_ENTRIES, softpipe_context::pipe, pipe_put_tile_raw(), pipe_put_tile_rgba(), sp_tile_cache_flush_clear(), softpipe_tile_cache::surface, softpipe_tile_cache::tex_face, softpipe_tile_cache::texture, TILE_SIZE, softpipe_cached_tile::x, and softpipe_cached_tile::y.

{
   struct pipe_surface *ps = tc->surface;
   int inuse = 0, pos;

   if (ps && ps->buffer) {
      /* caching a drawing surface */
      for (pos = 0; pos < NUM_ENTRIES; pos++) {
         struct softpipe_cached_tile *tile = tc->entries + pos;
         if (tile->x >= 0) {
            if (tc->depth_stencil) {
               pipe_put_tile_raw(ps,
                                 tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                 tile->data.depth32, 0/*STRIDE*/);
            }
            else {
               pipe_put_tile_rgba(ps,
                                  tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                                  (float *) tile->data.color);
            }
            tile->x = tile->y = -1;  /* mark as empty */
            inuse++;
         }
      }

#if TILE_CLEAR_OPTIMIZATION
      sp_tile_cache_flush_clear(&softpipe->pipe, tc);
#endif
   }
   else if (tc->texture) {
      /* caching a texture, mark all entries as empty */
      for (pos = 0; pos < NUM_ENTRIES; pos++) {
         tc->entries[pos].x = -1;
      }
      tc->tex_face = -1;
   }

#if 0
   debug_printf("flushed tiles in use: %d\n", inuse);
#endif
}

struct softpipe_cached_tile* sp_get_cached_tile	(	struct softpipe_context *	softpipe,
		struct softpipe_tile_cache *	tc,
		int	x,
		int	y
	)			[read]

Get a tile from the cache.

Parameters:

x,y

position of tile, in pixels

Definition at line 415 of file sp_tile_cache.c.

References CACHE_POS, clear_clear_flag(), softpipe_tile_cache::clear_color, softpipe_tile_cache::clear_flags, clear_tile(), clear_tile_rgba(), softpipe_tile_cache::clear_val, softpipe_cached_tile::color, softpipe_cached_tile::data, softpipe_cached_tile::depth32, softpipe_tile_cache::depth_stencil, softpipe_tile_cache::entries, pipe_surface::format, is_clear_flag_set(), pipe_get_tile_raw(), pipe_get_tile_rgba(), pipe_put_tile_raw(), pipe_put_tile_rgba(), softpipe_tile_cache::surface, TILE_SIZE, softpipe_cached_tile::x, and softpipe_cached_tile::y.

{
   struct pipe_surface *ps = tc->surface;

   /* tile pos in framebuffer: */
   const int tile_x = x & ~(TILE_SIZE - 1);
   const int tile_y = y & ~(TILE_SIZE - 1);

   /* cache pos/entry: */
   const int pos = CACHE_POS(x, y);
   struct softpipe_cached_tile *tile = tc->entries + pos;

   if (tile_x != tile->x ||
       tile_y != tile->y) {

      if (tile->x != -1) {
         /* put dirty tile back in framebuffer */
         if (tc->depth_stencil) {
            pipe_put_tile_raw(ps,
                              tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                              tile->data.depth32, 0/*STRIDE*/);
         }
         else {
            pipe_put_tile_rgba(ps,
                               tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                               (float *) tile->data.color);
         }
      }

      tile->x = tile_x;
      tile->y = tile_y;

      if (is_clear_flag_set(tc->clear_flags, x, y)) {
         /* don't get tile from framebuffer, just clear it */
         if (tc->depth_stencil) {
            clear_tile(tile, ps->format, tc->clear_val);
         }
         else {
            clear_tile_rgba(tile, ps->format, tc->clear_color);
         }
         clear_clear_flag(tc->clear_flags, x, y);
      }
      else {
         /* get new tile data from surface */
         if (tc->depth_stencil) {
            pipe_get_tile_raw(ps,
                              tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                              tile->data.depth32, 0/*STRIDE*/);
         }
         else {
            pipe_get_tile_rgba(ps,
                               tile->x, tile->y, TILE_SIZE, TILE_SIZE,
                               (float *) tile->data.color);
         }
      }
   }

   return tile;
}

struct softpipe_cached_tile* sp_get_cached_tile_tex	(	struct pipe_context *	pipe,
		struct softpipe_tile_cache *	tc,
		int	x,
		int	y,
		int	z,
		int	face,
		int	level
	)			[read]

Similar to sp_get_cached_tile() but for textures.

Tiles are read-only and indexed with more params.

Definition at line 497 of file sp_tile_cache.c.

References softpipe_cached_tile::color, softpipe_cached_tile::data, softpipe_tile_cache::entries, softpipe_cached_tile::face, FALSE, pipe_screen::get_tex_surface, softpipe_cached_tile::level, softpipe_texture::modified, NUM_ENTRIES, PIPE_BUFFER_USAGE_CPU_READ, pipe_get_tile_rgba(), softpipe_tile_cache::screen, pipe_context::screen, softpipe_texture(), pipe_screen::surface_map, pipe_screen::surface_unmap, tex_cache_pos(), softpipe_tile_cache::tex_face, softpipe_tile_cache::tex_level, softpipe_tile_cache::tex_surf, softpipe_tile_cache::tex_surf_map, softpipe_tile_cache::tex_z, softpipe_tile_cache::texture, TILE_SIZE, softpipe_cached_tile::x, softpipe_cached_tile::y, and softpipe_cached_tile::z.

{
   struct pipe_screen *screen = pipe->screen;
   /* tile pos in framebuffer: */
   const int tile_x = x & ~(TILE_SIZE - 1);
   const int tile_y = y & ~(TILE_SIZE - 1);
   /* cache pos/entry: */
   const uint pos = tex_cache_pos(x / TILE_SIZE, y / TILE_SIZE, z,
                                  face, level);
   struct softpipe_cached_tile *tile = tc->entries + pos;

   if (tc->texture) {
      struct softpipe_texture *spt = softpipe_texture(tc->texture);
      if (spt->modified) {
         /* texture was modified, invalidate all cached tiles */
         uint p;
         for (p = 0; p < NUM_ENTRIES; p++) {
            tile = tc->entries + p;
            tile->x = -1;
         }
         spt->modified = FALSE;
      }
   }

   if (tile_x != tile->x ||
       tile_y != tile->y ||
       z != tile->z ||
       face != tile->face ||
       level != tile->level) {
      /* cache miss */

#if 0
      printf("miss at %u  x=%d y=%d z=%d face=%d level=%d\n", pos,
             x/TILE_SIZE, y/TILE_SIZE, z, face, level);
#endif
      /* check if we need to get a new surface */
      if (!tc->tex_surf ||
          tc->tex_face != face ||
          tc->tex_level != level ||
          tc->tex_z != z) {
         /* get new surface (view into texture) */

         if (tc->tex_surf_map)
            tc->screen->surface_unmap(tc->screen, tc->tex_surf);

         tc->tex_surf = screen->get_tex_surface(screen, tc->texture, face, level, z, 
                                                PIPE_BUFFER_USAGE_CPU_READ);
         tc->tex_surf_map = screen->surface_map(screen, tc->tex_surf,
                                                PIPE_BUFFER_USAGE_CPU_READ);

         tc->tex_face = face;
         tc->tex_level = level;
         tc->tex_z = z;
      }

      /* get tile from the surface (view into texture) */
      pipe_get_tile_rgba(tc->tex_surf,
                         tile_x, tile_y, TILE_SIZE, TILE_SIZE,
                         (float *) tile->data.color);
      tile->x = tile_x;
      tile->y = tile_y;
      tile->z = z;
      tile->face = face;
      tile->level = level;
   }

   return tile;
}

void sp_tile_cache_clear	(	struct softpipe_tile_cache *	tc,
		uint	clearValue
	)

When a whole surface is being cleared to a value we can avoid fetching tiles above.

Save the color and set a 'clearflag' for each tile of the screen.

Definition at line 575 of file sp_tile_cache.c.

References softpipe_tile_cache::clear_color, softpipe_tile_cache::clear_flags, softpipe_tile_cache::clear_val, softpipe_tile_cache::entries, pipe_surface::format, NUM_ENTRIES, PIPE_FORMAT_A8R8G8B8_UNORM, PIPE_FORMAT_B8G8R8A8_UNORM, PIPE_FORMAT_B8G8R8X8_UNORM, PIPE_FORMAT_R8G8B8A8_UNORM, PIPE_FORMAT_R8G8B8X8_UNORM, PIPE_FORMAT_X8R8G8B8_UNORM, softpipe_tile_cache::surface, softpipe_cached_tile::x, and softpipe_cached_tile::y.

{
   uint r, g, b, a;
   uint pos;

   tc->clear_val = clearValue;

   switch (tc->surface->format) {
   case PIPE_FORMAT_R8G8B8A8_UNORM:
   case PIPE_FORMAT_R8G8B8X8_UNORM:
      r = (clearValue >> 24) & 0xff;
      g = (clearValue >> 16) & 0xff;
      b = (clearValue >>  8) & 0xff;
      a = (clearValue      ) & 0xff;
      break;
   case PIPE_FORMAT_A8R8G8B8_UNORM:
   case PIPE_FORMAT_X8R8G8B8_UNORM:
      r = (clearValue >> 16) & 0xff;
      g = (clearValue >>  8) & 0xff;
      b = (clearValue      ) & 0xff;
      a = (clearValue >> 24) & 0xff;
      break;
   case PIPE_FORMAT_B8G8R8A8_UNORM:
   case PIPE_FORMAT_B8G8R8X8_UNORM:
      r = (clearValue >>  8) & 0xff;
      g = (clearValue >> 16) & 0xff;
      b = (clearValue >> 24) & 0xff;
      a = (clearValue      ) & 0xff;
      break;
   default:
      r = g = b = a = 0;
   }

   tc->clear_color[0] = r / 255.0f;
   tc->clear_color[1] = g / 255.0f;
   tc->clear_color[2] = b / 255.0f;
   tc->clear_color[3] = a / 255.0f;

#if TILE_CLEAR_OPTIMIZATION
   /* set flags to indicate all the tiles are cleared */
   memset(tc->clear_flags, 255, sizeof(tc->clear_flags));
#else
   /* disable the optimization */
   memset(tc->clear_flags, 0, sizeof(tc->clear_flags));
#endif

   for (pos = 0; pos < NUM_ENTRIES; pos++) {
      struct softpipe_cached_tile *tile = tc->entries + pos;
      tile->x = tile->y = -1;
   }

struct pipe_surface* sp_tile_cache_get_surface

(

struct softpipe_tile_cache *

tc

)

[read]

Return the surface being cached.

Definition at line 187 of file sp_tile_cache.c.

References softpipe_tile_cache::surface.

{
   return tc->surface;
}

void sp_tile_cache_map_surfaces

(

struct softpipe_tile_cache *

tc

)

Definition at line 194 of file sp_tile_cache.c.

References PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, softpipe_tile_cache::screen, softpipe_tile_cache::surface, pipe_screen::surface_map, softpipe_tile_cache::surface_map, softpipe_tile_cache::tex_surf, and softpipe_tile_cache::tex_surf_map.

{
   if (tc->surface && !tc->surface_map)
      tc->surface_map = tc->screen->surface_map(tc->screen, tc->surface,
                                                PIPE_BUFFER_USAGE_CPU_WRITE |
                                                PIPE_BUFFER_USAGE_CPU_READ);

   if (tc->tex_surf && !tc->tex_surf_map)
      tc->tex_surf_map = tc->screen->surface_map(tc->screen, tc->tex_surf,
                                                 PIPE_BUFFER_USAGE_CPU_READ);
}

void sp_tile_cache_set_surface	(	struct softpipe_tile_cache *	tc,
		struct pipe_surface *	sps
	)

Specify the surface to cache.

Definition at line 154 of file sp_tile_cache.c.

References assert, softpipe_tile_cache::depth_stencil, pipe_surface::format, PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, PIPE_FORMAT_S8_UNORM, PIPE_FORMAT_S8Z24_UNORM, PIPE_FORMAT_X8Z24_UNORM, PIPE_FORMAT_Z16_UNORM, PIPE_FORMAT_Z24S8_UNORM, PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_Z32_UNORM, pipe_surface_reference(), softpipe_tile_cache::screen, softpipe_tile_cache::surface, pipe_screen::surface_map, softpipe_tile_cache::surface_map, pipe_screen::surface_unmap, and softpipe_tile_cache::texture.

{
   assert(!tc->texture);

   if (tc->surface_map) {
      tc->screen->surface_unmap(tc->screen, tc->surface);
      tc->surface_map = NULL;
   }

   pipe_surface_reference(&tc->surface, ps);

   if (tc->surface) {
      if (tc->surface_map) /* XXX: this is always NULL!? */
         tc->surface_map = tc->screen->surface_map(tc->screen, tc->surface,
                                                   PIPE_BUFFER_USAGE_CPU_READ | 
                                                   PIPE_BUFFER_USAGE_CPU_WRITE);

      tc->depth_stencil = (ps->format == PIPE_FORMAT_S8Z24_UNORM ||
                           ps->format == PIPE_FORMAT_X8Z24_UNORM ||
                           ps->format == PIPE_FORMAT_Z24S8_UNORM ||
                           ps->format == PIPE_FORMAT_Z24X8_UNORM ||
                           ps->format == PIPE_FORMAT_Z16_UNORM ||
                           ps->format == PIPE_FORMAT_Z32_UNORM ||
                           ps->format == PIPE_FORMAT_S8_UNORM);
   }
}

void sp_tile_cache_set_texture	(	struct pipe_context *	pipe,
		struct softpipe_tile_cache *	tc,
		struct pipe_texture *	texture
	)

Specify the texture to cache.

Definition at line 226 of file sp_tile_cache.c.

References assert, softpipe_tile_cache::entries, NUM_ENTRIES, pipe_surface_reference(), pipe_texture_reference(), softpipe_tile_cache::screen, softpipe_tile_cache::surface, pipe_screen::surface_unmap, softpipe_tile_cache::tex_face, softpipe_tile_cache::tex_surf, softpipe_tile_cache::tex_surf_map, softpipe_tile_cache::texture, and softpipe_cached_tile::x.

{
   uint i;

   assert(!tc->surface);

   pipe_texture_reference(&tc->texture, texture);

   if (tc->tex_surf_map) {
      tc->screen->surface_unmap(tc->screen, tc->tex_surf);
      tc->tex_surf_map = NULL;
   }
   pipe_surface_reference(&tc->tex_surf, NULL);

   /* mark as entries as invalid/empty */
   /* XXX we should try to avoid this when the teximage hasn't changed */
   for (i = 0; i < NUM_ENTRIES; i++) {
      tc->entries[i].x = -1;
   }

   tc->tex_face = -1; /* any invalid value here */
}

void sp_tile_cache_unmap_surfaces

(

struct softpipe_tile_cache *

tc

)

Definition at line 208 of file sp_tile_cache.c.

References softpipe_tile_cache::screen, softpipe_tile_cache::surface, softpipe_tile_cache::surface_map, pipe_screen::surface_unmap, softpipe_tile_cache::tex_surf, and softpipe_tile_cache::tex_surf_map.

{
   if (tc->surface_map) {
      tc->screen->surface_unmap(tc->screen, tc->surface);
      tc->surface_map = NULL;
   }

   if (tc->tex_surf_map) {
      tc->screen->surface_unmap(tc->screen, tc->tex_surf);
      tc->tex_surf_map = NULL;
   }
}

---