libs/backends/GP_X11.c

   1 /*****************************************************************************
   2  * This file is part of gfxprim library.                                     *
   3  *                                                                           *
   4  * Gfxprim is free software; you can redistribute it and/or                  *
   5  * modify it under the terms of the GNU Lesser General Public                *
   6  * License as published by the Free Software Foundation; either              *
   7  * version 2.1 of the License, or (at your option) any later version.        *
   8  *                                                                           *
   9  * Gfxprim is distributed in the hope that it will be useful,                *
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  12  * Lesser General Public License for more details.                           *
  13  *                                                                           *
  14  * You should have received a copy of the GNU Lesser General Public          *
  15  * License along with gfxprim; if not, write to the Free Software            *
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor,                        *
  17  * Boston, MA  02110-1301  USA                                               *
  18  *                                                                           *
  19  * Copyright (C) 2009-2013 Cyril Hrubis <metan@ucw.cz>                       *
  20  *                                                                           *
  21  *****************************************************************************/
  22
  23 #include <string.h>
  24 #include <errno.h>
  25
  26 #include "../../config.h"
  27
  28 #include <core/GP_Debug.h>
  29 #include <core/GP_Common.h>
  30 #include <core/GP_Pixmap.h>
  31
  32 #ifdef HAVE_LIBX11
  33
  34 #include <X11/Xlib.h>
  35 #include <X11/Xutil.h>
  36 #include <X11/Xatom.h>
  37 #include <X11/Xmd.h>
  38
  39 #ifdef HAVE_X_SHM
  40 #include <sys/ipc.h>
  41 #include <sys/shm.h>
  42 #include <X11/extensions/XShm.h>
  43 #endif /* HAVE_X_SHM */
  44
  45 #include "backends/GP_X11.h"
  46
  47 #include "GP_X11_Conn.h"
  48 #include "GP_X11_Win.h"
  49 #include "GP_X11_Input.h"
  50
  51 static int resize_ximage(gp_backend *self, int w, int h);
  52 static int resize_shm_ximage(gp_backend *self, int w, int h);
  53
  54 static void putimage(struct x11_win *win, int x0, int y0, int x1, int y1)
  55 {
  56 #ifdef HAVE_X_SHM
  57         if (win->shm_flag)
  58                 XShmPutImage(win->dpy, win->win, DefaultGC(win->dpy, win->scr),
  59                              win->img, x0, y0, x0, y0, x1-x0+1, y1-y0+1, False);
  60         else
  61 #endif /* HAVE_X_SHM */
  62                 XPutImage(win->dpy, win->win, DefaultGC(win->dpy, win->scr),
  63                           win->img, x0, y0, x0, y0, x1-x0+1, y1-y0+1);
  64 }
  65
  66 static void x11_update_rect(gp_backend *self, gp_coord x0, gp_coord y0,
  67                             gp_coord x1, gp_coord y1)
  68 {
  69         struct x11_win *win = GP_BACKEND_PRIV(self);
  70
  71         GP_DEBUG(4, "Updating rect %ix%i-%ix%i", x0, y0, x1, y1);
  72
  73         if (win->resized_flag) {
  74                 GP_DEBUG(4, "Ignoring update rect, waiting for resize ack");
  75                 return;
  76         }
  77
  78         XLockDisplay(win->dpy);
  79
  80         putimage(win, x0, y0, x1, y1);
  81
  82         XFlush(win->dpy);
  83
  84         XUnlockDisplay(win->dpy);
  85 }
  86
  87 static void x11_flip(gp_backend *self)
  88 {
  89         struct x11_win *win = GP_BACKEND_PRIV(self);
  90         unsigned int w = self->pixmap->w;
  91         unsigned int h = self->pixmap->h;
  92
  93         GP_DEBUG(4, "Flipping pixmap");
  94
  95         if (win->resized_flag) {
  96                 GP_DEBUG(4, "Ignoring flip, waiting for resize ack");
  97                 return;
  98         }
  99
 100         XLockDisplay(win->dpy);
 101
 102         putimage(win, 0, 0, w - 1, h - 1);
 103
 104         XFlush(win->dpy);
 105
 106         XUnlockDisplay(win->dpy);
 107 }
 108
 109 static struct x11_win *last_win = NULL;
 110
 111 static void x11_ev(XEvent *ev)
 112 {
 113         struct x11_win *win;
 114
 115         /* Lookup for window */
 116         if (last_win == NULL || last_win->win != ev->xany.window) {
 117                 last_win = win_list_lookup(ev->xany.window);
 118
 119                 if (last_win == NULL) {
 120                         GP_WARN("Event for unknown window, ignoring.");
 121                         return;
 122                 }
 123         }
 124
 125         win = last_win;
 126
 127         struct gp_backend *self = GP_CONTAINER_OF(win, gp_backend, priv);
 128
 129         switch (ev->type) {
 130         case Expose:
 131                 GP_DEBUG(4, "Expose %ix%i-%ix%i %i",
 132                          ev->xexpose.x, ev->xexpose.y,
 133                          ev->xexpose.width, ev->xexpose.height,
 134                          ev->xexpose.count);
 135
 136                 if (win->resized_flag)
 137                         break;
 138
 139                 /* Safety measure */
 140                 if (ev->xexpose.x + ev->xexpose.width > (int)self->pixmap->w) {
 141                         GP_WARN("Expose x + w > pixmap->w");
 142                         break;
 143                 }
 144
 145                 if (ev->xexpose.y + ev->xexpose.height > (int)self->pixmap->h) {
 146                         GP_WARN("Expose y + h > pixmap->h");
 147                         break;
 148                 }
 149
 150                 /* Update the rectangle  */
 151                 x11_update_rect(self, ev->xexpose.x, ev->xexpose.y,
 152                                 ev->xexpose.x + ev->xexpose.width - 1,
 153                                 ev->xexpose.y + ev->xexpose.height - 1);
 154         break;
 155         case ConfigureNotify:
 156                 if (ev->xconfigure.width == (int)self->pixmap->w &&
 157                     ev->xconfigure.height == (int)self->pixmap->h)
 158                         break;
 159
 160                 if (ev->xconfigure.width == (int)win->new_w &&
 161                     ev->xconfigure.height == (int)win->new_h)
 162                         break;
 163
 164                 win->new_w = ev->xconfigure.width;
 165                 win->new_h = ev->xconfigure.height;
 166
 167                 GP_DEBUG(4, "Configure Notify %ux%u", win->new_w, win->new_h);
 168
 169                 /*  Window has been resized, set flag. */
 170                 win->resized_flag = 1;
 171         default:
 172                 //TODO: More accurate window w and h?
 173                 x11_input_event_put(&self->event_queue, ev,
 174                                     self->pixmap->w, self->pixmap->h);
 175         break;
 176         }
 177 }
 178
 179 static void x11_poll(gp_backend *self)
 180 {
 181         struct x11_win *win = GP_BACKEND_PRIV(self);
 182         XEvent ev;
 183
 184         XLockDisplay(win->dpy);
 185
 186         while (XPending(win->dpy)) {
 187                 XNextEvent(win->dpy, &ev);
 188                 x11_ev(&ev);
 189         }
 190
 191         XUnlockDisplay(win->dpy);
 192 }
 193
 194 #include <poll.h>
 195
 196 static void x11_wait(gp_backend *self)
 197 {
 198         struct pollfd fd = {.fd = self->fd, .events = POLLIN, .revents = 0};
 199         poll(&fd, 1, -1);
 200         x11_poll(self);
 201 }
 202
 203 static int resize_buffer(struct gp_backend *self, uint32_t w, uint32_t h)
 204 {
 205         struct x11_win *win = GP_BACKEND_PRIV(self);
 206
 207         if (win->shm_flag) {
 208                 if (resize_shm_ximage(self, w, h))
 209                         return 1;
 210         } else {
 211                 if (resize_ximage(self, w, h))
 212                         return 1;
 213         }
 214
 215         return 0;
 216 }
 217
 218 static int x11_set_attributes(struct gp_backend *self,
 219                               uint32_t w, uint32_t h,
 220                               const char *caption)
 221 {
 222         struct x11_win *win = GP_BACKEND_PRIV(self);
 223
 224         XLockDisplay(win->dpy);
 225
 226         if (caption != NULL) {
 227                 GP_DEBUG(3, "Setting window caption to '%s'", caption);
 228                 XmbSetWMProperties(win->dpy, win->win, caption, caption,
 229                                    NULL, 0, NULL, NULL, NULL);
 230         }
 231
 232         if (w != 0 && h != 0) {
 233                 if (win->fullscreen_flag) {
 234                         GP_DEBUG(1, "Ignoring resize request in fullscreen");
 235                         goto out;
 236                 }
 237                 GP_DEBUG(3, "Setting window size to %ux%u", w, h);
 238                 XResizeWindow(win->dpy, win->win, w, h);
 239         }
 240
 241         XFlush(win->dpy);
 242
 243 out:
 244         XUnlockDisplay(win->dpy);
 245         return 0;
 246 }
 247
 248 static int x11_resize_ack(struct gp_backend *self)
 249 {
 250         struct x11_win *win = GP_BACKEND_PRIV(self);
 251         int ret;
 252
 253         XLockDisplay(win->dpy);
 254
 255         GP_DEBUG(3, "Setting buffer size to %ux%u", win->new_w, win->new_h);
 256
 257         ret = resize_buffer(self, win->new_w, win->new_h);
 258
 259         win->resized_flag = 0;
 260
 261         if (!ret) {
 262                 gp_event_queue_set_screen_size(&self->event_queue,
 263                                                win->new_w, win->new_h);
 264         }
 265
 266         GP_DEBUG(3, "Done");
 267
 268         XUnlockDisplay(win->dpy);
 269
 270         return ret;
 271 }
 272
 273 static const char *visual_class_name(int class)
 274 {
 275         switch (class) {
 276         case StaticGray:
 277                 return "StaticGray";
 278         case GrayScale:
 279                 return "GrayScale";
 280         case StaticColor:
 281                 return "StaticColor";
 282         case PseudoColor:
 283                 return "PseudoColor";
 284         case TrueColor:
 285                 return "TrueColor";
 286         case DirectColor:
 287                 return "DirectColor";
 288         }
 289
 290         return "Unknown";
 291 }
 292
 293 static enum gp_pixel_type match_pixel_type(struct x11_win *win)
 294 {
 295         GP_DEBUG(1, "Matching image pixel type, visual=%s depth=%u",
 296                  visual_class_name(win->vis->class), win->img->bits_per_pixel);
 297
 298         if (win->vis->class == DirectColor || win->vis->class == TrueColor) {
 299                 return gp_pixel_rgb_match(win->img->red_mask,
 300                                           win->img->green_mask,
 301                                           win->img->blue_mask, 0x0,
 302                                           win->img->bits_per_pixel);
 303         }
 304
 305         GP_FATAL("Unsupported visual %s", visual_class_name(win->vis->class));
 306         return GP_PIXEL_UNKNOWN;
 307 }
 308
 309 #ifdef HAVE_X_SHM
 310
 311 static int create_shm_ximage(gp_backend *self, gp_size w, gp_size h)
 312 {
 313         struct x11_win *win = GP_BACKEND_PRIV(self);
 314         enum gp_pixel_type pixel_type;
 315
 316         if (XShmQueryExtension(win->dpy) == False) {
 317                 GP_DEBUG(1, "MIT SHM Extension not supported, "
 318                             "falling back to XImage");
 319                 return 1;
 320         }
 321
 322         if (self->pixmap == NULL)
 323                 GP_DEBUG(1, "Using MIT SHM Extension");
 324
 325         win->img = XShmCreateImage(win->dpy, win->vis, win->scr_depth,
 326                                    ZPixmap, NULL, &win->shminfo, w, h);
 327
 328         if (win->img == NULL) {
 329                 GP_WARN("Failed to create SHM XImage");
 330                 return 1;
 331         }
 332
 333         size_t size = win->img->bytes_per_line * win->img->height;
 334
 335         pixel_type = match_pixel_type(win);
 336
 337         if (pixel_type == GP_PIXEL_UNKNOWN) {
 338                 GP_DEBUG(1, "Unknown pixel type");
 339                 goto err0;
 340         }
 341
 342         win->shminfo.shmid = shmget(IPC_PRIVATE, size, 0600);
 343
 344         if (win->shminfo.shmid == -1) {
 345                 GP_WARN("Calling shmget() failed: %s", strerror(errno));
 346                 goto err0;
 347         }
 348
 349         win->shminfo.shmaddr = win->img->data = shmat(win->shminfo.shmid, 0, 0);
 350
 351         if (win->shminfo.shmaddr == (void *)-1) {
 352                 GP_WARN("Calling shmat() failed: %s", strerror(errno));
 353                 goto err1;
 354         }
 355
 356         /* Mark SHM for deletion after detach */
 357         if (shmctl(win->shminfo.shmid, IPC_RMID, 0)) {
 358                 GP_WARN("Calling shmctl(..., IPC_RMID), 0) failed: %s",
 359                          strerror(errno));
 360                 goto err2;
 361         }
 362
 363         win->shminfo.readOnly = False;
 364
 365         if (XShmAttach(win->dpy, &win->shminfo) == False) {
 366                 GP_WARN("XShmAttach failed");
 367                 goto err2;
 368         }
 369
 370         gp_pixmap_init(&win->pixmap, w, h, pixel_type, win->shminfo.shmaddr);
 371         win->pixmap.bytes_per_row = win->img->bytes_per_line;
 372
 373         self->pixmap = &win->pixmap;
 374
 375         win->shm_flag = 1;
 376
 377         //FIXME: Proper synchronization
 378         XSync(win->dpy, True);
 379
 380         return 0;
 381 err2:
 382         shmdt(win->shminfo.shmaddr);
 383 err1:
 384         shmctl(win->shminfo.shmid, IPC_RMID, 0);
 385 err0:
 386         XDestroyImage(win->img);
 387         return 1;
 388 }
 389
 390 static void destroy_shm_ximage(gp_backend *self)
 391 {
 392         struct x11_win *win = GP_BACKEND_PRIV(self);
 393
 394         XLockDisplay(win->dpy);
 395
 396         XShmDetach(win->dpy, &win->shminfo);
 397         XFlush(win->dpy);
 398         shmdt(win->shminfo.shmaddr);
 399         XDestroyImage(win->img);
 400         XFlush(win->dpy);
 401
 402         XUnlockDisplay(win->dpy);
 403 }
 404
 405 static int resize_shm_ximage(gp_backend *self, int w, int h)
 406 {
 407         struct x11_win *win = GP_BACKEND_PRIV(self);
 408         int ret;
 409
 410         GP_DEBUG(4, "Resizing XShmImage %ux%u -> %ux%u",
 411                  self->pixmap->w, self->pixmap->h, w, h);
 412
 413         XLockDisplay(win->dpy);
 414
 415         destroy_shm_ximage(self);
 416         ret = create_shm_ximage(self, w, h);
 417
 418         XUnlockDisplay(win->dpy);
 419
 420         return ret;
 421 }
 422
 423 #else
 424
 425 static int create_shm_ximage(gp_backend GP_UNUSED(*self),
 426                              gp_size GP_UNUSED(w), gp_size GP_UNUSED(h))
 427 {
 428         return 1;
 429 }
 430
 431 static void destroy_shm_ximage(gp_backend GP_UNUSED(*self))
 432 {
 433         GP_WARN("Stub called");
 434 }
 435
 436 static int resize_shm_ximage(gp_backend GP_UNUSED(*self),
 437                              int GP_UNUSED(w), int GP_UNUSED(h))
 438 {
 439         GP_WARN("Stub called");
 440         return 1;
 441 }
 442
 443 #endif /* HAVE_X_SHM */
 444
 445 static int create_ximage(gp_backend *self, gp_size w, gp_size h)
 446 {
 447         struct x11_win *win = GP_BACKEND_PRIV(self);
 448         enum gp_pixel_type pixel_type;
 449         int depth;
 450
 451         /* Get depth similiar to the default visual depth */
 452         switch (win->scr_depth) {
 453         case 32:
 454         case 24:
 455                 depth = 32;
 456         case 16:
 457                 depth = 16;
 458         case 8:
 459                 depth = 8;
 460         default:
 461                 /* TODO: better default */
 462                 depth = 32;
 463         }
 464
 465         GP_DEBUG(1, "Screen depth %i, using XImage depth %i",
 466                  win->scr_depth, depth);
 467
 468         win->img = XCreateImage(win->dpy, win->vis, win->scr_depth, ZPixmap, 0,
 469                                NULL, w, h, depth, 0);
 470
 471         if (win->img == NULL) {
 472                 GP_DEBUG(1, "Failed to create XImage");
 473                 goto err0;
 474         }
 475
 476         pixel_type = match_pixel_type(win);
 477
 478         if (pixel_type == GP_PIXEL_UNKNOWN) {
 479                 GP_DEBUG(1, "Unknown pixel type");
 480                 goto err1;
 481         }
 482
 483         self->pixmap = gp_pixmap_alloc(w, h, pixel_type);
 484
 485         if (self->pixmap == NULL) {
 486                 GP_DEBUG(1, "Malloc failed :(");
 487                 goto err1;
 488         }
 489
 490         win->shm_flag = 0;
 491         win->img->data = (char*)self->pixmap->pixels;
 492
 493         return 0;
 494 err1:
 495         XDestroyImage(win->img);
 496 err0:
 497         return 1;
 498 }
 499
 500 static void destroy_ximage(gp_backend *self)
 501 {
 502         struct x11_win *win = GP_BACKEND_PRIV(self);
 503
 504         gp_pixmap_free(self->pixmap);
 505         win->img->data = NULL;
 506         XDestroyImage(win->img);
 507 }
 508
 509 static int resize_ximage(gp_backend *self, int w, int h)
 510 {
 511         struct x11_win *win = GP_BACKEND_PRIV(self);
 512         XImage *img;
 513
 514         /* Create new X image */
 515         img = XCreateImage(win->dpy, win->vis, win->scr_depth, ZPixmap, 0, NULL,
 516                            w, h, win->img->bitmap_pad, 0);
 517
 518         if (img == NULL) {
 519                 GP_DEBUG(2, "XCreateImage failed");
 520                 return 1;
 521         }
 522
 523         /* Resize pixmap */
 524         if (gp_pixmap_resize(self->pixmap, w, h)) {
 525                 XDestroyImage(img);
 526                 return 1;
 527         }
 528
 529         /* Free old image */
 530         win->img->data = NULL;
 531         XDestroyImage(win->img);
 532
 533         /* Swap the pointers */
 534         img->data = (char*)self->pixmap->pixels;
 535         win->img = img;
 536
 537         return 0;
 538 }
 539
 540 static void window_close(gp_backend *self)
 541 {
 542         struct x11_win *win = GP_BACKEND_PRIV(self);
 543
 544         XLockDisplay(win->dpy);
 545
 546         if (win->shm_flag)
 547                 destroy_shm_ximage(self);
 548         else
 549                 destroy_ximage(self);
 550
 551         x11_win_close(win);
 552
 553         XUnlockDisplay(win->dpy);
 554 }
 555
 556 static void x11_exit(gp_backend *self)
 557 {
 558         struct x11_win *win = GP_BACKEND_PRIV(self);
 559
 560         GP_DEBUG(1, "Closing window %p", win);
 561
 562         if (win == last_win)
 563                 last_win = NULL;
 564
 565         window_close(self);
 566
 567         free(self);
 568 }
 569
 570 gp_backend *gp_x11_init(const char *display, int x, int y,
 571                         unsigned int w, unsigned int h,
 572                         const char *caption,
 573                         enum gp_x11_flags flags)
 574 {
 575         gp_backend *backend;
 576         struct x11_win *win;
 577
 578         backend = malloc(sizeof(gp_backend) +
 579                          sizeof(struct x11_win));
 580
 581         if (backend == NULL)
 582                 return NULL;
 583
 584         win = GP_BACKEND_PRIV(backend);
 585
 586         //XSynchronize(win->dpy, True);
 587
 588         /* Pack parameters and open window */
 589         struct x11_wreq wreq = {
 590                 .win = win,
 591                 .display = display,
 592                 .x = x,
 593                 .y = y,
 594                 .w = w,
 595                 .h = h,
 596                 .caption = caption,
 597                 .flags = flags,
 598         };
 599
 600         x11_win_open(&wreq);
 601
 602         if (win->win == None) {
 603                 //TODO: Error message?
 604                 GP_DEBUG(1, "Failed to create window");
 605                 goto err1;
 606         }
 607
 608         if (flags & GP_X11_FULLSCREEN)
 609                 x11_win_fullscreen(win, 1);
 610
 611         /* Init the event queue, once we know the window size */
 612         gp_event_queue_init(&backend->event_queue, wreq.w, wreq.h, 0);
 613
 614         backend->pixmap = NULL;
 615
 616         if ((flags & GP_X11_DISABLE_SHM || !x11_conn.local)
 617             || create_shm_ximage(backend, wreq.w, wreq.h)) {
 618                 if (create_ximage(backend, wreq.w, wreq.h))
 619                         goto err1;
 620         }
 621
 622         XFlush(win->dpy);
 623
 624         win->resized_flag = 0;
 625
 626         backend->name = "X11";
 627         backend->flip = x11_flip;
 628         backend->update_rect = x11_update_rect;
 629         backend->exit = x11_exit;
 630         backend->poll = x11_poll;
 631         backend->wait = x11_wait;
 632         backend->set_attrs = x11_set_attributes;
 633         backend->resize_ack = x11_resize_ack;
 634         backend->fd = XConnectionNumber(win->dpy);
 635         backend->timers = NULL;
 636
 637         return backend;
 638 err1:
 639         x11_close();
 640         free(backend);
 641         return NULL;
 642 }
 643
 644 void gp_x11_fullscreen(gp_backend *self, int mode)
 645 {
 646         struct x11_win *win = GP_BACKEND_PRIV(self);
 647
 648         x11_win_fullscreen(win, mode);
 649 }
 650
 651 #else
 652
 653 #include <backends/GP_Backend.h>
 654
 655 gp_backend *gp_x11_init(const char *GP_UNUSED(display),
 656                         int GP_UNUSED(x), int GP_UNUSED(y),
 657                         unsigned int GP_UNUSED(w),
 658                         unsigned int GP_UNUSED(h),
 659                         const char *GP_UNUSED(caption))
 660 {
 661         GP_FATAL("X11 support not compiled in");
 662         return NULL;
 663 }
 664
 665 void gp_x11_fullscreen(gp_backend *GP_UNUSED(self),
 666                        int GP_UNUSED(mode))
 667 {
 668         GP_FATAL("X11 support not compiled in");
 669 }
 670
 671 #endif /* HAVE_LIBX11 */
 672
 673 int gp_backend_is_x11(gp_backend *self)
 674 {
 675         return !strcmp(self->name, "X11");
 676 }