Commit | Line | Data |
---|---|---|
f641fccb | 1 | /* |
0c7caf2b | 2 | * (C) GraÅžvydas "notaz" Ignotas, 2010-2012 |
f641fccb | 3 | * |
4 | * This work is licensed under the terms of the GNU LGPL, version 2.1 or later. | |
5 | * See the COPYING file in the top-level directory. | |
6 | */ | |
7 | ||
8 | #include <stdio.h> | |
9 | #include <stdlib.h> | |
10 | #include <string.h> | |
11 | #include <strings.h> | |
12 | #include <ctype.h> | |
13 | #include <sys/types.h> | |
14 | #include <sys/stat.h> | |
15 | #include <fcntl.h> | |
16 | #include <sys/ioctl.h> | |
17 | #include <unistd.h> | |
18 | #include <linux/fb.h> | |
19 | ||
9ab462cd | 20 | #include "osdl.h" |
f641fccb | 21 | #include "omapfb.h" |
22 | #include "linux/fbdev.h" | |
f9b3f440 | 23 | #include "linux/xenv.h" |
f641fccb | 24 | |
21e209de DA |
25 | #define MIN(a, b) ( ((a) < (b)) ? (a) : (b) ) |
26 | ||
090bcb85 | 27 | struct omapfb_state { |
f641fccb | 28 | struct omapfb_plane_info pi; |
29 | struct omapfb_mem_info mi; | |
090bcb85 | 30 | struct omapfb_plane_info pi_old; |
31 | struct omapfb_mem_info mi_old; | |
f641fccb | 32 | }; |
33 | ||
b9a19b44 | 34 | static const char *get_fb_device(void) |
35 | { | |
36 | const char *fbname = getenv("SDL_FBDEV"); | |
37 | if (fbname == NULL) | |
38 | fbname = "/dev/fb1"; | |
39 | ||
40 | return fbname; | |
41 | } | |
42 | ||
090bcb85 | 43 | static int osdl_setup_omapfb(struct omapfb_state *ostate, int fd, int enabled, |
44 | int x, int y, int w, int h, int mem, int *buffer_count) | |
f641fccb | 45 | { |
46 | struct omapfb_plane_info pi; | |
47 | struct omapfb_mem_info mi; | |
0c7caf2b | 48 | int mem_blocks = *buffer_count; |
3b1e72e7 | 49 | unsigned int size_cur; |
f641fccb | 50 | int ret; |
51 | ||
5f4b1fd3 | 52 | memset(&pi, 0, sizeof(pi)); |
53 | memset(&mi, 0, sizeof(mi)); | |
54 | ||
f641fccb | 55 | ret = ioctl(fd, OMAPFB_QUERY_PLANE, &pi); |
56 | if (ret != 0) { | |
7b66578c | 57 | err_perror("QUERY_PLANE"); |
f641fccb | 58 | return -1; |
59 | } | |
60 | ||
61 | ret = ioctl(fd, OMAPFB_QUERY_MEM, &mi); | |
62 | if (ret != 0) { | |
7b66578c | 63 | err_perror("QUERY_MEM"); |
f641fccb | 64 | return -1; |
65 | } | |
3b1e72e7 | 66 | size_cur = mi.size; |
f641fccb | 67 | |
68 | /* must disable when changing stuff */ | |
69 | if (pi.enabled) { | |
70 | pi.enabled = 0; | |
71 | ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi); | |
72 | if (ret != 0) | |
7b66578c | 73 | err_perror("SETUP_PLANE"); |
f641fccb | 74 | } |
75 | ||
3b1e72e7 | 76 | /* allocate more mem, if needed */ |
77 | for (; size_cur < mem * mem_blocks && mem_blocks > 0; mem_blocks--) { | |
78 | mi.size = mem * mem_blocks; | |
79 | ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi); | |
80 | if (ret == 0) | |
81 | break; | |
82 | mi.size = size_cur; | |
f641fccb | 83 | } |
3b1e72e7 | 84 | if (mem_blocks <= 0) { |
85 | err("failed to allocate at least %d bytes of vram:\n", mem); | |
86 | err_perror("SETUP_MEM"); | |
87 | return -1; | |
88 | } | |
89 | ||
0c7caf2b | 90 | *buffer_count = mem_blocks; |
f641fccb | 91 | |
92 | pi.pos_x = x; | |
93 | pi.pos_y = y; | |
94 | pi.out_width = w; | |
95 | pi.out_height = h; | |
96 | pi.enabled = enabled; | |
97 | ||
98 | ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi); | |
99 | if (ret != 0) { | |
7b66578c | 100 | err_perror("SETUP_PLANE"); |
6f13ad97 | 101 | err("(%d %d %d %d)\n", x, y, w, h); |
f641fccb | 102 | return -1; |
103 | } | |
104 | ||
090bcb85 | 105 | ostate->pi = pi; |
106 | ostate->mi = mi; | |
f641fccb | 107 | return 0; |
108 | } | |
109 | ||
3af567be | 110 | static int osdl_setup_omapfb_enable(struct omapfb_state *ostate, |
111 | int fd, int enabled) | |
112 | { | |
113 | int ret; | |
114 | ||
115 | ostate->pi.enabled = enabled; | |
116 | ret = ioctl(fd, OMAPFB_SETUP_PLANE, &ostate->pi); | |
117 | if (ret != 0) | |
118 | err_perror("SETUP_PLANE"); | |
119 | ||
120 | return ret; | |
121 | } | |
122 | ||
f641fccb | 123 | static int read_sysfs(const char *fname, char *buff, size_t size) |
124 | { | |
125 | FILE *f; | |
126 | int ret; | |
127 | ||
128 | f = fopen(fname, "r"); | |
129 | if (f == NULL) { | |
7b66578c | 130 | err_perror("open %s: ", fname); |
f641fccb | 131 | return -1; |
132 | } | |
133 | ||
134 | ret = fread(buff, 1, size - 1, f); | |
135 | fclose(f); | |
136 | if (ret <= 0) { | |
7b66578c | 137 | err_perror("read %s: ", fname); |
f641fccb | 138 | return -1; |
139 | } | |
140 | ||
141 | buff[ret] = 0; | |
142 | for (ret--; ret >= 0 && isspace(buff[ret]); ret--) | |
143 | buff[ret] = 0; | |
144 | ||
145 | return 0; | |
146 | } | |
147 | ||
34edc246 | 148 | int read_vscreeninfo(const char *fbname, int *w, int *h) |
149 | { | |
150 | struct fb_var_screeninfo fbvar; | |
151 | int ret, fd; | |
152 | ||
153 | fd = open(fbname, O_RDWR); | |
154 | if (fd == -1) { | |
155 | err_perror("open %s", fbname); | |
156 | return -1; | |
157 | } | |
158 | ||
159 | ret = ioctl(fd, FBIOGET_VSCREENINFO, &fbvar); | |
160 | close(fd); | |
161 | ||
162 | if (ret == -1) { | |
163 | err_perror("ioctl %s", fbname); | |
164 | return -1; | |
165 | } | |
166 | ||
167 | if (fbvar.xres == 0 || fbvar.yres == 0) | |
168 | return -1; | |
169 | ||
170 | *w = fbvar.xres; | |
171 | *h = fbvar.yres; | |
172 | return 0; | |
173 | } | |
174 | ||
b9a19b44 | 175 | int osdl_video_detect_screen(struct SDL_PrivateVideoData *pdata) |
f641fccb | 176 | { |
f641fccb | 177 | int fb_id, overlay_id = -1, screen_id = -1; |
178 | char buff[64], screen_name[64]; | |
b9a19b44 | 179 | const char *fbname; |
f641fccb | 180 | struct stat status; |
b9a19b44 | 181 | int fd, i, ret; |
182 | int w, h; | |
f641fccb | 183 | FILE *f; |
184 | ||
5f4b1fd3 | 185 | pdata->phys_w = pdata->phys_h = 0; |
186 | ||
b9a19b44 | 187 | fbname = get_fb_device(); |
f641fccb | 188 | |
b9a19b44 | 189 | /* Figure out screen resolution, we need to know default resolution |
190 | * to report to SDL and for centering stuff. | |
f641fccb | 191 | * The only way to achieve this seems to be walking some sysfs files.. */ |
192 | ret = stat(fbname, &status); | |
193 | if (ret != 0) { | |
7b66578c | 194 | err_perror("can't stat %s", fbname); |
b9a19b44 | 195 | goto skip_screen; |
f641fccb | 196 | } |
197 | fb_id = minor(status.st_rdev); | |
198 | ||
199 | snprintf(buff, sizeof(buff), "/sys/class/graphics/fb%d/overlays", fb_id); | |
200 | f = fopen(buff, "r"); | |
201 | if (f == NULL) { | |
7b66578c | 202 | err("can't open %s, skip screen detection", buff); |
f641fccb | 203 | goto skip_screen; |
204 | } | |
205 | ||
206 | ret = fscanf(f, "%d", &overlay_id); | |
207 | fclose(f); | |
208 | if (ret != 1) { | |
7b66578c | 209 | err("can't parse %s, skip screen detection", buff); |
f641fccb | 210 | goto skip_screen; |
211 | } | |
212 | ||
213 | snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/overlay%d/manager", overlay_id); | |
214 | ret = read_sysfs(buff, screen_name, sizeof(screen_name)); | |
215 | if (ret < 0) { | |
7b66578c | 216 | err("skip screen detection"); |
f641fccb | 217 | goto skip_screen; |
218 | } | |
219 | ||
220 | for (i = 0; ; i++) { | |
221 | snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/name", i); | |
222 | ret = read_sysfs(buff, buff, sizeof(buff)); | |
223 | if (ret < 0) | |
224 | break; | |
225 | ||
226 | if (strcmp(screen_name, buff) == 0) { | |
227 | screen_id = i; | |
228 | break; | |
229 | } | |
230 | } | |
231 | ||
232 | if (screen_id < 0) { | |
7b66578c | 233 | err("could not find screen"); |
f641fccb | 234 | goto skip_screen; |
235 | } | |
236 | ||
237 | snprintf(buff, sizeof(buff), "/sys/devices/platform/omapdss/display%d/timings", screen_id); | |
238 | f = fopen(buff, "r"); | |
239 | if (f == NULL) { | |
7b66578c | 240 | err("can't open %s, skip screen detection", buff); |
f641fccb | 241 | goto skip_screen; |
242 | } | |
243 | ||
b9a19b44 | 244 | ret = fscanf(f, "%*d,%d/%*d/%*d/%*d,%d/%*d/%*d/%*d", &w, &h); |
f641fccb | 245 | fclose(f); |
246 | if (ret != 2) { | |
7b66578c | 247 | err("can't parse %s (%d), skip screen detection", buff, ret); |
f641fccb | 248 | goto skip_screen; |
249 | } | |
250 | ||
7b66578c | 251 | log("detected %dx%d '%s' (%d) screen attached to fb %d and overlay %d", |
b9a19b44 | 252 | w, h, screen_name, screen_id, fb_id, overlay_id); |
253 | ||
5f4b1fd3 | 254 | pdata->phys_w = w; |
255 | pdata->phys_h = h; | |
b9a19b44 | 256 | return 0; |
f641fccb | 257 | |
258 | skip_screen: | |
b9a19b44 | 259 | /* attempt to extract this from FB then */ |
34edc246 | 260 | ret = read_vscreeninfo(fbname, &pdata->phys_w, &pdata->phys_h); |
261 | if (ret != 0 && strcmp(fbname, "/dev/fb0") != 0) { | |
262 | /* last resort */ | |
263 | ret = read_vscreeninfo("/dev/fb0", &pdata->phys_w, &pdata->phys_h); | |
b9a19b44 | 264 | } |
265 | ||
34edc246 | 266 | if (ret != 0) { |
b9a19b44 | 267 | err("VSCREENINFO has nothing meaningful"); |
268 | return -1; | |
269 | } | |
270 | ||
b9a19b44 | 271 | return 0; |
272 | } | |
273 | ||
274 | static int osdl_setup_omap_layer(struct SDL_PrivateVideoData *pdata, | |
0c7caf2b | 275 | const char *fbname, int width, int height, int bpp, int *buffer_count) |
b9a19b44 | 276 | { |
277 | int x = 0, y = 0, w = width, h = height; /* layer size and pos */ | |
278 | int screen_w = w, screen_h = h; | |
f151701d | 279 | int tmp_w, tmp_h; |
b9a19b44 | 280 | const char *tmp; |
f11c56a6 | 281 | int retval = -1; |
b9a19b44 | 282 | int ret, fd; |
283 | ||
5f4b1fd3 | 284 | pdata->layer_x = pdata->layer_y = pdata->layer_w = pdata->layer_h = 0; |
285 | ||
286 | if (pdata->phys_w != 0) | |
287 | screen_w = pdata->phys_w; | |
288 | if (pdata->phys_h != 0) | |
289 | screen_h = pdata->phys_h; | |
b9a19b44 | 290 | |
291 | fd = open(fbname, O_RDWR); | |
292 | if (fd == -1) { | |
293 | err_perror("open %s", fbname); | |
294 | return -1; | |
295 | } | |
296 | ||
297 | /* FIXME: assuming layer doesn't change here */ | |
298 | if (pdata->saved_layer == NULL) { | |
090bcb85 | 299 | struct omapfb_state *slayer; |
b9a19b44 | 300 | slayer = calloc(1, sizeof(*slayer)); |
301 | if (slayer == NULL) | |
f11c56a6 | 302 | goto out; |
b9a19b44 | 303 | |
090bcb85 | 304 | ret = ioctl(fd, OMAPFB_QUERY_PLANE, &slayer->pi_old); |
b9a19b44 | 305 | if (ret != 0) { |
306 | err_perror("QUERY_PLANE"); | |
f11c56a6 | 307 | goto out; |
b9a19b44 | 308 | } |
309 | ||
090bcb85 | 310 | ret = ioctl(fd, OMAPFB_QUERY_MEM, &slayer->mi_old); |
b9a19b44 | 311 | if (ret != 0) { |
312 | err_perror("QUERY_MEM"); | |
f11c56a6 | 313 | goto out; |
b9a19b44 | 314 | } |
315 | ||
316 | pdata->saved_layer = slayer; | |
317 | } | |
318 | ||
f641fccb | 319 | tmp = getenv("SDL_OMAP_LAYER_SIZE"); |
320 | if (tmp != NULL) { | |
21e209de | 321 | if (strcasecmp(tmp, "fullscreen") == 0) { |
f641fccb | 322 | w = screen_w, h = screen_h; |
21e209de DA |
323 | } |
324 | else if (strcasecmp(tmp, "scaled") == 0) { | |
325 | float factor = MIN(((float)screen_w) / width, ((float)screen_h) / height); | |
326 | w = (int)(factor*width), h = (int)(factor*height); | |
327 | } | |
328 | else if (strcasecmp(tmp, "pixelperfect") == 0) { | |
329 | float factor = MIN(((float)screen_w) / width, ((float)screen_h) / height); | |
330 | w = ((int)factor) * width, h = ((int)factor) * height; | |
331 | /* factor < 1.f => 0x0 layer, so fall back to 'scaled' */ | |
332 | if (!w || !h) { | |
333 | w = (int)(factor * width), h = (int)(factor * height); | |
334 | } | |
335 | } | |
336 | else if (sscanf(tmp, "%dx%d", &tmp_w, &tmp_h) == 2) { | |
f151701d | 337 | w = tmp_w, h = tmp_h; |
21e209de DA |
338 | } |
339 | else { | |
7b66578c | 340 | err("layer size specified incorrectly, " |
341 | "should be like 800x480"); | |
21e209de | 342 | } |
f641fccb | 343 | } |
f11c56a6 | 344 | |
345 | /* the layer can't be set larger than screen */ | |
346 | tmp_w = w, tmp_h = h; | |
347 | if (w > screen_w) | |
348 | w = screen_w; | |
349 | if (h > screen_h) | |
350 | h = screen_h; | |
351 | if (w != tmp_w || h != tmp_h) | |
352 | log("layer resized %dx%d -> %dx%d to fit screen", tmp_w, tmp_h, w, h); | |
f641fccb | 353 | |
354 | x = screen_w / 2 - w / 2; | |
355 | y = screen_h / 2 - h / 2; | |
3af567be | 356 | ret = osdl_setup_omapfb(pdata->saved_layer, fd, 0, x, y, w, h, |
0c7caf2b | 357 | width * height * ((bpp + 7) / 8), buffer_count); |
5f4b1fd3 | 358 | if (ret == 0) { |
359 | pdata->layer_x = x; | |
360 | pdata->layer_y = y; | |
361 | pdata->layer_w = w; | |
362 | pdata->layer_h = h; | |
363 | } | |
f641fccb | 364 | |
f11c56a6 | 365 | retval = ret; |
366 | out: | |
367 | close(fd); | |
368 | return retval; | |
f641fccb | 369 | } |
370 | ||
455c8c43 | 371 | void *osdl_video_set_mode(struct SDL_PrivateVideoData *pdata, |
372 | int border_l, int border_r, int border_t, int border_b, | |
090bcb85 | 373 | int width, int height, int bpp, int *doublebuf, |
374 | const char *wm_title) | |
f641fccb | 375 | { |
0c7caf2b | 376 | int buffers_try, buffers_set; |
f641fccb | 377 | const char *fbname; |
455c8c43 | 378 | void *result; |
f641fccb | 379 | int ret; |
380 | ||
b9a19b44 | 381 | fbname = get_fb_device(); |
f641fccb | 382 | |
383 | if (pdata->fbdev != NULL) { | |
384 | vout_fbdev_finish(pdata->fbdev); | |
385 | pdata->fbdev = NULL; | |
386 | } | |
387 | ||
0c7caf2b | 388 | buffers_try = buffers_set = 1; |
389 | if (*doublebuf) | |
390 | /* actually try tripple buffering for reduced chance of tearing */ | |
391 | buffers_try = buffers_set = 3; | |
392 | ||
393 | ret = osdl_setup_omap_layer(pdata, fbname, width, height, bpp, &buffers_set); | |
f641fccb | 394 | if (ret < 0) |
0c7caf2b | 395 | goto fail; |
f641fccb | 396 | |
0c7caf2b | 397 | pdata->fbdev = vout_fbdev_init(fbname, &width, &height, bpp, buffers_set); |
f641fccb | 398 | if (pdata->fbdev == NULL) |
0c7caf2b | 399 | goto fail; |
455c8c43 | 400 | |
401 | if (border_l | border_r | border_t | border_b) { | |
402 | width -= border_l + border_r; | |
403 | height -= border_t + border_b; | |
404 | result = vout_fbdev_resize(pdata->fbdev, width, height, bpp, | |
0c7caf2b | 405 | border_l, border_r, border_t, border_b, buffers_set); |
455c8c43 | 406 | } |
407 | else { | |
408 | result = osdl_video_flip(pdata); | |
409 | } | |
0c7caf2b | 410 | if (result == NULL) |
411 | goto fail; | |
f641fccb | 412 | |
f9b3f440 | 413 | if (!pdata->xenv_up) { |
090bcb85 | 414 | int xenv_flags = XENV_CAP_KEYS | XENV_CAP_MOUSE; |
415 | ret = xenv_init(&xenv_flags, wm_title); | |
e1837b2c | 416 | if (ret == 0) { |
f9b3f440 | 417 | pdata->xenv_up = 1; |
090bcb85 | 418 | pdata->xenv_mouse = (xenv_flags & XENV_CAP_MOUSE) ? 1 : 0; |
e1837b2c | 419 | } |
f641fccb | 420 | } |
421 | ||
3af567be | 422 | ret = osdl_setup_omapfb_enable(pdata->saved_layer, |
423 | vout_fbdev_get_fd(pdata->fbdev), 1); | |
424 | if (ret != 0) { | |
425 | err("layer enable failed"); | |
426 | goto fail; | |
427 | } | |
428 | ||
0c7caf2b | 429 | if (buffers_try != buffers_set) { |
430 | log("only %d/%d buffers available, expect tearing\n", | |
431 | buffers_set, buffers_try); | |
432 | *doublebuf = buffers_set > 1; | |
433 | } | |
434 | ||
455c8c43 | 435 | return result; |
0c7caf2b | 436 | |
437 | fail: | |
438 | osdl_video_finish(pdata); | |
439 | return NULL; | |
f641fccb | 440 | } |
441 | ||
442 | void *osdl_video_flip(struct SDL_PrivateVideoData *pdata) | |
443 | { | |
52a1749b | 444 | void *ret; |
445 | ||
f641fccb | 446 | if (pdata->fbdev == NULL) |
447 | return NULL; | |
448 | ||
52a1749b | 449 | ret = vout_fbdev_flip(pdata->fbdev); |
450 | ||
5f4b1fd3 | 451 | if (pdata->cfg_force_vsync) |
f641fccb | 452 | vout_fbdev_wait_vsync(pdata->fbdev); |
453 | ||
52a1749b | 454 | return ret; |
f641fccb | 455 | } |
456 | ||
090bcb85 | 457 | int osdl_video_pause(struct SDL_PrivateVideoData *pdata, int is_pause) |
458 | { | |
459 | struct omapfb_state *state = pdata->saved_layer; | |
460 | struct omapfb_plane_info pi; | |
461 | struct omapfb_mem_info mi; | |
462 | int enabled; | |
463 | int fd = -1; | |
464 | int ret; | |
465 | ||
466 | if (pdata->fbdev != NULL) | |
467 | fd = vout_fbdev_get_fd(pdata->fbdev); | |
468 | if (fd == -1) { | |
469 | err("bad fd %d", fd); | |
470 | return -1; | |
471 | } | |
472 | if (state == NULL) { | |
473 | err("missing layer state\n"); | |
474 | return -1; | |
475 | } | |
476 | ||
477 | if (is_pause) { | |
478 | ret = vout_fbdev_save(pdata->fbdev); | |
479 | if (ret != 0) | |
480 | return ret; | |
481 | pi = state->pi_old; | |
482 | mi = state->mi_old; | |
483 | enabled = pi.enabled; | |
484 | } else { | |
485 | pi = state->pi; | |
486 | mi = state->mi; | |
487 | enabled = 1; | |
488 | } | |
489 | pi.enabled = 0; | |
490 | ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi); | |
491 | if (ret != 0) { | |
492 | err_perror("SETUP_PLANE"); | |
493 | return -1; | |
494 | } | |
495 | ||
496 | ret = ioctl(fd, OMAPFB_SETUP_MEM, &mi); | |
497 | if (ret != 0) | |
498 | err_perror("SETUP_MEM"); | |
499 | ||
500 | if (!is_pause) { | |
501 | ret = vout_fbdev_restore(pdata->fbdev); | |
502 | if (ret != 0) { | |
503 | err("fbdev_restore failed\n"); | |
504 | return ret; | |
505 | } | |
506 | } | |
507 | ||
508 | if (enabled) { | |
509 | pi.enabled = 1; | |
510 | ret = ioctl(fd, OMAPFB_SETUP_PLANE, &pi); | |
511 | if (ret != 0) { | |
512 | err_perror("SETUP_PLANE"); | |
513 | return -1; | |
514 | } | |
515 | } | |
516 | ||
517 | return 0; | |
518 | } | |
519 | ||
f641fccb | 520 | void osdl_video_finish(struct SDL_PrivateVideoData *pdata) |
521 | { | |
522 | static const char *fbname; | |
523 | ||
b9a19b44 | 524 | fbname = get_fb_device(); |
f641fccb | 525 | if (pdata->fbdev != NULL) { |
526 | vout_fbdev_finish(pdata->fbdev); | |
527 | pdata->fbdev = NULL; | |
528 | } | |
529 | ||
530 | /* restore the OMAP layer */ | |
531 | if (pdata->saved_layer != NULL) { | |
090bcb85 | 532 | struct omapfb_state *slayer = pdata->saved_layer; |
f641fccb | 533 | int fd; |
534 | ||
535 | fd = open(fbname, O_RDWR); | |
536 | if (fd != -1) { | |
090bcb85 | 537 | int enabled = slayer->pi_old.enabled; |
f641fccb | 538 | |
539 | /* be sure to disable while setting up */ | |
090bcb85 | 540 | slayer->pi_old.enabled = 0; |
541 | ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old); | |
542 | ioctl(fd, OMAPFB_SETUP_MEM, &slayer->mi_old); | |
f641fccb | 543 | if (enabled) { |
090bcb85 | 544 | slayer->pi_old.enabled = enabled; |
545 | ioctl(fd, OMAPFB_SETUP_PLANE, &slayer->pi_old); | |
f641fccb | 546 | } |
547 | close(fd); | |
548 | } | |
549 | free(slayer); | |
550 | pdata->saved_layer = NULL; | |
551 | } | |
552 | ||
f9b3f440 | 553 | if (pdata->xenv_up) { |
554 | xenv_finish(); | |
555 | pdata->xenv_up = 0; | |
f641fccb | 556 | } |
557 | } | |
558 |