wrlib/xutil.c

   1 /* xutil.c - utility functions for X
   2  *
   3  * Raster graphics library
   4  *
   5  * Copyright (c) 1997-2003 Alfredo K. Kojima
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Library General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 2 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Library General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Library General Public
  18  *  License along with this library; if not, write to the Free
  19  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <config.h>
  23
  24
  25 #include <X11/Xlib.h>
  26 #include <X11/Xutil.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <assert.h>
  32
  33 #ifdef XSHM
  34 #include <sys/ipc.h>
  35 #include <sys/shm.h>
  36 #endif /* XSHM */
  37
  38 #include "wraster.h"
  39
  40
  41 #ifdef XSHM
  42
  43 static int shmError;
  44
  45 static int (*oldErrorHandler)();
  46
  47 static int
  48 errorHandler(Display *dpy, XErrorEvent *err)
  49 {
  50     shmError=1;
  51     if(err->error_code!=BadAccess)
  52         (*oldErrorHandler)(dpy, err);
  53
  54     return 0;
  55 }
  56
  57
  58 #endif
  59
  60
  61 RXImage*
  62 RCreateXImage(RContext *context, int depth, unsigned width, unsigned height)
  63 {
  64     RXImage *rximg;
  65     Visual *visual = context->visual;
  66
  67     rximg = malloc(sizeof(RXImage));
  68     if (!rximg) {
  69         RErrorCode = RERR_NOMEMORY;
  70         return NULL;
  71     }
  72
  73 #ifndef XSHM
  74     rximg->image = XCreateImage(context->dpy, visual, depth,
  75                                 ZPixmap, 0, NULL, width, height, 8, 0);
  76     if (!rximg->image) {
  77         free(rximg);
  78         RErrorCode = RERR_XERROR;
  79         return NULL;
  80     }
  81     rximg->image->data = malloc(rximg->image->bytes_per_line*height);
  82     if (!rximg->image->data) {
  83         XDestroyImage(rximg->image);
  84         free(rximg);
  85         RErrorCode = RERR_NOMEMORY;
  86         return NULL;
  87     }
  88
  89 #else /* XSHM */
  90     if (!context->attribs->use_shared_memory) {
  91     retry_without_shm:
  92
  93         context->attribs->use_shared_memory = 0;
  94         rximg->is_shared = 0;
  95         rximg->image = XCreateImage(context->dpy, visual, depth,
  96                                     ZPixmap, 0, NULL, width, height, 8, 0);
  97         if (!rximg->image) {
  98             free(rximg);
  99             RErrorCode = RERR_XERROR;
 100             return NULL;
 101         }
 102         rximg->image->data = malloc(rximg->image->bytes_per_line*height);
 103         if (!rximg->image->data) {
 104             XDestroyImage(rximg->image);
 105             free(rximg);
 106             RErrorCode = RERR_NOMEMORY;
 107             return NULL;
 108         }
 109     } else {
 110         rximg->is_shared = 1;
 111
 112         rximg->info.readOnly = False;
 113
 114         rximg->image = XShmCreateImage(context->dpy, visual, depth,
 115                                        ZPixmap, NULL, &rximg->info, width,
 116                                        height);
 117
 118         rximg->info.shmid = shmget(IPC_PRIVATE,
 119                                    rximg->image->bytes_per_line*height,
 120                                    IPC_CREAT|0777);
 121         if (rximg->info.shmid < 0) {
 122             context->attribs->use_shared_memory = 0;
 123             perror("wrlib: could not allocate shared memory segment");
 124             XDestroyImage(rximg->image);
 125             goto retry_without_shm;
 126         }
 127
 128         rximg->info.shmaddr = shmat(rximg->info.shmid, 0, 0);
 129         if (rximg->info.shmaddr == (void*)-1) {
 130             context->attribs->use_shared_memory = 0;
 131             if (shmctl(rximg->info.shmid, IPC_RMID, 0) < 0)
 132                 perror("wrlib: shmctl");
 133             perror("wrlib: could not allocate shared memory");
 134             XDestroyImage(rximg->image);
 135             goto retry_without_shm;
 136         }
 137
 138         shmError = 0;
 139         XSync(context->dpy, False);
 140         oldErrorHandler = XSetErrorHandler(errorHandler);
 141         XShmAttach(context->dpy, &rximg->info);
 142         XSync(context->dpy, False);
 143         XSetErrorHandler(oldErrorHandler);
 144
 145         rximg->image->data = rximg->info.shmaddr;
 146 /*      rximg->image->obdata = &(rximg->info);*/
 147
 148         if (shmError) {
 149             context->attribs->use_shared_memory = 0;
 150             XDestroyImage(rximg->image);
 151             if (shmdt(rximg->info.shmaddr) < 0)
 152                 perror("wrlib: shmdt");
 153             if (shmctl(rximg->info.shmid, IPC_RMID, 0) < 0)
 154                 perror("wrlib: shmctl");
 155 /*          printf("wrlib:error attaching shared memory segment to XImage\n");
 156  */
 157             goto retry_without_shm;
 158         }
 159     }
 160 #endif /* XSHM */
 161
 162     return rximg;
 163 }
 164
 165
 166 void
 167 RDestroyXImage(RContext *context, RXImage *rximage)
 168 {
 169 #ifndef XSHM
 170     XDestroyImage(rximage->image);
 171 #else /* XSHM */
 172     if (rximage->is_shared) {
 173         XSync(context->dpy, False);
 174         XShmDetach(context->dpy, &rximage->info);
 175         XDestroyImage(rximage->image);
 176         if (shmdt(rximage->info.shmaddr) < 0)
 177             perror("wrlib: shmdt");
 178         if (shmctl(rximage->info.shmid, IPC_RMID, 0) < 0)
 179             perror("wrlib: shmctl");
 180     } else {
 181         XDestroyImage(rximage->image);
 182     }
 183 #endif
 184     free(rximage);
 185 }
 186
 187
 188 static unsigned
 189 getDepth(Display *dpy, Drawable d)
 190 {
 191     Window w;
 192     int foo;
 193     unsigned bar;
 194     unsigned depth;
 195
 196     XGetGeometry(dpy, d, &w, &foo, &foo, &bar, &bar, &bar, &depth);
 197
 198     return depth;
 199 }
 200
 201
 202
 203 RXImage*
 204 RGetXImage(RContext *context, Drawable d, int x, int y,
 205            unsigned width, unsigned height)
 206 {
 207     RXImage *ximg = NULL;
 208
 209 #ifdef XSHM
 210     if (context->attribs->use_shared_memory && 0) {
 211         ximg = RCreateXImage(context, getDepth(context->dpy, d),
 212                              width, height);
 213
 214         if (ximg && !ximg->is_shared) {
 215             RDestroyXImage(context, ximg);
 216             ximg = NULL;
 217         }
 218         if (ximg) {
 219             XShmGetImage(context->dpy, d, ximg->image, x, y, AllPlanes);
 220         }
 221     }
 222     if (!ximg) {
 223         ximg = malloc(sizeof(RXImage));
 224         if (!ximg) {
 225             RErrorCode = RERR_NOMEMORY;
 226             return NULL;
 227         }
 228         ximg->is_shared = 0;
 229         ximg->image = XGetImage(context->dpy, d, x, y, width, height,
 230                                 AllPlanes, ZPixmap);
 231     }
 232     return ximg;
 233 #else /* !XSHM */
 234     ximg = malloc(sizeof(RXImage));
 235     if (!ximg) {
 236         RErrorCode = RERR_NOMEMORY;
 237         return NULL;
 238     }
 239
 240     ximg->image = XGetImage(context->dpy, d, x, y, width, height,
 241                             AllPlanes, ZPixmap);
 242
 243     return ximg;
 244 #endif /* !XSHM */
 245 }
 246
 247
 248 void
 249 RPutXImage(RContext *context, Drawable d, GC gc, RXImage *ximage, int src_x,
 250            int src_y, int dest_x, int dest_y,
 251            unsigned int width, unsigned int height)
 252 {
 253 #ifndef XSHM
 254     XPutImage(context->dpy, d, gc, ximage->image, src_x, src_y, dest_x,
 255               dest_y, width, height);
 256 #else
 257     if (ximage->is_shared) {
 258         XShmPutImage(context->dpy, d, gc, ximage->image, src_x, src_y,
 259                      dest_x, dest_y, width, height, False);
 260     } else {
 261         XPutImage(context->dpy, d, gc, ximage->image, src_x, src_y, dest_x,
 262                   dest_y, width, height);
 263     }
 264     XFlush(context->dpy);
 265 #endif /* XSHM */
 266 }
 267
 268
 269 #ifdef XSHM
 270 Pixmap
 271 R_CreateXImageMappedPixmap(RContext *context, RXImage *rximage)
 272 {
 273     Pixmap pix;
 274
 275     pix = XShmCreatePixmap(context->dpy, context->drawable,
 276                            rximage->image->data, &rximage->info,
 277                            rximage->image->width, rximage->image->height,
 278                            rximage->image->depth);
 279
 280     return pix;
 281 }
 282
 283 #endif /* XSHM */
 284