st_public.h File Reference

Include dependency graph for st_public.h:

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

Go to the source code of this file.

Defines
#define	ST_SURFACE_FRONT_LEFT   0
#define	ST_SURFACE_BACK_LEFT   1
#define	ST_SURFACE_FRONT_RIGHT   2
#define	ST_SURFACE_BACK_RIGHT   3
#define	ST_SURFACE_DEPTH   8
#define	ST_TEXTURE_2D   0x2
#define	ST_TEXTURE_RGB   0x1
#define	ST_TEXTURE_RGBA   0x2
Typedefs
typedef void(*	st_proc )()
	Generic function type.
Functions
struct st_context *	st_create_context (struct pipe_context *pipe, const __GLcontextModes *visual, struct st_context *share)
void	st_destroy_context (struct st_context *st)
void	st_copy_context_state (struct st_context *dst, struct st_context *src, uint mask)
struct st_framebuffer *	st_create_framebuffer (const __GLcontextModes *visual, enum pipe_format colorFormat, enum pipe_format depthFormat, enum pipe_format stencilFormat, uint width, uint height, void *privateData)
void	st_resize_framebuffer (struct st_framebuffer *stfb, uint width, uint height)
void	st_set_framebuffer_surface (struct st_framebuffer *stfb, uint surfIndex, struct pipe_surface *surf)
	Set/replace a framebuffer surface.
struct pipe_surface *	st_get_framebuffer_surface (struct st_framebuffer *stfb, uint surfIndex)
	Return the pipe_surface for the given renderbuffer.
struct pipe_texture *	st_get_framebuffer_texture (struct st_framebuffer *stfb, uint surfIndex)
void *	st_framebuffer_private (struct st_framebuffer *stfb)
void	st_unreference_framebuffer (struct st_framebuffer **stfb)
void	st_make_current (struct st_context *st, struct st_framebuffer *draw, struct st_framebuffer *read)
void	st_flush (struct st_context *st, uint pipeFlushFlags, struct pipe_fence_handle **fence)
void	st_finish (struct st_context *st)
	Flush, and wait for completion.
void	st_notify_swapbuffers (struct st_framebuffer *stfb)
	This function is to be called prior to SwapBuffers on the given framebuffer.
void	st_notify_swapbuffers_complete (struct st_framebuffer *stfb)
	Quick hack - allows the winsys to inform the driver that surface states are now undefined after a glXSwapBuffers or similar.
int	st_bind_teximage (struct st_framebuffer *stfb, uint surfIndex, int target, int format, int level)
	Redirect rendering into stfb's surface to a texture image.
int	st_release_teximage (struct st_framebuffer *stfb, uint surfIndex, int target, int format, int level)
	Undo surface-to-texture binding.
st_proc	st_get_proc_address (const char *procname)

---

Define Documentation

#define ST_SURFACE_BACK_LEFT   1

Definition at line 39 of file st_public.h.

#define ST_SURFACE_BACK_RIGHT   3

Definition at line 41 of file st_public.h.

#define ST_SURFACE_DEPTH   8

Definition at line 42 of file st_public.h.

#define ST_SURFACE_FRONT_LEFT   0

Definition at line 38 of file st_public.h.

#define ST_SURFACE_FRONT_RIGHT   2

Definition at line 40 of file st_public.h.

#define ST_TEXTURE_2D   0x2

Definition at line 44 of file st_public.h.

#define ST_TEXTURE_RGB   0x1

Definition at line 45 of file st_public.h.

#define ST_TEXTURE_RGBA   0x2

Definition at line 46 of file st_public.h.

---

Typedef Documentation

typedef void(* st_proc)()

Generic function type.

Definition at line 110 of file st_public.h.

---

Function Documentation

int st_bind_teximage	(	struct st_framebuffer *	stfb,
		uint	surfIndex,
		int	target,
		int	format,
		int	level
	)

Redirect rendering into stfb's surface to a texture image.

Definition at line 356 of file st_texture.c.

