1 /* Copyright 2011-2016 Pierre Ossman for Cendio AB
2 *
3 * This is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This software is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this software; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
16 * USA.
17 */
18
19 #include <assert.h>
20
21 #if !defined(WIN32) && !defined(__APPLE__)
22 #include <sys/ipc.h>
23 #include <sys/shm.h>
24 #endif
25
26 #include <FL/Fl.H>
27 #include <FL/x.H>
28
29 #include <rfb/LogWriter.h>
30 #include <rdr/Exception.h>
31
32 #include "PlatformPixelBuffer.h"
33
34 static rfb::LogWriter vlog("PlatformPixelBuffer");
35
PlatformPixelBuffer(int width,int height)36 PlatformPixelBuffer::PlatformPixelBuffer(int width, int height) :
37 FullFramePixelBuffer(rfb::PixelFormat(32, 24, false, true,
38 255, 255, 255, 16, 8, 0),
39 0, 0, NULL, 0),
40 Surface(width, height)
41 #if !defined(WIN32) && !defined(__APPLE__)
42 , shminfo(NULL), xim(NULL)
43 #endif
44 {
45 #if !defined(WIN32) && !defined(__APPLE__)
46 if (!setupShm(width, height)) {
47 xim = XCreateImage(fl_display, CopyFromParent, 32,
48 ZPixmap, 0, 0, width, height, 32, 0);
49 if (!xim)
50 throw rdr::Exception("XCreateImage");
51
52 xim->data = (char*)malloc(xim->bytes_per_line * xim->height);
53 if (!xim->data)
54 throw rdr::Exception("malloc");
55
56 vlog.debug("Using standard XImage");
57 }
58
59 setBuffer(width, height, (rdr::U8*)xim->data,
60 xim->bytes_per_line / (getPF().bpp/8));
61
62 // On X11, the Pixmap backing this Surface is uninitialized.
63 clear(0, 0, 0);
64 #else
65 setBuffer(width, height, (rdr::U8*)Surface::data, width);
66 #endif
67 }
68
~PlatformPixelBuffer()69 PlatformPixelBuffer::~PlatformPixelBuffer()
70 {
71 #if !defined(WIN32) && !defined(__APPLE__)
72 if (shminfo) {
73 vlog.debug("Freeing shared memory XImage");
74 XShmDetach(fl_display, shminfo);
75 shmdt(shminfo->shmaddr);
76 shmctl(shminfo->shmid, IPC_RMID, 0);
77 delete shminfo;
78 shminfo = NULL;
79 }
80
81 // XDestroyImage() will free(xim->data) if appropriate
82 if (xim)
83 XDestroyImage(xim);
84 xim = NULL;
85 #endif
86 }
87
commitBufferRW(const rfb::Rect & r)88 void PlatformPixelBuffer::commitBufferRW(const rfb::Rect& r)
89 {
90 FullFramePixelBuffer::commitBufferRW(r);
91 mutex.lock();
92 damage.assign_union(rfb::Region(r));
93 mutex.unlock();
94 }
95
getDamage(void)96 rfb::Rect PlatformPixelBuffer::getDamage(void)
97 {
98 rfb::Rect r;
99
100 mutex.lock();
101 r = damage.get_bounding_rect();
102 damage.clear();
103 mutex.unlock();
104
105 #if !defined(WIN32) && !defined(__APPLE__)
106 if (r.width() == 0 || r.height() == 0)
107 return r;
108
109 GC gc;
110
111 gc = XCreateGC(fl_display, pixmap, 0, NULL);
112 if (shminfo) {
113 XShmPutImage(fl_display, pixmap, gc, xim,
114 r.tl.x, r.tl.y, r.tl.x, r.tl.y,
115 r.width(), r.height(), False);
116 // Need to make sure the X server has finished reading the
117 // shared memory before we return
118 XSync(fl_display, False);
119 } else {
120 XPutImage(fl_display, pixmap, gc, xim,
121 r.tl.x, r.tl.y, r.tl.x, r.tl.y, r.width(), r.height());
122 }
123 XFreeGC(fl_display, gc);
124 #endif
125
126 return r;
127 }
128
129 #if !defined(WIN32) && !defined(__APPLE__)
130
131 static bool caughtError;
132
XShmAttachErrorHandler(Display * dpy,XErrorEvent * error)133 static int XShmAttachErrorHandler(Display *dpy, XErrorEvent *error)
134 {
135 caughtError = true;
136 return 0;
137 }
138
setupShm(int width,int height)139 bool PlatformPixelBuffer::setupShm(int width, int height)
140 {
141 int major, minor;
142 Bool pixmaps;
143 XErrorHandler old_handler;
144 const char *display_name = XDisplayName (NULL);
145
146 /* Don't use MIT-SHM on remote displays */
147 if (*display_name && *display_name != ':')
148 return false;
149
150 if (!XShmQueryVersion(fl_display, &major, &minor, &pixmaps))
151 return false;
152
153 shminfo = new XShmSegmentInfo;
154
155 xim = XShmCreateImage(fl_display, CopyFromParent, 32,
156 ZPixmap, 0, shminfo, width, height);
157 if (!xim)
158 goto free_shminfo;
159
160 shminfo->shmid = shmget(IPC_PRIVATE,
161 xim->bytes_per_line * xim->height,
162 IPC_CREAT|0600);
163 if (shminfo->shmid == -1)
164 goto free_xim;
165
166 shminfo->shmaddr = xim->data = (char*)shmat(shminfo->shmid, 0, 0);
167 shmctl(shminfo->shmid, IPC_RMID, 0); // to avoid memory leakage
168 if (shminfo->shmaddr == (char *)-1)
169 goto free_xim;
170
171 shminfo->readOnly = True;
172
173 // This is the only way we can detect that shared memory won't work
174 // (e.g. because we're accessing a remote X11 server)
175 caughtError = false;
176 old_handler = XSetErrorHandler(XShmAttachErrorHandler);
177
178 if (!XShmAttach(fl_display, shminfo)) {
179 XSetErrorHandler(old_handler);
180 goto free_shmaddr;
181 }
182
183 XSync(fl_display, False);
184
185 XSetErrorHandler(old_handler);
186
187 if (caughtError)
188 goto free_shmaddr;
189
190 vlog.debug("Using shared memory XImage");
191
192 return true;
193
194 free_shmaddr:
195 shmdt(shminfo->shmaddr);
196
197 free_xim:
198 XDestroyImage(xim);
199 xim = NULL;
200
201 free_shminfo:
202 delete shminfo;
203 shminfo = NULL;
204
205 return 0;
206 }
207
208 #endif
209