st_gen_mipmap.c File Reference

Include dependency graph for st_gen_mipmap.c:

Go to the source code of this file.

Functions
void	st_init_generate_mipmap (struct st_context *st)
	one-time init for generate mipmap XXX Note: there may be other times we need no-op/simple state like this.
void	st_destroy_generate_mipmap (struct st_context *st)
static boolean	st_render_mipmap (struct st_context *st, GLenum target, struct pipe_texture *pt, uint baseLevel, uint lastLevel)
	Generate mipmap levels using hardware rendering.
static void	fallback_generate_mipmap (GLcontext *ctx, GLenum target, struct gl_texture_object *texObj)
void	st_generate_mipmap (GLcontext *ctx, GLenum target, struct gl_texture_object *texObj)

---

Function Documentation

static void fallback_generate_mipmap	(	GLcontext *	ctx,
		GLenum	target,
		struct gl_texture_object *	texObj
	)			[static]

Definition at line 102 of file st_gen_mipmap.c.

References assert, pipe_surface::buffer, pipe_texture::depth, pipe_screen::get_tex_surface, pipe_texture::height, pipe_texture::last_level, pipe_surface::offset, pipe_buffer_map(), pipe_buffer_unmap(), PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, pipe_surface_reference(), pipe_context::screen, st_get_texobj_texture(), pipe_surface::stride, pipe_texture::width, and pipe_surface::zslice.

{
   struct pipe_context *pipe = ctx->st->pipe;
   struct pipe_screen *screen = pipe->screen;
   struct pipe_texture *pt = st_get_texobj_texture(texObj);
   const uint baseLevel = texObj->BaseLevel;
   const uint lastLevel = pt->last_level;
   const uint face = _mesa_tex_target_to_face(target), zslice = 0;
   uint dstLevel;
   GLenum datatype;
   GLuint comps;

   assert(target != GL_TEXTURE_3D); /* not done yet */

   _mesa_format_to_type_and_comps(texObj->Image[face][baseLevel]->TexFormat,
                                  &datatype, &comps);

   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
      const uint srcLevel = dstLevel - 1;
      struct pipe_surface *srcSurf, *dstSurf;
      const ubyte *srcData;
      ubyte *dstData;

      srcSurf = screen->get_tex_surface(screen, pt, face, srcLevel, zslice,
                                        PIPE_BUFFER_USAGE_CPU_READ);
      dstSurf = screen->get_tex_surface(screen, pt, face, dstLevel, zslice,
                                        PIPE_BUFFER_USAGE_CPU_WRITE);

      srcData = (ubyte *) pipe_buffer_map(pipe->screen, srcSurf->buffer,
                                          PIPE_BUFFER_USAGE_CPU_READ)
              + srcSurf->offset;
      dstData = (ubyte *) pipe_buffer_map(pipe->screen, dstSurf->buffer,
                                          PIPE_BUFFER_USAGE_CPU_WRITE)
              + dstSurf->offset;

      _mesa_generate_mipmap_level(target, datatype, comps,
                   0 /*border*/,
                   pt->width[srcLevel], pt->height[srcLevel], pt->depth[srcLevel],
                   srcSurf->stride, /* stride in bytes */
                   srcData,
                   pt->width[dstLevel], pt->height[dstLevel], pt->depth[dstLevel],
                   dstSurf->stride, /* stride in bytes */
                   dstData);

      pipe_buffer_unmap(pipe->screen, srcSurf->buffer);
      pipe_buffer_unmap(pipe->screen, dstSurf->buffer);

      pipe_surface_reference(&srcSurf, NULL);
      pipe_surface_reference(&dstSurf, NULL);
   }
}

void st_destroy_generate_mipmap

(

struct st_context *

st

)

Definition at line 65 of file st_gen_mipmap.c.

References st_context::gen_mipmap, and util_destroy_gen_mipmap().

{
   util_destroy_gen_mipmap(st->gen_mipmap);
   st->gen_mipmap = NULL;
}

