Subversion Repositories Kolibri OS

/**************************************************************************

 *

 * Copyright 2007 Tungsten Graphics, Inc., Bismarck, ND., USA

 * 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 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

 * THE COPYRIGHT HOLDERS, AUTHORS 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.

 *

 * The above copyright notice and this permission notice (including the

 * next paragraph) shall be included in all copies or substantial portions

 * of the Software.

 *

 *

 **************************************************************************/

/*

 * Authors:

 *   Keith Whitwell

 *   Brian Paul

 */

#include "pipe/p_format.h"

#include "pipe/p_context.h"

#include "util/u_inlines.h"

#include "util/u_format.h"

#include "util/u_math.h"

#include "util/u_memory.h"

#include "state_tracker/xlib_sw_winsys.h"

#include 

#include 

#include 

#include 

#include 

#include 

DEBUG_GET_ONCE_BOOL_OPTION(xlib_no_shm, "XLIB_NO_SHM", FALSE)

/**

 * Display target for Xlib winsys.

 * Low-level OS/window system memory buffer

 */

struct xlib_displaytarget

{

   enum pipe_format format;

   unsigned width;

   unsigned height;

   unsigned stride;

   void *data;

   void *mapped;

   Display *display;

   Visual *visual;

   XImage *tempImage;

   GC gc;

   /* This is the last drawable that this display target was presented

    * against.  May need to recreate gc, tempImage when this changes??

    */

   Drawable drawable;

   XShmSegmentInfo shminfo;

   Bool shm;  /** Using shared memory images? */

};

/**

 * Subclass of sw_winsys for Xlib winsys

 */

struct xlib_sw_winsys

{

   struct sw_winsys base;

   Display *display;

};

/** Cast wrapper */

static INLINE struct xlib_displaytarget *

xlib_displaytarget(struct sw_displaytarget *dt)

{

   return (struct xlib_displaytarget *) dt;

}

/**

 * X Shared Memory Image extension code

 */

static volatile int XErrorFlag = 0;

/**

 * Catches potential Xlib errors.

 */

static int

handle_xerror(Display *dpy, XErrorEvent *event)

{

   (void) dpy;

   (void) event;

   XErrorFlag = 1;

   return 0;

}

static char *

alloc_shm(struct xlib_displaytarget *buf, unsigned size)

{

   XShmSegmentInfo *const shminfo = & buf->shminfo;

   shminfo->shmid = -1;

   shminfo->shmaddr = (char *) -1;

   shminfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT|0777);

   if (shminfo->shmid < 0) {

      return NULL;

   }

   shminfo->shmaddr = (char *) shmat(shminfo->shmid, 0, 0);

   if (shminfo->shmaddr == (char *) -1) {

      shmctl(shminfo->shmid, IPC_RMID, 0);

      return NULL;

   }

   shminfo->readOnly = False;

   return shminfo->shmaddr;

}

/**

 * Allocate a shared memory XImage back buffer for the given display target.

 */

static void

alloc_shm_ximage(struct xlib_displaytarget *xlib_dt,

                 struct xlib_drawable *xmb,

                 unsigned width, unsigned height)

{

   /*

    * We have to do a _lot_ of error checking here to be sure we can

    * really use the XSHM extension.  It seems different servers trigger

    * errors at different points if the extension won't work.  Therefore

    * we have to be very careful...

    */

   int (*old_handler)(Display *, XErrorEvent *);

   xlib_dt->tempImage = XShmCreateImage(xlib_dt->display,

                                      xmb->visual,

                                      xmb->depth,

                                      ZPixmap,

                                      NULL,

                                      &xlib_dt->shminfo,

                                      width, height);

   if (xlib_dt->tempImage == NULL) {

      shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);

      xlib_dt->shm = False;

      return;

   }

   XErrorFlag = 0;

   old_handler = XSetErrorHandler(handle_xerror);

   /* This may trigger the X protocol error we're ready to catch: */

   XShmAttach(xlib_dt->display, &xlib_dt->shminfo);

   XSync(xlib_dt->display, False);

   /* Mark the segment to be destroyed, so that it is automatically destroyed

    * when this process dies.  Needs to be after XShmAttach() for *BSD.

    */

   shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);

   if (XErrorFlag) {

      /* we are on a remote display, this error is normal, don't print it */

      XFlush(xlib_dt->display);

      XErrorFlag = 0;

      XDestroyImage(xlib_dt->tempImage);

      xlib_dt->tempImage = NULL;

      xlib_dt->shm = False;

      (void) XSetErrorHandler(old_handler);

      return;

   }

   xlib_dt->shm = True;

}

