473 lines
17 KiB
C
473 lines
17 KiB
C
|
/* X11 specific code and features */
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdint.h>
|
||
|
|
#include <stdbool.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <limits.h>
|
||
|
|
#include <errno.h>
|
||
|
|
#include <time.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
|
||
|
|
#include <sys/ipc.h>
|
||
|
|
#include <sys/shm.h>
|
||
|
|
#include <sys/mman.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <sys/stat.h>
|
||
|
|
|
||
|
|
#include <X11/Xlib.h>
|
||
|
|
#include <X11/Xutil.h>
|
||
|
|
#include <X11/Xatom.h>
|
||
|
|
#include <X11/extensions/Xcomposite.h>
|
||
|
|
#include <X11/extensions/XShm.h>
|
||
|
|
|
||
|
|
#include "glad.h"
|
||
|
|
|
||
|
|
#define GLAVA_RDX11
|
||
|
|
#include "render.h"
|
||
|
|
#include "xwin.h"
|
||
|
|
|
||
|
|
/* BMP Image header */
|
||
|
|
struct __attribute__((packed)) bmp_header {
|
||
|
|
uint16_t header;
|
||
|
|
uint32_t size;
|
||
|
|
uint16_t reserved0, reserved1;
|
||
|
|
uint32_t offset;
|
||
|
|
/* BITMAPINFOHEADER */
|
||
|
|
uint32_t header_size, width, height;
|
||
|
|
uint16_t planes, bits_per_pixel;
|
||
|
|
uint32_t compression, image_size, hres, vres, colors, colors_used;
|
||
|
|
};
|
||
|
|
|
||
|
|
#define BMP_HEADER_MAGIC 0x4D42
|
||
|
|
#define BMP_BITFIELDS 3
|
||
|
|
|
||
|
|
void xwin_assign_icon_bmp(struct gl_wcb* wcb, void* impl, const char* path) {
|
||
|
|
int fd = open(path, O_RDONLY);
|
||
|
|
if (fd == -1) {
|
||
|
|
fprintf(stderr, "failed to load icon '%s': %s\n", path, strerror(errno));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
Window w = wcb->get_x11_window(impl);
|
||
|
|
struct stat st;
|
||
|
|
fstat(fd, &st);
|
||
|
|
const struct bmp_header* header = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
|
||
|
|
if (header->header != BMP_HEADER_MAGIC) {
|
||
|
|
fprintf(stderr, "failed to load icon '%s': invalid BMP header.\n", path);
|
||
|
|
close(fd);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (header->bits_per_pixel != 32) {
|
||
|
|
fprintf(stderr, "failed to load icon '%s': wrong bit depth (%d).\n",
|
||
|
|
path, (int) header->bits_per_pixel);
|
||
|
|
close(fd);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (header->planes != 1 || header->compression != BMP_BITFIELDS) {
|
||
|
|
fprintf(stderr, "failed to load icon '%s': invalid BMP format, requires RGBA bitfields.\n", path);
|
||
|
|
close(fd);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Obtain image data pointer from offset */
|
||
|
|
const char* data = (const char*) (((const uint8_t*) header) + header->offset);
|
||
|
|
|
||
|
|
/* Assign icon using the older WMHints. Most window managers don't actually use this. */
|
||
|
|
XWMHints hints = {};
|
||
|
|
hints.flags = IconPixmapHint;
|
||
|
|
hints.icon_pixmap = XCreateBitmapFromData(d, w, data, header->width, header->height);
|
||
|
|
XSetWMHints(d, w, &hints);
|
||
|
|
|
||
|
|
/* To assign the icon property we need to convert the image data to `unsigned long`, which
|
||
|
|
can be 64-bits and padded depending on the architecture. Additionally we need to flip the
|
||
|
|
Y-axis due to how BMP data is stored. */
|
||
|
|
size_t sz = header->width * header->height;
|
||
|
|
size_t asz = sz + 2;
|
||
|
|
unsigned long* off = malloc(asz * sizeof(unsigned long));
|
||
|
|
for (size_t x = 0; x < header->width; ++x) {
|
||
|
|
for (size_t y = 0; y < header->height; ++y) {
|
||
|
|
off[x + (((header->height - 1) - y) * header->height) + 2]
|
||
|
|
= ((const uint32_t*) data)[x + (y * header->height)];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/* The first two elements represent the icon dimensions */
|
||
|
|
off[0] = header->width;
|
||
|
|
off[1] = header->height;
|
||
|
|
XChangeProperty(d, w, XInternAtom(d, "_NET_WM_ICON", true),
|
||
|
|
XA_CARDINAL, 32, PropModeReplace, (const unsigned char*) off, asz);
|
||
|
|
free(off);
|
||
|
|
close(fd);
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Note: currently unused */
|
||
|
|
Window* __attribute__ ((unused)) xwin_get_desktop_layer(struct gl_wcb* wcb) {
|
||
|
|
static Window desktop;
|
||
|
|
static bool searched = false;
|
||
|
|
if (!searched) {
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
Atom class = XInternAtom(d, "WM_CLASS", false);
|
||
|
|
desktop = DefaultRootWindow(d);
|
||
|
|
Window _ignored, * children;
|
||
|
|
unsigned int nret;
|
||
|
|
XQueryTree(d, desktop, &_ignored, &_ignored, &children, &nret);
|
||
|
|
if (children) {
|
||
|
|
for (unsigned int t = 0; t < nret; ++t) {
|
||
|
|
char* name;
|
||
|
|
XFetchName(d, children[t], &name);
|
||
|
|
if (name) {
|
||
|
|
/* Mutter-based window managers */
|
||
|
|
if (!strcmp(name, "mutter guard window")) {
|
||
|
|
printf("Reparenting to mutter guard window instead of root window\n");
|
||
|
|
desktop = children[t];
|
||
|
|
t = nret; /* break after */
|
||
|
|
}
|
||
|
|
XFree(name);
|
||
|
|
}
|
||
|
|
unsigned long bytes;
|
||
|
|
XTextProperty text = {};
|
||
|
|
char** list;
|
||
|
|
int list_sz;
|
||
|
|
/* Get WM_CLASS property */
|
||
|
|
if (Success == XGetWindowProperty(d, children[t], class, 0, 512, false, AnyPropertyType,
|
||
|
|
&text.encoding, &text.format, &text.nitems, &bytes,
|
||
|
|
&text.value)) {
|
||
|
|
/* decode string array */
|
||
|
|
if (Success == XmbTextPropertyToTextList(d, &text, &list, &list_sz)) {
|
||
|
|
if (list_sz >= 1 && !strcmp(list[0], "plasmashell")) {
|
||
|
|
desktop = children[t];
|
||
|
|
t = nret;
|
||
|
|
}
|
||
|
|
XFreeStringList(list);
|
||
|
|
}
|
||
|
|
XFree(text.value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
XFree(children);
|
||
|
|
}
|
||
|
|
searched = true;
|
||
|
|
}
|
||
|
|
return &desktop;
|
||
|
|
}
|
||
|
|
|
||
|
|
void xwin_wait_for_wm(void) {
|
||
|
|
Display* d = XOpenDisplay(0);
|
||
|
|
|
||
|
|
Atom check = None;
|
||
|
|
bool exists = false;
|
||
|
|
struct timespec tv = { .tv_sec = 0, .tv_nsec = 50 * 1000000 };
|
||
|
|
|
||
|
|
do {
|
||
|
|
if (check == None) {
|
||
|
|
check = XInternAtom(d, "_NET_SUPPORTING_WM_CHECK", true);
|
||
|
|
}
|
||
|
|
if (check) {
|
||
|
|
int num_prop, idx;
|
||
|
|
Atom* props = XListProperties(d, DefaultRootWindow(d), &num_prop);
|
||
|
|
for (idx = 0; idx < num_prop; ++idx) {
|
||
|
|
if (props[idx] == check) {
|
||
|
|
exists = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
XFree(props);
|
||
|
|
}
|
||
|
|
if (!exists) nanosleep(&tv, NULL);
|
||
|
|
} while (!exists);
|
||
|
|
|
||
|
|
XCloseDisplay(d);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char* xwin_detect_wm(struct gl_wcb* wcb) {
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
Atom check = XInternAtom(d, "_NET_SUPPORTING_WM_CHECK", false);
|
||
|
|
Atom name = XInternAtom(d, "_NET_WM_NAME", false);
|
||
|
|
Atom type = XInternAtom(d, "UTF8_STRING", false);
|
||
|
|
union {
|
||
|
|
Atom a;
|
||
|
|
int i;
|
||
|
|
long unsigned int lui;
|
||
|
|
} ignored;
|
||
|
|
|
||
|
|
unsigned long nitems = 0;
|
||
|
|
unsigned char* wm_name = NULL;
|
||
|
|
Window* wm_check;
|
||
|
|
if (Success != XGetWindowProperty(d, DefaultRootWindow(d), check, 0, 1024, false, XA_WINDOW,
|
||
|
|
&ignored.a, &ignored.i, &nitems, &ignored.lui, (unsigned char**) &wm_check)) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (nitems > 0 && Success == XGetWindowProperty(d, *wm_check, name, 0, 1024, false, type,
|
||
|
|
&ignored.a, &ignored.i, &nitems, &ignored.lui, &wm_name)) {
|
||
|
|
if (nitems > 0) {
|
||
|
|
static const char* wm_name_store = NULL;
|
||
|
|
if (wm_name_store) XFree((unsigned char*) wm_name_store);
|
||
|
|
wm_name_store = (const char*) wm_name;
|
||
|
|
} else {
|
||
|
|
XFree(wm_name);
|
||
|
|
wm_name = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
XFree(wm_check);
|
||
|
|
|
||
|
|
return (const char*) wm_name;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static int stub_handler(Display* d, XErrorEvent* e) { return 0; }
|
||
|
|
|
||
|
|
bool xwin_should_render(struct gl_wcb* wcb, void* impl) {
|
||
|
|
bool ret = true, should_close = false;
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
if (!d) {
|
||
|
|
d = XOpenDisplay(0);
|
||
|
|
should_close = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
Atom prop = XInternAtom(d, "_NET_ACTIVE_WINDOW", true);
|
||
|
|
Atom fullscreen = XInternAtom(d, "_NET_WM_STATE_FULLSCREEN", true);
|
||
|
|
|
||
|
|
Atom actual_type;
|
||
|
|
int actual_format, t;
|
||
|
|
unsigned long nitems, bytes_after;
|
||
|
|
unsigned char* data = NULL;
|
||
|
|
|
||
|
|
XSetErrorHandler(stub_handler); /* dummy error handler */
|
||
|
|
|
||
|
|
if (Success != XGetWindowProperty(d, DefaultRootWindow(d), prop, 0, 1, false, AnyPropertyType,
|
||
|
|
&actual_type, &actual_format, &nitems, &bytes_after, &data)) {
|
||
|
|
goto close; /* if an error occurs here, the WM probably isn't EWMH compliant */
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!nitems)
|
||
|
|
goto close;
|
||
|
|
|
||
|
|
Window active = ((Window*) data)[0];
|
||
|
|
|
||
|
|
prop = XInternAtom(d, "_NET_WM_STATE", true);
|
||
|
|
|
||
|
|
if (data) {
|
||
|
|
XFree(data);
|
||
|
|
data = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Success != XGetWindowProperty(d, active, prop, 0, LONG_MAX, false, AnyPropertyType,
|
||
|
|
&actual_type, &actual_format, &nitems, &bytes_after, &data)) {
|
||
|
|
goto close; /* some WMs are a little slow on creating _NET_WM_STATE, so errors may occur here */
|
||
|
|
}
|
||
|
|
for (t = 0; t < nitems; ++t) {
|
||
|
|
if (fullscreen == ((Atom*) data)[t]) {
|
||
|
|
ret = false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
close:
|
||
|
|
if (data)
|
||
|
|
XFree(data);
|
||
|
|
if (should_close)
|
||
|
|
XCloseDisplay(d);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Create string copy on stack with upcase chars */
|
||
|
|
#define S_UPPER(in, out) char out[strlen(in) + 1]; \
|
||
|
|
do { \
|
||
|
|
for (size_t t = 0; t < sizeof(out) / sizeof(char); ++t) { \
|
||
|
|
char c = in[t]; \
|
||
|
|
switch (c) { \
|
||
|
|
case 'a' ... 'z': c -= 'a' - 'A'; \
|
||
|
|
default: out[t] = c; \
|
||
|
|
} \
|
||
|
|
} \
|
||
|
|
} while (0)
|
||
|
|
|
||
|
|
static void xwin_changeatom(struct gl_wcb* wcb, void* impl, const char* type,
|
||
|
|
const char* atom, const char* fmt, int mode) {
|
||
|
|
Window w = wcb->get_x11_window(impl);
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
Atom wtype = XInternAtom(d, atom, false);
|
||
|
|
char buf[256];
|
||
|
|
snprintf(buf, sizeof(buf), fmt, type);
|
||
|
|
Atom desk = XInternAtom(d, buf, false);
|
||
|
|
XChangeProperty(d, w, wtype, XA_ATOM, 32, mode, (unsigned char*) &desk, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Set window types defined by the EWMH standard, possible values:
|
||
|
|
-> "desktop", "dock", "toolbar", "menu", "utility", "splash", "dialog", "normal" */
|
||
|
|
bool xwin_settype(struct gl_wcb* wcb, void* impl, const char* rtype) {
|
||
|
|
S_UPPER(rtype, type);
|
||
|
|
if (type[0] != '!') {
|
||
|
|
xwin_changeatom(wcb, impl, type, "_NET_WM_WINDOW_TYPE",
|
||
|
|
"_NET_WM_WINDOW_TYPE_%s", PropModeReplace);
|
||
|
|
}
|
||
|
|
return !strcmp(type, "DESKTOP");
|
||
|
|
}
|
||
|
|
|
||
|
|
void xwin_addstate(struct gl_wcb* wcb, void* impl, const char* rstate) {
|
||
|
|
S_UPPER(rstate, state);
|
||
|
|
if (strcmp(state, "PINNED"))
|
||
|
|
xwin_changeatom(wcb, impl, state, "_NET_WM_STATE", "_NET_WM_STATE_%s", PropModeAppend);
|
||
|
|
else
|
||
|
|
xwin_setdesktop(wcb, impl, XWIN_ALL_DESKTOPS);
|
||
|
|
}
|
||
|
|
|
||
|
|
void xwin_setdesktop(struct gl_wcb* wcb, void* impl, unsigned long desktop) {
|
||
|
|
Window w = wcb->get_x11_window(impl);
|
||
|
|
Display* d = wcb->get_x11_display();
|
||
|
|
Atom wtype = XInternAtom(d, "_NET_WM_DESKTOP", false);
|
||
|
|
XChangeProperty(d, w, wtype, XA_CARDINAL, 32, PropModeReplace, (unsigned char*) &desktop, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
static Drawable get_drawable(Display* d, Window w) {
|
||
|
|
Drawable p;
|
||
|
|
Atom act_type;
|
||
|
|
int act_format;
|
||
|
|
unsigned long nitems, bytes_after;
|
||
|
|
unsigned char *data = NULL;
|
||
|
|
Atom id;
|
||
|
|
|
||
|
|
id = XInternAtom(d, "_XROOTPMAP_ID", False);
|
||
|
|
|
||
|
|
if (XGetWindowProperty(d, w, id, 0, 1, False, XA_PIXMAP,
|
||
|
|
&act_type, &act_format, &nitems, &bytes_after,
|
||
|
|
&data) == Success && data) {
|
||
|
|
p = *((Pixmap *) data);
|
||
|
|
XFree(data);
|
||
|
|
} else {
|
||
|
|
p = w;
|
||
|
|
}
|
||
|
|
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int xwin_copyglbg(struct glava_renderer* rd, unsigned int tex) {
|
||
|
|
GLuint texture = (GLuint) tex;
|
||
|
|
if (!texture)
|
||
|
|
glGenTextures(1, &texture);
|
||
|
|
glBindTexture(GL_TEXTURE_2D, texture);
|
||
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||
|
|
|
||
|
|
int x, y, w, h;
|
||
|
|
rd_get_wcb(rd)->get_fbsize(rd_get_impl_window(rd), &w, &h);
|
||
|
|
rd_get_wcb(rd)->get_pos(rd_get_impl_window(rd), &x, &y);
|
||
|
|
XColor c;
|
||
|
|
Display* d = rd_get_wcb(rd)->get_x11_display();
|
||
|
|
Drawable src = get_drawable(d, DefaultRootWindow(d));
|
||
|
|
bool use_shm = XShmQueryExtension(d);
|
||
|
|
|
||
|
|
/* Obtain section of root pixmap */
|
||
|
|
|
||
|
|
XShmSegmentInfo shminfo;
|
||
|
|
Visual* visual = DefaultVisual(d, DefaultScreen(d));
|
||
|
|
XVisualInfo match = { .visualid = XVisualIDFromVisual(visual) };
|
||
|
|
int nret;
|
||
|
|
XVisualInfo* info = XGetVisualInfo(d, VisualIDMask, &match, &nret);
|
||
|
|
XImage* image;
|
||
|
|
if (use_shm) {
|
||
|
|
image = XShmCreateImage(d, visual, info->depth, ZPixmap, NULL,
|
||
|
|
&shminfo, (unsigned int) w, (unsigned int) h);
|
||
|
|
if ((shminfo.shmid = shmget(IPC_PRIVATE, image->bytes_per_line * image->height,
|
||
|
|
IPC_CREAT | 0777)) == -1) {
|
||
|
|
fprintf(stderr, "shmget() failed: %s\n", strerror(errno));
|
||
|
|
glava_abort();
|
||
|
|
}
|
||
|
|
shminfo.shmaddr = image->data = shmat(shminfo.shmid, 0, 0);
|
||
|
|
shminfo.readOnly = false;
|
||
|
|
XShmAttach(d, &shminfo);
|
||
|
|
XShmGetImage(d, src, image, x, y, AllPlanes);
|
||
|
|
} else {
|
||
|
|
image = XGetImage(d, src, x, y, (unsigned int) w, (unsigned int) h,
|
||
|
|
AllPlanes, ZPixmap);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Try to convert pixel bit depth to OpenGL storage format. The following formats\
|
||
|
|
will need intermediate conversion before OpenGL can accept the data:
|
||
|
|
|
||
|
|
- 8-bit pixel formats (retro displays, low-bandwidth virtual displays)
|
||
|
|
- 36-bit pixel formats (rare deep color displays) */
|
||
|
|
|
||
|
|
if (image) {
|
||
|
|
bool invalid = false, aligned = false;
|
||
|
|
GLenum type = 0;
|
||
|
|
switch (image->bits_per_pixel) {
|
||
|
|
case 16:
|
||
|
|
switch (image->depth) {
|
||
|
|
case 12: type = GL_UNSIGNED_SHORT_4_4_4_4; break; /* 12-bit (rare) */
|
||
|
|
case 15: type = GL_UNSIGNED_SHORT_5_5_5_1; break; /* 15-bit, hi-color */
|
||
|
|
case 16: /* 16-bit, hi-color */
|
||
|
|
type = GL_UNSIGNED_SHORT_5_6_5;
|
||
|
|
aligned = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 32:
|
||
|
|
switch (image->depth) {
|
||
|
|
case 24: type = GL_UNSIGNED_BYTE; break; /* 24-bit, true color */
|
||
|
|
case 30: type = GL_UNSIGNED_INT_10_10_10_2; break; /* 30-bit, deep color */
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case 64:
|
||
|
|
if (image->depth == 48) /* 48-bit deep color */
|
||
|
|
type = GL_UNSIGNED_SHORT;
|
||
|
|
else goto invalid;
|
||
|
|
break;
|
||
|
|
/* >64-bit formats */
|
||
|
|
case 128:
|
||
|
|
if (image->depth == 96)
|
||
|
|
type = GL_UNSIGNED_INT;
|
||
|
|
else goto invalid;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
invalid: invalid = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t* buf;
|
||
|
|
if (invalid) {
|
||
|
|
abort();
|
||
|
|
/* Manual reformat (slow) */
|
||
|
|
buf = malloc(4 * w * h);
|
||
|
|
int xi, yi;
|
||
|
|
Colormap map = DefaultColormap(d, DefaultScreen(d));
|
||
|
|
for (yi = 0; yi < h; ++yi) {
|
||
|
|
for (xi = 0; xi < w; ++xi) {
|
||
|
|
c.pixel = XGetPixel(image, xi, yi);
|
||
|
|
XQueryColor(d, map, &c);
|
||
|
|
size_t base = (xi + (yi * w)) * 4;
|
||
|
|
buf[base + 0] = c.red / 256;
|
||
|
|
buf[base + 1] = c.green / 256;
|
||
|
|
buf[base + 2] = c.blue / 256;
|
||
|
|
buf[base + 3] = 255;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);
|
||
|
|
free(buf);
|
||
|
|
} else {
|
||
|
|
/* Use image data directly. The alpha value is garbage/unassigned data, but
|
||
|
|
we need to read it because X11 keeps pixel data aligned */
|
||
|
|
buf = (uint8_t*) image->data;
|
||
|
|
/* Data could be 2, 4, or 8 byte aligned, the RGBA format and type (depth)
|
||
|
|
already ensures reads will be properly aligned across scanlines */
|
||
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||
|
|
GLenum format = image->bitmap_bit_order == LSBFirst ?
|
||
|
|
(!aligned ? GL_BGRA : GL_BGR) :
|
||
|
|
(!aligned ? GL_RGBA : GL_RGB);
|
||
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, format, type, buf);
|
||
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 4); /* restore default */
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (use_shm) {
|
||
|
|
XShmDetach(d, &shminfo);
|
||
|
|
shmdt(shminfo.shmaddr);
|
||
|
|
shmctl(shminfo.shmid, IPC_RMID, NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (image) XDestroyImage(image);
|
||
|
|
XFree(info);
|
||
|
|
|
||
|
|
return texture;
|
||
|
|
}
|