{
   GET_CURRENT_CONTEXT(ctx);
   struct st_context *st = ctx->st;
   struct pipe_context *pipe = st->pipe;
   struct pipe_screen *screen = pipe->screen;
   const GLuint unit = ctx->Texture.CurrentUnit;
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
   struct gl_texture_object *texObj;
   struct gl_texture_image *texImage;
   struct st_texture_image *stImage;
   struct st_renderbuffer *strb;
   GLint face = 0, slice = 0;

   assert(surfIndex <= ST_SURFACE_DEPTH);

   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);

   if (strb->texture_save || strb->surface_save) {
      /* Error! */
      return 0;
   }

   if (target == ST_TEXTURE_2D) {
      texObj = texUnit->Current2D;
      texImage = _mesa_get_tex_image(ctx, texObj, GL_TEXTURE_2D, level);
      stImage = st_texture_image(texImage);
   }
   else {
      /* unsupported target */
      return 0;
   }

   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);

   /* save the renderbuffer's surface/texture info */
   pipe_texture_reference(&strb->texture_save, strb->texture);
   pipe_surface_reference(&strb->surface_save, strb->surface);

   /* plug in new surface/texture info */
   pipe_texture_reference(&strb->texture, stImage->pt);
   strb->surface = screen->get_tex_surface(screen, strb->texture,
                                           face, level, slice,
                                           (PIPE_BUFFER_USAGE_GPU_READ |
                                            PIPE_BUFFER_USAGE_GPU_WRITE));

   st->dirty.st |= ST_NEW_FRAMEBUFFER;

void st_copy_context_state	(	struct st_context *	dst,
		struct st_context *	src,
		uint	mask
	)

Definition at line 278 of file st_context.c.

References st_context::ctx.

{
   _mesa_copy_context(dst->ctx, src->ctx, mask);
}

struct st_context* st_create_context	(	struct pipe_context *	pipe,
		const __GLcontextModes *	visual,
		struct st_context *	share
	)			[read]

Definition at line 167 of file st_context.c.

References st_context::ctx, st_create_context_priv(), and st_init_driver_functions().

{
   GLcontext *ctx;
   GLcontext *shareCtx = share ? share->ctx : NULL;
   struct dd_function_table funcs;

   memset(&funcs, 0, sizeof(funcs));
   st_init_driver_functions(&funcs);

   ctx = _mesa_create_context(visual, shareCtx, &funcs, NULL);

   return st_create_context_priv(ctx, pipe);
}

struct st_framebuffer* st_create_framebuffer	(	const __GLcontextModes *	visual,
		enum pipe_format	colorFormat,
		enum pipe_format	depthFormat,
		enum pipe_format	stencilFormat,
		uint	width,
		uint	height,
		void *	privateData
	)			[read]

Definition at line 45 of file st_framebuffer.c.

References st_framebuffer::Base, CALLOC_STRUCT, DEFAULT_ACCUM_PIPE_FORMAT, st_framebuffer::InitHeight, st_framebuffer::InitWidth, PIPE_FORMAT_NONE, st_framebuffer::Private, st_get_msaa(), and st_new_renderbuffer_fb().

{
   struct st_framebuffer *stfb = CALLOC_STRUCT(st_framebuffer);
   if (stfb) {
      int samples = st_get_msaa();

      if (visual->sampleBuffers)
         samples = visual->samples;

      _mesa_initialize_framebuffer(&stfb->Base, visual);

      {
         /* fake frontbuffer */
         /* XXX allocation should only happen in the unusual case
            it's actually needed */
         struct gl_renderbuffer *rb
            = st_new_renderbuffer_fb(colorFormat, samples);
         _mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
      }

      if (visual->doubleBufferMode) {
         struct gl_renderbuffer *rb
            = st_new_renderbuffer_fb(colorFormat, samples);
         _mesa_add_renderbuffer(&stfb->Base, BUFFER_BACK_LEFT, rb);
      }

      if (depthFormat == stencilFormat && depthFormat != PIPE_FORMAT_NONE) {
         /* combined depth/stencil buffer */
         struct gl_renderbuffer *depthStencilRb
            = st_new_renderbuffer_fb(depthFormat, samples);
         /* note: bind RB to two attachment points */
         _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthStencilRb);
         _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, depthStencilRb);
      }
      else {
         /* separate depth and/or stencil */

         if (visual->depthBits == 32) {
            /* 32-bit depth buffer */
            struct gl_renderbuffer *depthRb
               = st_new_renderbuffer_fb(depthFormat, samples);
            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
         }
         else if (visual->depthBits == 24) {
            /* 24-bit depth buffer, ignore stencil bits */
            struct gl_renderbuffer *depthRb
               = st_new_renderbuffer_fb(depthFormat, samples);
            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
         }
         else if (visual->depthBits > 0) {
            /* 16-bit depth buffer */
            struct gl_renderbuffer *depthRb
               = st_new_renderbuffer_fb(depthFormat, samples);
            _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
         }

         if (visual->stencilBits > 0) {
            /* 8-bit stencil */
            struct gl_renderbuffer *stencilRb
               = st_new_renderbuffer_fb(stencilFormat, samples);
            _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, stencilRb);
         }
      }

      if (visual->accumRedBits > 0) {
         /* 16-bit/channel accum */
         struct gl_renderbuffer *accumRb
            = st_new_renderbuffer_fb(DEFAULT_ACCUM_PIPE_FORMAT, 0); /* XXX accum isn't multisampled right? */
         _mesa_add_renderbuffer(&stfb->Base, BUFFER_ACCUM, accumRb);
      }

      stfb->Base.Initialized = GL_TRUE;
      stfb->InitWidth = width;
      stfb->InitHeight = height;
      stfb->Private = private;
   }
   return stfb;
}