static void

alloc_ximage(struct xlib_displaytarget *xlib_dt,

             struct xlib_drawable *xmb,

             unsigned width, unsigned height)

{

   /* try allocating a shared memory image first */

   if (xlib_dt->shm) {

      alloc_shm_ximage(xlib_dt, xmb, width, height);

      if (xlib_dt->tempImage)

         return; /* success */

   }

   /* try regular (non-shared memory) image */

   xlib_dt->tempImage = XCreateImage(xlib_dt->display,

                                   xmb->visual,

                                   xmb->depth,

                                   ZPixmap, 0,

                                   NULL, width, height,

                                   8, 0);

}

static boolean

xlib_is_displaytarget_format_supported(struct sw_winsys *ws,

                                       unsigned tex_usage,

                                       enum pipe_format format)

{

   /* TODO: check visuals or other sensible thing here */

   return TRUE;

}

static void *

xlib_displaytarget_map(struct sw_winsys *ws,

                       struct sw_displaytarget *dt,

                       unsigned flags)

{

   struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);

   xlib_dt->mapped = xlib_dt->data;

   return xlib_dt->mapped;

}

static void

xlib_displaytarget_unmap(struct sw_winsys *ws,

                         struct sw_displaytarget *dt)

{

   struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);

   xlib_dt->mapped = NULL;

}

static void

xlib_displaytarget_destroy(struct sw_winsys *ws,

                           struct sw_displaytarget *dt)

{

   struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);

   if (xlib_dt->data) {

      if (xlib_dt->shminfo.shmid >= 0) {

         shmdt(xlib_dt->shminfo.shmaddr);

         shmctl(xlib_dt->shminfo.shmid, IPC_RMID, 0);

         xlib_dt->shminfo.shmid = -1;

         xlib_dt->shminfo.shmaddr = (char *) -1;

         xlib_dt->data = NULL;

         if (xlib_dt->tempImage)

            xlib_dt->tempImage->data = NULL;

      }

      else {

         FREE(xlib_dt->data);

         if (xlib_dt->tempImage && xlib_dt->tempImage->data == xlib_dt->data) {

            xlib_dt->tempImage->data = NULL;

         }

         xlib_dt->data = NULL;

      }

   }

   if (xlib_dt->tempImage) {

      XDestroyImage(xlib_dt->tempImage);

      xlib_dt->tempImage = NULL;

   }

   if (xlib_dt->gc)

      XFreeGC(xlib_dt->display, xlib_dt->gc);

   FREE(xlib_dt);

}

/**

 * Display/copy the image in the surface into the X window specified

 * by the display target.

 */

static void

xlib_sw_display(struct xlib_drawable *xlib_drawable,

                struct sw_displaytarget *dt)

{

   static boolean no_swap = 0;

   static boolean firsttime = 1;

   struct xlib_displaytarget *xlib_dt = xlib_displaytarget(dt);

   Display *display = xlib_dt->display;

   XImage *ximage;

   if (firsttime) {

      no_swap = getenv("SP_NO_RAST") != NULL;

      firsttime = 0;

   }

   if (no_swap)

      return;

   if (xlib_dt->drawable != xlib_drawable->drawable) {

      if (xlib_dt->gc) {

         XFreeGC(display, xlib_dt->gc);

         xlib_dt->gc = NULL;

      }

      if (xlib_dt->tempImage) {

         XDestroyImage(xlib_dt->tempImage);

         xlib_dt->tempImage = NULL;

      }

      xlib_dt->drawable = xlib_drawable->drawable;

   }

   if (xlib_dt->tempImage == NULL) {

      assert(util_format_get_blockwidth(xlib_dt->format) == 1);

      assert(util_format_get_blockheight(xlib_dt->format) == 1);

      alloc_ximage(xlib_dt, xlib_drawable,

                   xlib_dt->stride / util_format_get_blocksize(xlib_dt->format),

                   xlib_dt->height);

      if (!xlib_dt->tempImage)

         return;

   }

   if (xlib_dt->gc == NULL) {

      xlib_dt->gc = XCreateGC(display, xlib_drawable->drawable, 0, NULL);

      XSetFunction(display, xlib_dt->gc, GXcopy);

   }

