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.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 creating 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
 266   /* Just for a little variety, let's return colorbars every other time. */
 267   static int counter = 0;
 268   if (counter++ & 1)
 269     return False;
 270
 271   SaverRunner *s =
 272     (SaverRunner *) [[UIApplication sharedApplication] delegate];
 273   if (! s)
 274     return False;
 275   if (! [s isKindOfClass:[SaverRunner class]])
 276     abort();
 277   UIImage *img = [s screenshot];
 278   if (! img)
 279     return False;
 280   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable,
 281                                  True, img, geom_ret, 0);
 282   return True;
 283 }
 284
 285
 286 #else /* MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 287
 288          10.5+ code.
 289
 290          This version of the code is simpler and more reliable, but
 291          uses an API that only exist on 10.5 and newer, so we can only
 292          use it if when being compiled against the 10.5 SDK or later.
 293        */
 294
 295 /* Loads an image into the Drawable, returning once the image is loaded.
 296  */
 297 Bool
 298 osx_grab_desktop_image (Screen *screen, Window xwindow, Drawable drawable,
 299                         XRectangle *geom_ret)
 300 {
 301   Display *dpy = DisplayOfScreen (screen);
 302   NSView *nsview = jwxyz_window_view (xwindow);
 303   XWindowAttributes xgwa;
 304   int window_x, window_y;
 305   Window unused;
 306
 307   // Figure out where this window is on the screen.
 308   //
 309   XGetWindowAttributes (dpy, xwindow, &xgwa);
 310   XTranslateCoordinates (dpy, xwindow, RootWindowOfScreen (screen), 0, 0,
 311                          &window_x, &window_y, &unused);
 312
 313   // Grab only the rectangle of the screen underlying this window.
 314   //
 315   CGRect cgrect;
 316   cgrect.origin.x    = window_x;
 317   cgrect.origin.y    = window_y;
 318   cgrect.size.width  = xgwa.width;
 319   cgrect.size.height = xgwa.height;
 320
 321   /* If a password is required to unlock the screen, a large black
 322      window will be on top of all of the desktop windows by the time
 323      we reach here, making the screen-grab rather uninteresting.  If
 324      we move ourselves temporarily below the login-window windows
 325      before capturing the image, we capture the real desktop as
 326      intended.
 327    */
 328
 329   // save our current level so we can restore it later
 330   int oldLevel = [[nsview window] level];
 331
 332   [[nsview window] setLevel:CGWindowLevelForKey(kCGPopUpMenuWindowLevelKey)];
 333
 334   // Grab a screen shot of those windows below this one
 335   // (hey, X11 can't do that!)
 336   //
 337   CGImageRef img =
 338     CGWindowListCreateImage (cgrect,
 339                              kCGWindowListOptionOnScreenBelowWindow,
 340                              [[nsview window] windowNumber],
 341                              kCGWindowImageDefault);
 342
 343   // put us back above the login windows so the screensaver is visible.
 344   [[nsview window] setLevel:oldLevel];
 345
 346   if (! img) return False;
 347
 348   // Render the grabbed CGImage into the Drawable.
 349   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable,
 350                                  False, img, geom_ret, 0);
 351   CGImageRelease (img);
 352   return True;
 353 }
 354
 355 #endif /* 10.5+ code */
 356
 357
 358 # ifndef USE_IPHONE
 359
 360 /* Returns the EXIF rotation property of the image, if any.
 361  */
 362 static int
 363 exif_rotation (const char *filename)
 364 {
 365   /* As of 10.6, NSImage rotates according to EXIF by default:
 366      http://developer.apple.com/mac/library/releasenotes/cocoa/appkit.html
 367      So this function should return -1 when *running* on 10.6 systems.
 368      But when running against older systems, we need to examine the image
 369      to figure out its rotation.
 370    */
 371
 372 # if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6  /* 10.6 SDK */
 373
 374   /* When we have compiled against the 10.6 SDK, we know that we are
 375      running on a 10.6 or later system.
 376    */
 377   return -1;
 378
 379 # else /* Compiled against 10.5 SDK or earlier */
 380
 381   /* If this selector exists, then we are running against a 10.6 runtime
 382      that does automatic EXIF rotation (despite the fact that we were
 383      compiled against the 10.5 or earlier SDK).  So in that case, this
 384      function should no-op.
 385    */
 386   if ([NSImage instancesRespondToSelector:
 387                  @selector(initWithDataIgnoringOrientation:)])
 388     return -1;
 389
 390   /* Otherwise, go ahead and figure out what the rotational characteristics
 391      of this image are. */
 392
 393
 394
 395   /* This is a ridiculous amount of rigamarole to go through, but for some
 396      reason the "Orientation" tag does not exist in the "NSImageEXIFData"
 397      dictionary inside the NSBitmapImageRep of the NSImage.  Several other
 398      EXIF tags are there (e.g., shutter speed) but not orientation.  WTF?
 399    */
 400   CFStringRef s = CFStringCreateWithCString (NULL, filename,
 401                                              kCFStringEncodingUTF8);
 402   CFURLRef url = CFURLCreateWithFileSystemPath (NULL, s,
 403                                                 kCFURLPOSIXPathStyle, 0);
 404   CGImageSourceRef cgimg = CGImageSourceCreateWithURL (url, NULL);
 405   if (! cgimg) return -1;
 406
 407   NSDictionary *props = (NSDictionary *)
 408     CGImageSourceCopyPropertiesAtIndex (cgimg, 0, NULL);
 409   int rot = [[props objectForKey:@"Orientation"] intValue];
 410   CFRelease (cgimg);
 411   CFRelease (url);
 412   CFRelease (s);
 413   return rot;
 414
 415 # endif /* 10.5 */
 416 }
 417
 418 # endif /* USE_IPHONE */
 419
 420
 421
 422 /* Loads an image file and splats it onto the drawable.
 423    The image is drawn as large as possible while preserving its aspect ratio.
 424    If geom_ret is provided, the actual rectangle the rendered image takes
 425    up will be returned there.
 426  */
 427 Bool
 428 osx_load_image_file (Screen *screen, Window xwindow, Drawable drawable,
 429                      const char *filename, XRectangle *geom_ret)
 430 {
 431 # ifndef USE_IPHONE
 432
 433   NSImage *img = [[NSImage alloc] initWithContentsOfFile:
 434                                     [NSString stringWithCString:filename
 435                                               encoding:NSUTF8StringEncoding]];
 436   if (!img)
 437     return False;
 438
 439   jwxyz_draw_NSImage_or_CGImage (DisplayOfScreen (screen), drawable,
 440                                  True, img, geom_ret,
 441                                  exif_rotation (filename));
 442   [img release];
 443   return True;
 444
 445 # else  /* USE_IPHONE */
 446
 447   /* It would be nice to select a random image from the Photo Album and
 448      load that, but that looks like a gigantic pain in the ass, because
 449      it's an asynchronous API, and might require manual authorization
 450      by the user.  (ALAssetsLibrary, enumerateGroupsWithTypes.)
 451
 452      Possibly useful sample code to check out:
 453        http://www.fiveminutes.eu/accessing-photo-library-using-assets-library-framework-on-iphone/
 454
 455      So, in the meantime, return False, acquire colorbars.
 456    */
 457   return False;
 458
 459 # endif /* USE_IPHONE */
 460 }