void st_destroy_context

(

struct st_context *

st

)

Definition at line 225 of file st_context.c.

References st_context::cache, st_context::cso_context, cso_destroy_context(), cso_release_all(), st_context::ctx, pipe_context::destroy, st_context::fp, st_context::pipe, st_context::pixel_xfer, st_destroy_context_priv(), st_reference_fragprog(), st_reference_vertprog(), and st_context::vp.

{
   struct pipe_context *pipe = st->pipe;
   struct cso_context *cso = st->cso_context;
   GLcontext *ctx = st->ctx;

   /* need to unbind and destroy CSO objects before anything else */
   cso_release_all(st->cso_context);

   st_reference_fragprog(st, &st->fp, NULL);
   st_reference_vertprog(st, &st->vp, NULL);

   _mesa_delete_program_cache(st->ctx, st->pixel_xfer.cache);

   _vbo_DestroyContext(st->ctx);

   _mesa_free_context_data(ctx);

   st_destroy_context_priv(st);

   cso_destroy_context(cso);

   pipe->destroy( pipe );

   free(ctx);
}

void st_finish

(

struct st_context *

st

)

Flush, and wait for completion.

Definition at line 99 of file st_cb_flush.c.

References pipe_winsys::fence_finish, pipe_winsys::fence_reference, st_context::pipe, PIPE_FLUSH_FRAME, PIPE_FLUSH_RENDER_CACHE, st_flush(), and pipe_context::winsys.

{
   struct pipe_fence_handle *fence = NULL;

   st_flush(st, PIPE_FLUSH_RENDER_CACHE | PIPE_FLUSH_FRAME, &fence);

   if(fence) {
      st->pipe->winsys->fence_finish(st->pipe->winsys, fence, 0);
      st->pipe->winsys->fence_reference(st->pipe->winsys, &fence, NULL);
   }
}

void st_flush	(	struct st_context *	st,
		uint	pipeFlushFlags,
		struct pipe_fence_handle **	fence
	)

Definition at line 79 of file st_cb_flush.c.

References st_context::blit, st_context::ctx, pipe_context::flush, st_context::gen_mipmap, st_context::pipe, st_flush_bitmap(), st_flush_clear(), util_blit_flush(), and util_gen_mipmap_flush().

{
   FLUSH_VERTICES(st->ctx, 0);

   /* Release any vertex buffers that might potentially be accessed in
    * successive frames:
    */
   st_flush_bitmap(st);
   st_flush_clear(st);
   util_blit_flush(st->blit);
   util_gen_mipmap_flush(st->gen_mipmap);

   st->pipe->flush( st->pipe, pipeFlushFlags, fence );
}

void* st_framebuffer_private

(

struct st_framebuffer *

stfb

)

Definition at line 302 of file st_framebuffer.c.

References st_framebuffer::Private.

{
   return stfb->Private;
}

struct pipe_surface* st_get_framebuffer_surface	(	struct st_framebuffer *	stfb,
		uint	surfIndex
	)			[read]

Return the pipe_surface for the given renderbuffer.

Definition at line 222 of file st_framebuffer.c.

References assert, st_framebuffer::Base, st_renderbuffer(), ST_SURFACE_BACK_RIGHT, ST_SURFACE_DEPTH, ST_SURFACE_FRONT_LEFT, and st_renderbuffer::surface.