   if (xlib_dt->shm) {

      ximage = xlib_dt->tempImage;

      ximage->data = xlib_dt->data;

      /* _debug_printf("XSHM\n"); */

      XShmPutImage(xlib_dt->display, xlib_drawable->drawable, xlib_dt->gc,

                   ximage, 0, 0, 0, 0, xlib_dt->width, xlib_dt->height, False);

   }

   else {

      /* display image in Window */

      ximage = xlib_dt->tempImage;

      ximage->data = xlib_dt->data;

      /* check that the XImage has been previously initialized */

      assert(ximage->format);

      assert(ximage->bitmap_unit);

      /* update XImage's fields */

      ximage->width = xlib_dt->width;

      ximage->height = xlib_dt->height;

      ximage->bytes_per_line = xlib_dt->stride;

      /* _debug_printf("XPUT\n"); */

      XPutImage(xlib_dt->display, xlib_drawable->drawable, xlib_dt->gc,

                ximage, 0, 0, 0, 0, xlib_dt->width, xlib_dt->height);

   }

   XFlush(xlib_dt->display);

}

/**

 * Display/copy the image in the surface into the X window specified

 * by the display target.

 */

static void

xlib_displaytarget_display(struct sw_winsys *ws,

                           struct sw_displaytarget *dt,

                           void *context_private)

{

   struct xlib_drawable *xlib_drawable = (struct xlib_drawable *)context_private;

   xlib_sw_display(xlib_drawable, dt);

}

static struct sw_displaytarget *

xlib_displaytarget_create(struct sw_winsys *winsys,

                          unsigned tex_usage,

                          enum pipe_format format,

                          unsigned width, unsigned height,

                          unsigned alignment,

                          unsigned *stride)

{

   struct xlib_displaytarget *xlib_dt;

   unsigned nblocksy, size;

   xlib_dt = CALLOC_STRUCT(xlib_displaytarget);

   if (!xlib_dt)

      goto no_xlib_dt;

   xlib_dt->display = ((struct xlib_sw_winsys *)winsys)->display;

   xlib_dt->format = format;

   xlib_dt->width = width;

   xlib_dt->height = height;

   nblocksy = util_format_get_nblocksy(format, height);

   xlib_dt->stride = align(util_format_get_stride(format, width), alignment);

   size = xlib_dt->stride * nblocksy;

   if (!debug_get_option_xlib_no_shm()) {

      xlib_dt->data = alloc_shm(xlib_dt, size);

      if (xlib_dt->data) {

         xlib_dt->shm = True;

      }

   }

   if (!xlib_dt->data) {

      xlib_dt->data = align_malloc(size, alignment);

      if (!xlib_dt->data)

         goto no_data;

   }

   *stride = xlib_dt->stride;

   return (struct sw_displaytarget *)xlib_dt;

no_data:

   FREE(xlib_dt);

no_xlib_dt:

   return NULL;

}

static struct sw_displaytarget *

xlib_displaytarget_from_handle(struct sw_winsys *winsys,

                               const struct pipe_resource *templet,

                               struct winsys_handle *whandle,

                               unsigned *stride)

{

   assert(0);

   return NULL;

}

static boolean

xlib_displaytarget_get_handle(struct sw_winsys *winsys,

                              struct sw_displaytarget *dt,

                              struct winsys_handle *whandle)

{

   assert(0);

   return FALSE;

}

static void

xlib_destroy(struct sw_winsys *ws)

{

   FREE(ws);

}

struct sw_winsys *

xlib_create_sw_winsys(Display *display)

{

   struct xlib_sw_winsys *ws;

   ws = CALLOC_STRUCT(xlib_sw_winsys);

   if (!ws)

      return NULL;

   ws->display = display;

   ws->base.destroy = xlib_destroy;

   ws->base.is_displaytarget_format_supported = xlib_is_displaytarget_format_supported;

   ws->base.displaytarget_create = xlib_displaytarget_create;

   ws->base.displaytarget_from_handle = xlib_displaytarget_from_handle;

   ws->base.displaytarget_get_handle = xlib_displaytarget_get_handle;

   ws->base.displaytarget_map = xlib_displaytarget_map;

   ws->base.displaytarget_unmap = xlib_displaytarget_unmap;

   ws->base.displaytarget_destroy = xlib_displaytarget_destroy;

   ws->base.displaytarget_display = xlib_displaytarget_display;

   return &ws->base;

}