void st_generate_mipmap	(	GLcontext *	ctx,
		GLenum	target,
		struct gl_texture_object *	texObj
	)

Definition at line 157 of file st_gen_mipmap.c.

References pipe_texture::depth, fallback_generate_mipmap(), pipe_texture::height, pipe_texture::last_level, pipe_texture_reference(), st_texture_image::pt, st_get_texobj_texture(), st_render_mipmap(), and pipe_texture::width.

{
   struct st_context *st = ctx->st;
   struct pipe_texture *pt = st_get_texobj_texture(texObj);
   const uint baseLevel = texObj->BaseLevel;
   const uint lastLevel = pt->last_level;
   uint dstLevel;

   if (!st_render_mipmap(st, target, pt, baseLevel, lastLevel)) {
      fallback_generate_mipmap(ctx, target, texObj);
   }

   /* Fill in the Mesa gl_texture_image fields */
   for (dstLevel = baseLevel + 1; dstLevel <= lastLevel; dstLevel++) {
      const uint srcLevel = dstLevel - 1;
      const struct gl_texture_image *srcImage
         = _mesa_get_tex_image(ctx, texObj, target, srcLevel);
      struct gl_texture_image *dstImage;
      struct st_texture_image *stImage;
      uint dstWidth = pt->width[dstLevel];
      uint dstHeight = pt->height[dstLevel];
      uint dstDepth = pt->depth[dstLevel];
      uint border = srcImage->Border;

      dstImage = _mesa_get_tex_image(ctx, texObj, target, dstLevel);
      if (!dstImage) {
         _mesa_error(ctx, GL_OUT_OF_MEMORY, "generating mipmaps");
         return;
      }

      if (dstImage->ImageOffsets)
         _mesa_free(dstImage->ImageOffsets);

      /* Free old image data */
      if (dstImage->Data)
         ctx->Driver.FreeTexImageData(ctx, dstImage);

      /* initialize new image */
      _mesa_init_teximage_fields(ctx, target, dstImage, dstWidth, dstHeight,
                                 dstDepth, border, srcImage->InternalFormat);

      dstImage->TexFormat = srcImage->TexFormat;

      stImage = (struct st_texture_image *) dstImage;
      pipe_texture_reference(&stImage->pt, pt);
   }
}

void st_init_generate_mipmap

(

struct st_context *

st

)

one-time init for generate mipmap XXX Note: there may be other times we need no-op/simple state like this.

In that case, some code refactoring would be good.

Definition at line 58 of file st_gen_mipmap.c.

References st_context::cso_context, st_context::gen_mipmap, st_context::pipe, and util_create_gen_mipmap().

{
   st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);
}

static boolean st_render_mipmap	(	struct st_context *	st,
		GLenum	target,
		struct pipe_texture *	pt,
		uint	baseLevel,
		uint	lastLevel
	)			[static]

Generate mipmap levels using hardware rendering.

Returns:

TRUE if successful, FALSE if not possible

Definition at line 77 of file st_gen_mipmap.c.

References assert, FALSE, pipe_texture::format, st_context::gen_mipmap, pipe_screen::is_format_supported, st_context::pipe, PIPE_TEX_FILTER_LINEAR, PIPE_TEXTURE_USAGE_RENDER_TARGET, pipe_context::screen, TRUE, and util_gen_mipmap().

{
   struct pipe_context *pipe = st->pipe;
   struct pipe_screen *screen = pipe->screen;
   const uint face = _mesa_tex_target_to_face(target);

   assert(target != GL_TEXTURE_3D); /* not done yet */

   /* check if we can render in the texture's format */
   if (!screen->is_format_supported(screen, pt->format, target,
                                    PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
      return FALSE;
   }

   util_gen_mipmap(st->gen_mipmap, pt, face, baseLevel, lastLevel,
                   PIPE_TEX_FILTER_LINEAR);

   return TRUE;
}

---