{
   struct st_renderbuffer *strb;

   assert(surfIndex <= ST_SURFACE_DEPTH);

   /* sanity checks, ST tokens should match Mesa tokens */
   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);

   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
   if (strb)
      return strb->surface;
   return NULL;
}

struct pipe_texture* st_get_framebuffer_texture	(	struct st_framebuffer *	stfb,
		uint	surfIndex
	)			[read]

Definition at line 239 of file st_framebuffer.c.

References assert, st_framebuffer::Base, st_renderbuffer(), ST_SURFACE_BACK_RIGHT, ST_SURFACE_DEPTH, ST_SURFACE_FRONT_LEFT, and st_renderbuffer::texture.

{
   struct st_renderbuffer *strb;

   assert(surfIndex <= ST_SURFACE_DEPTH);

   /* sanity checks, ST tokens should match Mesa tokens */
   assert(ST_SURFACE_FRONT_LEFT == BUFFER_FRONT_LEFT);
   assert(ST_SURFACE_BACK_RIGHT == BUFFER_BACK_RIGHT);

   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
   if (strb)
      return strb->texture;
   return NULL;
}

st_proc st_get_proc_address

(

const char *

procname

)

Definition at line 287 of file st_context.c.

{
   return (st_proc) _glapi_get_proc_address(procname);
}

void st_make_current	(	struct st_context *	st,
		struct st_framebuffer *	draw,
		struct st_framebuffer *	read
	)

Definition at line 253 of file st_context.c.

References st_framebuffer::Base, st_context::ctx, st_framebuffer::InitHeight, and st_framebuffer::InitWidth.

{
   if (st) {
      GLboolean firstTime = st->ctx->FirstTimeCurrent;
      _mesa_make_current(st->ctx, &draw->Base, &read->Base);
      /* Need to initialize viewport here since draw->Base->Width/Height
       * will still be zero at this point.
       * This could be improved, but would require rather extensive work
       * elsewhere (allocate rb surface storage sooner)
       */
      if (firstTime) {
         GLuint w = draw->InitWidth, h = draw->InitHeight;
         _mesa_set_viewport(st->ctx, 0, 0, w, h);
         _mesa_set_scissor(st->ctx, 0, 0, w, h);

      }
   }
   else {
      _mesa_make_current(NULL, NULL, NULL);
   }
}

void st_notify_swapbuffers

(

struct st_framebuffer *

stfb

)

This function is to be called prior to SwapBuffers on the given framebuffer.

It checks if the current context is bound to the framebuffer and flushes rendering if needed.

Definition at line 261 of file st_framebuffer.c.

References st_framebuffer::Base, FRONT_STATUS_COPY_OF_BACK, PIPE_FLUSH_FRAME, PIPE_FLUSH_RENDER_CACHE, PIPE_FLUSH_SWAPBUFFERS, and st_flush().

{
   GET_CURRENT_CONTEXT(ctx);

   if (ctx && ctx->DrawBuffer == &stfb->Base) {
      st_flush( ctx->st, 
                PIPE_FLUSH_RENDER_CACHE | 
                PIPE_FLUSH_SWAPBUFFERS |
                PIPE_FLUSH_FRAME,
                NULL );
      ctx->st->frontbuffer_status = FRONT_STATUS_COPY_OF_BACK;
   }
}

void st_notify_swapbuffers_complete

(

struct st_framebuffer *

stfb

)

Quick hack - allows the winsys to inform the driver that surface states are now undefined after a glXSwapBuffers or similar.

Definition at line 281 of file st_framebuffer.c.

References st_framebuffer::Base, PIPE_SURFACE_STATUS_UNDEFINED, st_renderbuffer(), pipe_surface::status, and st_renderbuffer::surface.

{
   GET_CURRENT_CONTEXT(ctx);

   if (ctx && ctx->DrawBuffer == &stfb->Base) {
      struct st_renderbuffer *strb;

      /* Mark back color buffers as undefined */
      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_BACK_LEFT].
                             Renderbuffer);
      if (strb && strb->surface)
         strb->surface->status = PIPE_SURFACE_STATUS_UNDEFINED;

      strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_BACK_RIGHT].
                             Renderbuffer);
      if (strb && strb->surface)
         strb->surface->status = PIPE_SURFACE_STATUS_UNDEFINED;
   }
}

