git.hungrycats.org Git - xscreensaver/blob - 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 }