xlib_sw_winsys.c 11.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
/**************************************************************************
 * 
 * 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"

42
#include "state_tracker/xlib_sw_winsys.h"
43

44 45 46 47 48 49 50
#include <X11/Xlib.h>
#include <X11/Xlibint.h>
#include <X11/Xutil.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>

51
/**
52
 * Display target for Xlib winsys.
53 54 55 56 57 58 59 60 61 62 63 64
 * Low-level OS/window system memory buffer
 */
struct xm_displaytarget
{
   enum pipe_format format;
   unsigned width;
   unsigned height;
   unsigned stride;

   void *data;
   void *mapped;

65 66
   Display *display;
   Visual *visual;
67
   XImage *tempImage;
68 69 70 71 72 73
   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;
74

75
   XShmSegmentInfo shminfo;
76
   int shm;
77 78 79 80 81 82
};


/**
 * Subclass of sw_winsys for Xlib winsys
 */
83
struct xlib_sw_winsys
84 85
{
   struct sw_winsys base;
86 87 88 89



   Display *display;
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
};



/** Cast wrapper */
static INLINE struct xm_displaytarget *
xm_displaytarget( struct sw_displaytarget *dt )
{
   return (struct xm_displaytarget *)dt;
}


/**
 * X Shared Memory Image extension code
 */

static volatile int mesaXErrorFlag = 0;

/**
 * Catches potential Xlib errors.
 */
static int
mesaHandleXError(Display *dpy, XErrorEvent *event)
{
   (void) dpy;
   (void) event;
   mesaXErrorFlag = 1;
   return 0;
}


static char *alloc_shm(struct xm_displaytarget *buf, unsigned size)
{
   XShmSegmentInfo *const shminfo = & buf->shminfo;

   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 XMesaBuffer.
 */
static void
145 146
alloc_shm_ximage(struct xm_displaytarget *xm_dt,
                 struct xlib_drawable *xmb,
147 148 149 150 151 152 153 154 155 156
                 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 *);

157 158 159 160 161 162 163 164 165
   xm_dt->tempImage = XShmCreateImage(xm_dt->display,
                                      xmb->visual,
                                      xmb->depth,
                                      ZPixmap,
                                      NULL,
                                      &xm_dt->shminfo,
                                      width, height);
   if (xm_dt->tempImage == NULL) {
      xm_dt->shm = 0;
166 167 168 169 170 171 172
      return;
   }


   mesaXErrorFlag = 0;
   old_handler = XSetErrorHandler(mesaHandleXError);
   /* This may trigger the X protocol error we're ready to catch: */
173 174
   XShmAttach(xm_dt->display, &xm_dt->shminfo);
   XSync(xm_dt->display, False);
175 176 177

   if (mesaXErrorFlag) {
      /* we are on a remote display, this error is normal, don't print it */
178
      XFlush(xm_dt->display);
179
      mesaXErrorFlag = 0;
180 181 182
      XDestroyImage(xm_dt->tempImage);
      xm_dt->tempImage = NULL;
      xm_dt->shm = 0;
183 184 185 186
      (void) XSetErrorHandler(old_handler);
      return;
   }

187
   xm_dt->shm = 1;
188 189 190
}


191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
static void
alloc_ximage(struct xm_displaytarget *xm_dt,
             struct xlib_drawable *xmb,
             unsigned width, unsigned height)
{
   if (xm_dt->shm) {
      alloc_shm_ximage(xm_dt, xmb, width, height);
      return;
   }

   xm_dt->tempImage = XCreateImage(xm_dt->display,
                                   xmb->visual,
                                   xmb->depth,
                                   ZPixmap, 0,
                                   NULL, width, height,
                                   8, 0);
}

209 210
static boolean
xm_is_displaytarget_format_supported( struct sw_winsys *ws,
211
                                      unsigned tex_usage,
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
                                      enum pipe_format format )
{
   /* TODO: check visuals or other sensible thing here */
   return TRUE;
}


