arch/all-hosted/hidd/x11/xshm.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 /* I have to put his in its own file because of include file
   7 conflicts between AROS includes and system includes */
   8
   9
  10 /* NOTE !!! All these functions need to be
  11   singlethreded by the LOCK_X11/UNLOCK_X11 macros form the outside
  12 */
  13
  14 #include <X11/Xlib.h>
  15 #include <X11/Xutil.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include "xshm.h"
  19 #include <aros/debug.h>
  20
  21 #include <aros/symbolsets.h>
  22
  23 /****************************************************************************************/
  24
  25 /* stegerg: maybe more safe, even if Unix malloc is used and not AROS malloc */
  26 #define NO_MALLOC 1
  27
  28 /****************************************************************************************/
  29
  30 #if NO_MALLOC
  31 #include <exec/memory.h>
  32 #include <proto/exec.h>
  33 #endif
  34
  35 /****************************************************************************************/
  36
  37 static void dummy_func()
  38 {
  39         return;
  40 }
  41
  42 /****************************************************************************************/
  43
  44 #if USE_XSHM
  45
  46 /****************************************************************************************/
  47
  48 #include <sys/shm.h>
  49 #include <sys/ipc.h>
  50 #include <X11/extensions/XShm.h>
  51
  52 #include "x11_hostlib.h"
  53
  54 #include <proto/hostlib.h>
  55
  56 static void *xext_handle = NULL;
  57 static void *shm_handle = NULL;
  58
  59 static struct {
  60     Status (*XShmDetach) ( Display* , XShmSegmentInfo* );
  61     Status (*XShmPutImage) ( Display* , Drawable , GC , XImage* , int , int , int , int , unsigned int , unsigned int , Bool );
  62     Status (*XShmGetImage) ( Display* , Drawable , XImage* , int , int , unsigned long );
  63     XImage * (*XShmCreateImage) ( Display* , Visual* , unsigned int , int , char* , XShmSegmentInfo* , unsigned int , unsigned int );
  64     Bool (*XShmQueryVersion) ( Display* , int* , int* , Bool* );
  65     Status (*XShmAttach) ( Display* , XShmSegmentInfo* );
  66 } xext_func;
  67
  68 static const char *xext_func_names[] = {
  69     "XShmDetach",
  70     "XShmPutImage",
  71     "XShmGetImage",
  72     "XShmCreateImage",
  73     "XShmQueryVersion",
  74     "XShmAttach"
  75 };
  76
  77 #define XEXT_SOFILE "libXext.so.6"
  78
  79 #define XEXTCALL(func,...) (xext_func.func(__VA_ARGS__))
  80
  81 extern void *x11_hostlib_load_so(const char *, const char **, int, void **);
  82
  83 static int xext_hostlib_init(void *libbase) {
  84     D(bug("[x11] xext hostlib init\n"));
  85
  86     if ((xext_handle = x11_hostlib_load_so(XEXT_SOFILE, xext_func_names, 6, (void **) &xext_func)) == NULL)
  87         return FALSE;
  88
  89     return TRUE;
  90 }
  91
  92 static int xext_hostlib_expunge(void *libbase) {
  93     D(bug("[x11] xext hostlib expunge\n"));
  94
  95     if (xext_handle != NULL)
  96         HostLib_Close(xext_handle, NULL);
  97
  98     return TRUE;
  99 }
 100
 101 ADD2INITLIB(xext_hostlib_init, 1)
 102 ADD2EXPUNGELIB(xext_hostlib_expunge, 1)
 103
 104
 105 /****************************************************************************************/
 106
 107 void *init_shared_mem(Display *display)
 108 {
 109     #warning "Also check if this is a local display"
 110
 111     XShmSegmentInfo *shminfo;
 112     int              xshm_major, xshm_minor;
 113     Bool             xshm_pixmaps;
 114
 115     if (XEXTCALL(XShmQueryVersion, display, &xshm_major, &xshm_minor, &xshm_pixmaps))
 116     {
 117         #if NO_MALLOC
 118         shminfo = (XShmSegmentInfo *)AllocVec(sizeof(*shminfo), MEMF_PUBLIC);
 119         #else
 120         shminfo = (XShmSegmentInfo *)malloc(sizeof(*shminfo));
 121         #endif
 122
 123         if (NULL != shminfo)
 124         {
 125             key_t key;
 126
 127             /*
 128              *  Try and get a key for us to use. The idea is to use a
 129              *  filename that isn't likely to change all that often. This
 130              *  is made somewhat easier since we must be run from the AROS
 131              *  root directory (atm). So, I shall choose the path "C",
 132              *  since the inode number isn't likely to change all that
 133              *  often.
 134              */
 135         #if 1
 136             key = IPC_PRIVATE;
 137         #else
 138             key = CCALL(ftok, "./C", 'A');
 139             if(key == -1)
 140             {
 141                 kprintf("Hmm, path \"./C\" doesn't seem to exist?\n");
 142                 key = IPC_PRIVATE;
 143             }
 144             else
 145             {
 146                 kprintf("Using shared memory key %d\n", key);
 147             }
 148         #endif
 149             memset(shminfo, 0, sizeof (*shminfo));
 150
 151             /* Allocate shared memory */
 152             shminfo->shmid = CCALL(shmget, key, XSHM_MEMSIZE, IPC_CREAT|0777);
 153
 154             if (shminfo->shmid >= 0)
 155             {
 156                 /* Attach the mem to our process */
 157                 shminfo->shmaddr = CCALL(shmat, shminfo->shmid, NULL, 0);
 158                 if (NULL != shminfo->shmaddr)
 159                 {
 160                     shminfo->readOnly = False;
 161                     if (XEXTCALL(XShmAttach, display, shminfo))
 162                     {
 163                         return shminfo;
 164
 165                     }
 166                     CCALL(shmdt, shminfo->shmaddr);
 167
 168                 }
 169                 CCALL(shmctl, shminfo->shmid, IPC_RMID, NULL);
 170             }
 171         #if NO_MALLOC
 172             FreeVec(shminfo);
 173         #else
 174             free(shminfo);
 175         #endif
 176
 177         }
 178
 179     }   /* If has XShm extension */
 180
 181     return NULL;
 182
 183 }
 184
 185 /****************************************************************************************/
 186
 187 void cleanup_shared_mem(Display *display, void *meminfo)
 188 {
 189     XShmSegmentInfo *shminfo = (XShmSegmentInfo *)meminfo;
 190
 191     if (NULL == meminfo)
 192         return;
 193
 194     XEXTCALL(XShmDetach, display, shminfo);
 195     CCALL(shmdt, shminfo->shmaddr);
 196     CCALL(shmctl, shminfo->shmid, IPC_RMID, 0);
 197
 198 #if NO_MALLOC
 199     FreeVec(shminfo);
 200 #else
 201     free(shminfo);
 202 #endif
 203
 204 }
 205
 206 /****************************************************************************************/
 207
 208 XImage *create_xshm_ximage(Display *display, Visual *visual, int depth, int format,
 209                            int width, int height, void *xshminfo)
 210 {
 211     XShmSegmentInfo *shminfo;
 212     XImage          *image;
 213
 214     shminfo = (XShmSegmentInfo *)xshminfo;
 215
 216     image = XEXTCALL(XShmCreateImage, display, visual, depth, format, shminfo->shmaddr,
 217                                       shminfo, width, height);
 218
 219     return image;
 220 }
 221
 222 /****************************************************************************************/
 223
 224 void put_xshm_ximage(Display *display, Drawable d, GC gc, XImage *image,
 225                      int xsrc,  int ysrc, int xdest, int ydest,
 226                      int width, int height, Bool send_event)
 227 {
 228     XEXTCALL(XShmPutImage, display, d, gc, image, xsrc, ysrc, xdest, ydest,
 229                            width, height, send_event);
 230     XCALL(XSync, display, False);
 231 }
 232
 233 /****************************************************************************************/
 234
 235 void get_xshm_ximage(Display *display, Drawable d, XImage *image, int x, int y)
 236 {
 237     XCALL(XSync, display, False);
 238     XEXTCALL(XShmGetImage, display, d, image, x, y, AllPlanes);
 239 }
 240
 241 /****************************************************************************************/
 242
 243 void destroy_xshm_ximage(XImage *image)
 244 {
 245     XDestroyImage(image);
 246 }
 247
 248 /****************************************************************************************/
 249
 250 #endif /* USE_XSHM */
 251
 252 /****************************************************************************************/