From http://www.jwz.org/xscreensaver/xscreensaver-5.35.tar.gz
[xscreensaver] / OSX / osxgrabscreen.m
1 /* xscreensaver, Copyright (c) 1992-2012 Jamie Zawinski <jwz@jwz.org>
2  *
3  * Permission to use, copy, modify, distribute, and sell this software and its
4  * documentation for any purpose is hereby granted without fee, provided that
5  * the above copyright notice appear in all copies and that both that
6  * copyright notice and this permission notice appear in supporting
7  * documentation.  No representations are made about the suitability of this
8  * software for any purpose.  It is provided "as is" without express or 
9  * implied warranty.
10  */
11
12 /* This is the OSX implementation of desktop-grabbing and image-loading.
13    This code is invoked by "utils/grabclient.c", which is linked directly
14    in to each screen saver bundle.
15
16    X11-based builds of the savers do not use this code (even on MacOS).
17    This is used only by the Cocoa build of the savers.
18  */
19
20 #import <stdlib.h>
21 #import <stdint.h>
22 #ifndef USE_IPHONE
23 # import <Cocoa/Cocoa.h>
24 #else
25 # import "SaverRunner.h"
26 #endif
27 #import "jwxyz-cocoa.h"
28 #import "grabscreen.h"
29 #import "colorbars.h"
30 #import "resources.h"
31 #import "usleep.h"
32
33
34 #ifdef USE_IPHONE
35 # define NSImage UIImage
36 #endif
37
38
39 #ifndef  MAC_OS_X_VERSION_10_6
40 # define MAC_OS_X_VERSION_10_6 1060  /* undefined in 10.4 SDK, grr */
41 #endif
42
43 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
44
45      /* 10.4 code.
46
47         This version of the code works on 10.4, but is flaky.  There is
48         a better way to do it on 10.5 and newer, but taking this path,
49         then we are being compiled against the 10.4 SDK instead of the
50         10.5 SDK, and the newer API is not available to us.
51       */
52
53 static void
54 copy_framebuffer_to_ximage (CGDirectDisplayID cgdpy, XImage *xim,
55                             int window_x, int window_y)
56 {
57   unsigned char *data = (unsigned char *) 
58     CGDisplayAddressForPosition (cgdpy, window_x, window_y);
59   int bpp = CGDisplayBitsPerPixel (cgdpy);
60   int spp = CGDisplaySamplesPerPixel (cgdpy);
61   int bps = CGDisplayBitsPerSample (cgdpy);
62   int bpr = CGDisplayBytesPerRow (cgdpy);
63
64   int y;
65   int ximw = xim->width;
66   int ximh = xim->height;
67
68   uint32_t *odata = (uint32_t *) xim->data;
69
70   switch (bpp) {
71   case 32:
72     if (spp != 3) abort();
73     if (bps != 8) abort();
74     int xwpl = xim->bytes_per_line/4;
75     for (y = 0; y < ximh; y++) {
76       // We can do this because the frame buffer and XImage are both ARGB 32.
77       // Both PPC and Intel use ARGB, viewed in word order (not byte-order).
78       memcpy (odata, data, ximw * 4);
79       odata += xwpl;
80       data += bpr;
81     }
82     break;
83
84   case 16:
85     if (spp != 3) abort();
86     if (bps != 5) abort();
87     for (y = 0; y < ximh; y++) {
88       uint16_t *ip = (uint16_t *) data;
89       int x;
90       for (x = 0; x < ximw; x++) {
91         uint16_t p = *ip++;
92         // This should be ok on both PPC and Intel (ARGB, word order)
93         unsigned char r = (p >> 10) & 0x1F;
94         unsigned char g = (p >>  5) & 0x1F;
95         unsigned char b = (p      ) & 0x1F;
96         r = (r << 3) | (r >> 2);
97         g = (g << 3) | (g >> 2);
98         b = (b << 3) | (b >> 2);
99         uint32_t pixel = 0xFF000000 | (r << 16) | (g << 8) | b;
100         // XPutPixel (xim, x, y, pixel);
101         *odata++ = pixel;
102       }
103       data += bpr;
104     }
105     break;
106
107   case 8:
108     {
109       /* Get the current palette of the display. */
110       CGDirectPaletteRef pal = CGPaletteCreateWithDisplay (cgdpy);
111
112       /* Map it to 32bpp pixels */
113       uint32_t map[256];
114       for (y = 0; y < 256; y++) {
115         CGDeviceColor c = CGPaletteGetColorAtIndex (pal, y);
116         unsigned char r = c.red   * 255.0;
117         unsigned char g = c.green * 255.0;
118         unsigned char b = c.blue  * 255.0;
119         uint32_t pixel = 0xFF000000 | (r << 16) | (g << 8) | b;
120         map[y] = pixel;
121       }
122
123       for (y = 0; y < ximh; y++) {
124         unsigned char *ip = data;
125         int x;
126         for (x = 0; x < ximw; x++) {
127           *odata++ = map[*ip++];
128         }
129         data += bpr;
130       }
131       CGPaletteRelease (pal);
132     }
133     break;
134
135   default:
136     abort();
137     break;
138   }
139 }
140
141
142 /* Loads an image into the Drawable, returning once the image is loaded.
143  */
144 Bool
145 osx_grab_desktop_image (Screen *screen, Window xwindow, Drawable drawable,
146                         XRectangle *geom_ret)
147 {
148   Display *dpy = DisplayOfScreen (screen);
149   NSView *nsview = jwxyz_window_view (xwindow);
150   NSWindow *nswindow = [nsview window];
151   XWindowAttributes xgwa;
152   int window_x, window_y;
153   Window unused;
154
155   // Figure out where this window is on the screen.
156   //
157   XGetWindowAttributes (dpy, xwindow, &xgwa);
158   XTranslateCoordinates (dpy, xwindow, RootWindowOfScreen (screen), 0, 0, 
159                          &window_x, &window_y, &unused);
160
161   // Use the size of the Drawable, not the Window.
162   {
163     Window r;
164     int x, y;
165     unsigned int w, h, bbw, d;
166     XGetGeometry (dpy, drawable, &r, &x, &y, &w, &h, &bbw, &d);
167     xgwa.width = w;
168     xgwa.height = h;
169   }
170
171   // Create a tmp ximage to hold the screen data.
172   //
173   XImage *xim = XCreateImage (dpy, xgwa.visual, 32, ZPixmap, 0, 0,
174                               xgwa.width, xgwa.height, 8, 0);
175   xim->data = (char *) malloc (xim->height * xim->bytes_per_line);
176
177
178   // Find the address in the frame buffer of the top left of this window.
179   //
180   CGDirectDisplayID cgdpy = 0;
181   {
182     CGPoint p;
183     // #### this isn't quite right for screen 2: it's offset slightly.
184     p.x = window_x;
185     p.y = window_y;
186     CGDisplayCount n;
187     CGGetDisplaysWithPoint (p, 1, &cgdpy, &n);
188     if (!cgdpy) abort();
189   }
190
191   // Paint a transparent "hole" in this window.
192   //
193   BOOL oopaque = [nswindow isOpaque];
194   [nswindow setOpaque:NO];
195
196   [[NSColor clearColor] set];
197   NSRectFill ([nsview frame]);
198   [[nswindow graphicsContext] flushGraphics];
199
200
201   // Without this, we get a dozen black scanlines at the top.
202   // #### But with this, the screen saver loops, because calling this
203   //      seems to implicitly mark the display as non-idle!
204   // CGDisplayCaptureWithOptions (cgdpy, kCGCaptureNoFill);
205
206   // #### So let's try waiting for the vertical blank instead...
207   //      Nope, that doesn't work.
208   //
209   // CGDisplayWaitForBeamPositionOutsideLines (cgdpy, 0,
210   //   window_y + [nswindow frame].size.height);
211
212   // #### Ok, try a busy-wait?
213   //      Nope.
214   //
215
216   // #### Ok, just fuckin' sleep!
217   //
218   usleep (100000);
219
220
221   // Pull the bits out of the frame buffer.
222   //
223   copy_framebuffer_to_ximage (cgdpy, xim, window_x, window_y);
224
225   // CGDisplayRelease (cgdpy);
226
227   // Make the window visible again.
228   //
229   [nswindow setOpaque:oopaque];
230
231   // Splat the XImage onto the target drawable (probably the window)
232   // and free the bits.
233   //
234   XGCValues gcv;
235   GC gc = XCreateGC (dpy, drawable, 0, &gcv);
236   XPutImage (dpy, drawable, gc, xim, 0, 0, 0, 0, xim->width, xim->height);
237   XFreeGC (dpy, gc);
238
239   if (geom_ret) {
240     geom_ret->x = 0;
241     geom_ret->y = 0;
242     geom_ret->width  = xim->width;
243     geom_ret->height = xim->height;
244   }
245
246   XDestroyImage (xim);
247   return True;
248 }
249
250
251 #elif defined(USE_IPHONE)
252
253         /* What a hack!
254
255            On iOS, our application delegate, SaverRunner, grabs an image
256            of itself as a UIImage before mapping the XScreenSaverView.
257            In this code, we ask SaverRunner for that UIImage, then copy
258            it to the root window.
259          */
260
261 Bool
262 osx_grab_desktop_image (Screen *screen, Window xwindow, Drawable drawable,
263                         XRectangle *geom_ret)
264 {
265   SaverRunner *s = 
266     (SaverRunner *) [[UIApplication sharedApplication] delegate];
267   if (! s)
268     return False;
269   if (! [s isKindOfClass:[SaverRunner class]])
270     return False;
271   UIImage *img = [s screenshot];
272   if (! img)
273     return False;
274   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable,
275                                  True, img, geom_ret, 0);
276   return True;
277 }
278
279
280 #else /* MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
281
282          10.5+ code.
283
284          This version of the code is simpler and more reliable, but
285          uses an API that only exist on 10.5 and newer, so we can only
286          use it if when being compiled against the 10.5 SDK or later.
287        */
288
289 /* Loads an image into the Drawable, returning once the image is loaded.
290  */
291 Bool
292 osx_grab_desktop_image (Screen *screen, Window xwindow, Drawable drawable,
293                         XRectangle *geom_ret)
294 {
295   Display *dpy = DisplayOfScreen (screen);
296   NSView *nsview = jwxyz_window_view (xwindow);
297   XWindowAttributes xgwa;
298   int window_x, window_y;
299   Window unused;
300
301   // Figure out where this window is on the screen.
302   //
303   XGetWindowAttributes (dpy, xwindow, &xgwa);
304   XTranslateCoordinates (dpy, xwindow, RootWindowOfScreen (screen), 0, 0, 
305                          &window_x, &window_y, &unused);
306
307   // Grab only the rectangle of the screen underlying this window.
308   //
309   CGRect cgrect;
310   cgrect.origin.x    = window_x;
311   cgrect.origin.y    = window_y;
312   cgrect.size.width  = xgwa.width;
313   cgrect.size.height = xgwa.height;
314
315   /* If a password is required to unlock the screen, a large black
316      window will be on top of all of the desktop windows by the time
317      we reach here, making the screen-grab rather uninteresting.  If
318      we move ourselves temporarily below the login-window windows
319      before capturing the image, we capture the real desktop as
320      intended.
321    */
322
323   // save our current level so we can restore it later
324   int oldLevel = [[nsview window] level]; 
325
326   [[nsview window] setLevel:CGWindowLevelForKey(kCGPopUpMenuWindowLevelKey)];
327
328   // Grab a screen shot of those windows below this one
329   // (hey, X11 can't do that!)
330   //
331   CGImageRef img = 
332     CGWindowListCreateImage (cgrect,
333                              kCGWindowListOptionOnScreenBelowWindow,
334                              [[nsview window] windowNumber],
335                              kCGWindowImageDefault);
336
337   // put us back above the login windows so the screensaver is visible.
338   [[nsview window] setLevel:oldLevel];
339
340   if (! img) return False;
341
342   // Render the grabbed CGImage into the Drawable.
343   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable, 
344                                  False, img, geom_ret, 0);
345   CGImageRelease (img);
346   return True;
347 }
348
349 #endif /* 10.5+ code */
350
351
352 # ifndef USE_IPHONE
353
354 /* Returns the EXIF rotation property of the image, if any.
355  */
356 static int
357 exif_rotation (const char *filename)
358 {
359   /* As of 10.6, NSImage rotates according to EXIF by default:
360      http://developer.apple.com/mac/library/releasenotes/cocoa/appkit.html
361      So this function should return -1 when *running* on 10.6 systems.
362      But when running against older systems, we need to examine the image
363      to figure out its rotation.
364    */
365
366 # if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6  /* 10.6 SDK */
367
368   /* When we have compiled against the 10.6 SDK, we know that we are 
369      running on a 10.6 or later system.
370    */
371   return -1;
372
373 # else /* Compiled against 10.5 SDK or earlier */
374
375   /* If this selector exists, then we are running against a 10.6 runtime
376      that does automatic EXIF rotation (despite the fact that we were
377      compiled against the 10.5 or earlier SDK).  So in that case, this
378      function should no-op.
379    */
380   if ([NSImage instancesRespondToSelector:
381                  @selector(initWithDataIgnoringOrientation:)])
382     return -1;
383
384   /* Otherwise, go ahead and figure out what the rotational characteristics
385      of this image are. */
386
387
388
389   /* This is a ridiculous amount of rigamarole to go through, but for some
390      reason the "Orientation" tag does not exist in the "NSImageEXIFData"
391      dictionary inside the NSBitmapImageRep of the NSImage.  Several other
392      EXIF tags are there (e.g., shutter speed) but not orientation.  WTF?
393    */
394   CFStringRef s = CFStringCreateWithCString (NULL, filename, 
395                                              kCFStringEncodingUTF8);
396   CFURLRef url = CFURLCreateWithFileSystemPath (NULL, s, 
397                                                 kCFURLPOSIXPathStyle, 0);
398   CGImageSourceRef cgimg = CGImageSourceCreateWithURL (url, NULL);
399   if (! cgimg) return -1;
400
401   NSDictionary *props = (NSDictionary *)
402     CGImageSourceCopyPropertiesAtIndex (cgimg, 0, NULL);
403   int rot = [[props objectForKey:@"Orientation"] intValue];
404   CFRelease (cgimg);
405   CFRelease (url);
406   CFRelease (s);
407   return rot;
408
409 # endif /* 10.5 */
410 }
411
412 # endif /* USE_IPHONE */
413
414
415
416 /* Loads an image file and splats it onto the drawable.
417    The image is drawn as large as possible while preserving its aspect ratio.
418    If geom_ret is provided, the actual rectangle the rendered image takes
419    up will be returned there.
420  */
421 Bool
422 osx_load_image_file (Screen *screen, Window xwindow, Drawable drawable,
423                      const char *filename, XRectangle *geom_ret)
424 {
425 # ifndef USE_IPHONE
426
427   if (!filename || !*filename) return False;
428
429   NSImage *img = [[NSImage alloc] initWithContentsOfFile:
430                                     [NSString stringWithCString:filename
431                                               encoding:NSUTF8StringEncoding]];
432   if (!img)
433     return False;
434
435   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable, 
436                                  True, img, geom_ret,
437                                  exif_rotation (filename));
438   [img release];
439   return True;
440
441 # else  /* USE_IPHONE */
442
443   /* This is handled differently: see grabclient.c and iosgrabimage.m. */
444   return False;
445
446 # endif /* USE_IPHONE */
447 }