static void *
xm_displaytarget_map(struct sw_winsys *ws,
                     struct sw_displaytarget *dt,
                     unsigned flags)
{
   struct xm_displaytarget *xm_dt = xm_displaytarget(dt);
   xm_dt->mapped = xm_dt->data;
   return xm_dt->mapped;
}

static void
xm_displaytarget_unmap(struct sw_winsys *ws,
                       struct sw_displaytarget *dt)
{
   struct xm_displaytarget *xm_dt = xm_displaytarget(dt);
   xm_dt->mapped = NULL;
}

static void
xm_displaytarget_destroy(struct sw_winsys *ws,
                         struct sw_displaytarget *dt)
{
   struct xm_displaytarget *xm_dt = xm_displaytarget(dt);

   if (xm_dt->data) {
      if (xm_dt->shminfo.shmid >= 0) {
         shmdt(xm_dt->shminfo.shmaddr);
         shmctl(xm_dt->shminfo.shmid, IPC_RMID, 0);
         
         xm_dt->shminfo.shmid = -1;
         xm_dt->shminfo.shmaddr = (char *) -1;
      }
251
      else {
252
         FREE(xm_dt->data);
253
      }
254 255
   }

256 257 258 259 260 261
   if (xm_dt->tempImage)
      XDestroyImage(xm_dt->tempImage);

   if (xm_dt->gc)
      XFreeGC(xm_dt->display, xm_dt->gc);

262 263 264 265 266 267 268 269
   FREE(xm_dt);
}


/**
 * Display/copy the image in the surface into the X window specified
 * by the XMesaBuffer.
 */
270
static void
271
xlib_sw_display(struct xlib_drawable *xlib_drawable,
272 273 274 275
                struct sw_displaytarget *dt)
{
   static boolean no_swap = 0;
   static boolean firsttime = 1;
276 277 278
   struct xm_displaytarget *xm_dt = xm_displaytarget(dt);
   Display *display = xm_dt->display;
   XImage *ximage;
279 280 281 282 283 284 285 286 287

   if (firsttime) {
      no_swap = getenv("SP_NO_RAST") != NULL;
      firsttime = 0;
   }

   if (no_swap)
      return;

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
   if (xm_dt->drawable != xlib_drawable->drawable) {
      if (xm_dt->gc) {
         XFreeGC( display, xm_dt->gc );
         xm_dt->gc = NULL;
      }

      if (xm_dt->tempImage) {
         XDestroyImage( xm_dt->tempImage );
         xm_dt->tempImage = NULL;
      }

      xm_dt->drawable = xlib_drawable->drawable;
   }

   if (xm_dt->tempImage == NULL) {
303 304 305 306 307 308 309 310 311
      assert(util_format_get_blockwidth(xm_dt->format) == 1);
      assert(util_format_get_blockheight(xm_dt->format) == 1);
      alloc_ximage(xm_dt, xlib_drawable,
                   xm_dt->stride / util_format_get_blocksize(xm_dt->format),
                   xm_dt->height);
      if (!xm_dt->tempImage)
         return;
   }

312 313 314 315 316
   if (xm_dt->gc == NULL) {
      xm_dt->gc = XCreateGC( display, xlib_drawable->drawable, 0, NULL );
      XSetFunction( display, xm_dt->gc, GXcopy );
   }

317 318 319 320 321 322
   if (xm_dt->shm)
   {
      ximage = xm_dt->tempImage;
      ximage->data = xm_dt->data;

      /* _debug_printf("XSHM\n"); */
323
      XShmPutImage(xm_dt->display, xlib_drawable->drawable, xm_dt->gc,
324 325
                   ximage, 0, 0, 0, 0, xm_dt->width, xm_dt->height, False);
   }
326
   else {
327 328 329 330 331 332 333 334 335 336 337 338 339 340
      /* display image in Window */
      ximage = xm_dt->tempImage;
      ximage->data = xm_dt->data;

      /* check that the XImage has been previously initialized */
      assert(ximage->format);
      assert(ximage->bitmap_unit);

      /* update XImage's fields */
      ximage->width = xm_dt->width;
      ximage->height = xm_dt->height;
      ximage->bytes_per_line = xm_dt->stride;

      /* _debug_printf("XPUT\n"); */
341
      XPutImage(xm_dt->display, xlib_drawable->drawable, xm_dt->gc,
342 343 344 345 346 347 348 349 350 351 352 353 354
                ximage, 0, 0, 0, 0, xm_dt->width, xm_dt->height);
   }
}