int st_release_teximage	(	struct st_framebuffer *	stfb,
		uint	surfIndex,
		int	target,
		int	format,
		int	level
	)

Undo surface-to-texture binding.

Definition at line 411 of file st_texture.c.

{
   GET_CURRENT_CONTEXT(ctx);
   struct st_context *st = ctx->st;
   struct st_renderbuffer *strb;

   assert(surfIndex <= ST_SURFACE_DEPTH);

   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);

   if (!strb->texture_save || !strb->surface_save) {
      /* Error! */
      return 0;
   }

   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);

   /* free tex surface, restore original */
   pipe_surface_reference(&strb->surface, strb->surface_save);
   pipe_texture_reference(&strb->texture, strb->texture_save);

   pipe_surface_reference(&strb->surface_save, NULL);
   pipe_texture_reference(&strb->texture_save, NULL);

   st->dirty.st |= ST_NEW_FRAMEBUFFER;

void st_resize_framebuffer	(	struct st_framebuffer *	stfb,
		uint	width,
		uint	height
	)

Definition at line 130 of file st_framebuffer.c.

References assert, st_framebuffer::Base, st_framebuffer::InitHeight, and st_framebuffer::InitWidth.

{
   if (stfb->Base.Width != width || stfb->Base.Height != height) {
      GET_CURRENT_CONTEXT(ctx);
      if (ctx) {
         if (stfb->InitWidth == 0 && stfb->InitHeight == 0) {
            /* didn't have a valid size until now */
            stfb->InitWidth = width;
            stfb->InitHeight = height;
            if (ctx->Viewport.Width <= 1) {
               /* set context's initial viewport/scissor size */
               _mesa_set_viewport(ctx, 0, 0, width, height);
               _mesa_set_scissor(ctx, 0, 0, width, height);
            }
         }

         _mesa_resize_framebuffer(ctx, &stfb->Base, width, height);

         assert(stfb->Base.Width == width);
         assert(stfb->Base.Height == height);
      }
   }
}

void st_set_framebuffer_surface	(	struct st_framebuffer *	stfb,
		uint	surfIndex,
		struct pipe_surface *	surf
	)

Set/replace a framebuffer surface.

The user of the state tracker can use this instead of st_resize_framebuffer() to provide new surfaces when a window is resized.

Definition at line 169 of file st_framebuffer.c.

References assert, st_renderbuffer::Base, st_framebuffer::Base, pipe_surface::height, pipe_surface_reference(), pipe_texture_reference(), st_renderbuffer(), st_renderbuffer::surface, pipe_surface::texture, st_renderbuffer::texture, and pipe_surface::width.

{
   static const GLuint invalid_size = 9999999;
   struct st_renderbuffer *strb;
   GLuint width, height, i;

   assert(surfIndex < BUFFER_COUNT);

   strb = st_renderbuffer(stfb->Base.Attachment[surfIndex].Renderbuffer);
   assert(strb);

   /* replace the renderbuffer's surface/texture pointers */
   pipe_surface_reference( &strb->surface, surf );
   pipe_texture_reference( &strb->texture, surf->texture );

   /* update renderbuffer's width/height */
   strb->Base.Width = surf->width;
   strb->Base.Height = surf->height;

   /* Try to update the framebuffer's width/height from the renderbuffer
    * sizes.  Before we start drawing, all the rbs _should_ be the same size.
    */
   width = height = invalid_size;
   for (i = 0; i < BUFFER_COUNT; i++) {
      if (stfb->Base.Attachment[i].Renderbuffer) {
         if (width == invalid_size) {
            width = stfb->Base.Attachment[i].Renderbuffer->Width;
            height = stfb->Base.Attachment[i].Renderbuffer->Height;
         }
         else if (width != stfb->Base.Attachment[i].Renderbuffer->Width ||
                  height != stfb->Base.Attachment[i].Renderbuffer->Height) {
            /* inconsistant renderbuffer sizes, bail out */
            return;
         }
      }
   }

   if (width != invalid_size) {
      /* OK, the renderbuffers are of a consistant size, so update the
       * parent framebuffer's size.
       */
      stfb->Base.Width = width;
      stfb->Base.Height = height;
   }
}

void st_unreference_framebuffer

(

struct st_framebuffer **

stfb

)

Definition at line 156 of file st_framebuffer.c.

{
   _mesa_unreference_framebuffer((struct gl_framebuffer **) stfb);
}

---