/**
 * Display/copy the image in the surface into the X window specified
 * by the XMesaBuffer.
 */
static void
xm_displaytarget_display(struct sw_winsys *ws,
                         struct sw_displaytarget *dt,
                         void *context_private)
{
355 356
   struct xlib_drawable *xlib_drawable = (struct xlib_drawable *)context_private;
   xlib_sw_display(xlib_drawable, dt);
357 358 359 360 361
}


static struct sw_displaytarget *
xm_displaytarget_create(struct sw_winsys *winsys,
362
                        unsigned tex_usage,
363 364 365 366 367
                        enum pipe_format format,
                        unsigned width, unsigned height,
                        unsigned alignment,
                        unsigned *stride)
{
Vinson Lee's avatar
Vinson Lee committed
368
   struct xm_displaytarget *xm_dt;
369 370 371 372 373 374
   unsigned nblocksy, size;

   xm_dt = CALLOC_STRUCT(xm_displaytarget);
   if(!xm_dt)
      goto no_xm_dt;

375
   xm_dt->display = ((struct xlib_sw_winsys *)winsys)->display;
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
   xm_dt->format = format;
   xm_dt->width = width;
   xm_dt->height = height;

   nblocksy = util_format_get_nblocksy(format, height);
   xm_dt->stride = align(util_format_get_stride(format, width), alignment);
   size = xm_dt->stride * nblocksy;

   if (!debug_get_bool_option("XLIB_NO_SHM", FALSE))
   {
      xm_dt->shminfo.shmid = -1;
      xm_dt->shminfo.shmaddr = (char *) -1;
      xm_dt->shm = TRUE;
         
      xm_dt->data = alloc_shm(xm_dt, size);
      if(!xm_dt->data)
         goto no_data;
   }

   if(!xm_dt->data) {
      xm_dt->data = align_malloc(size, alignment);
      if(!xm_dt->data)
         goto no_data;
   }

   *stride = xm_dt->stride;
   return (struct sw_displaytarget *)xm_dt;

no_data:
   FREE(xm_dt);
no_xm_dt:
   return NULL;
}


411 412
static struct sw_displaytarget *
xm_displaytarget_from_handle(struct sw_winsys *winsys,
413
                             const struct pipe_resource *templet,
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
                             struct winsys_handle *whandle,
                             unsigned *stride)
{
   assert(0);
   return NULL;
}


static boolean
xm_displaytarget_get_handle(struct sw_winsys *winsys,
                            struct sw_displaytarget *dt,
                            struct winsys_handle *whandle)
{
   assert(0);
   return FALSE;
}


432 433 434 435 436 437 438 439
static void
xm_destroy( struct sw_winsys *ws )
{
   FREE(ws);
}


struct sw_winsys *
440
xlib_create_sw_winsys( Display *display )
441
{
442
   struct xlib_sw_winsys *ws;
443

444
   ws = CALLOC_STRUCT(xlib_sw_winsys);
445 446 447
   if (!ws)
      return NULL;

448
   ws->display = display;
449 450 451 452 453
   ws->base.destroy = xm_destroy;

   ws->base.is_displaytarget_format_supported = xm_is_displaytarget_format_supported;

   ws->base.displaytarget_create = xm_displaytarget_create;
454 455
   ws->base.displaytarget_from_handle = xm_displaytarget_from_handle;
   ws->base.displaytarget_get_handle = xm_displaytarget_get_handle;
456 457 458 459 460 461 462 463 464
   ws->base.displaytarget_map = xm_displaytarget_map;
   ws->base.displaytarget_unmap = xm_displaytarget_unmap;
   ws->base.displaytarget_destroy = xm_displaytarget_destroy;

   ws->base.displaytarget_display = xm_displaytarget_display;

   return &ws->base;
}