Retired Document
Important: This sample code may not represent best practices for current development. The project may use deprecated symbols and illustrate technologies and techniques that are no longer recommended.
Relevant replacement documents include:
OpenGLScreenReader.m
/* |
File: OpenGLScreenReader.m |
Abstract: OpenGLScreenReader class implementation. Contains |
OpenGL code which creates a full-screen OpenGL context |
to use for rendering, then calls glReadPixels to read the |
actual screen bits. |
Version: 1.0 |
Disclaimer: IMPORTANT: This Apple software is supplied to you by |
Apple Inc. ("Apple") in consideration of your agreement to the |
following terms, and your use, installation, modification or |
redistribution of this Apple software constitutes acceptance of these |
terms. If you do not agree with these terms, please do not use, |
install, modify or redistribute this Apple software. |
In consideration of your agreement to abide by the following terms, and |
subject to these terms, Apple grants you a personal, non-exclusive |
license, under Apple's copyrights in this original Apple software (the |
"Apple Software"), to use, reproduce, modify and redistribute the Apple |
Software, with or without modifications, in source and/or binary forms; |
provided that if you redistribute the Apple Software in its entirety and |
without modifications, you must retain this notice and the following |
text and disclaimers in all such redistributions of the Apple Software. |
Neither the name, trademarks, service marks or logos of Apple Inc. |
may be used to endorse or promote products derived from the Apple |
Software without specific prior written permission from Apple. Except |
as expressly stated in this notice, no other rights or licenses, express |
or implied, are granted by Apple herein, including but not limited to |
any patent rights that may be infringed by your derivative works or by |
other works in which the Apple Software may be incorporated. |
The Apple Software is provided by Apple on an "AS IS" basis. APPLE |
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION |
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS |
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND |
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS. |
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL |
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, |
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED |
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), |
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE |
POSSIBILITY OF SUCH DAMAGE. |
Copyright (C) 2007 Apple Inc. All Rights Reserved. |
*/ |
#import "OpenGLScreenReader.h" |
@interface OpenGLScreenReader (PrivateMethods) |
-(void)flipImageData; |
-(CGImageRef)createRGBImageFromBufferData; |
@end |
@implementation OpenGLScreenReader (PrivateMethods) |
/* |
* perform an in-place swap from Quadrant 1 to Quadrant III format |
* (upside-down PostScript/GL to right side up QD/CG raster format) |
* We do this in-place, which requires more copying, but will touch |
* only half the pages. (Display grabs are BIG!) |
* |
* Pixel reformatting may optionally be done here if needed. |
*/ |
-(void)flipImageData |
{ |
long top, bottom; |
void * buffer; |
void * topP; |
void * bottomP; |
void * base; |
long rowBytes; |
top = 0; |
bottom = mHeight - 1; |
base = mData; |
rowBytes = mByteWidth; |
buffer = malloc(rowBytes); |
NSAssert( buffer != nil, @"malloc failure"); |
while ( top < bottom ) |
{ |
topP = (void *)((top * rowBytes) + (intptr_t)base); |
bottomP = (void *)((bottom * rowBytes) + (intptr_t)base); |
/* |
* Save and swap scanlines. |
* |
* This code does a simple in-place exchange with a temp buffer. |
* If you need to reformat the pixels, replace the first two bcopy() |
* calls with your own custom pixel reformatter. |
*/ |
bcopy( topP, buffer, rowBytes ); |
bcopy( bottomP, topP, rowBytes ); |
bcopy( buffer, bottomP, rowBytes ); |
++top; |
--bottom; |
} |
free( buffer ); |
} |
// Create a RGB CGImageRef from our buffer data |
-(CGImageRef)createRGBImageFromBufferData |
{ |
CGColorSpaceRef cSpace = CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB); |
NSAssert( cSpace != NULL, @"CGColorSpaceCreateWithName failure"); |
CGContextRef bitmap = CGBitmapContextCreate(mData, mWidth, mHeight, 8, mByteWidth, |
cSpace, |
#if __BIG_ENDIAN__ |
kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Big /* XRGB Big Endian */); |
#else |
kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Little /* XRGB Little Endian */); |
#endif |
NSAssert( bitmap != NULL, @"CGBitmapContextCreate failure"); |
// Get rid of color space |
CFRelease(cSpace); |
// Make an image out of our bitmap; does a cheap vm_copy of the |
// bitmap |
CGImageRef image = CGBitmapContextCreateImage(bitmap); |
NSAssert( image != NULL, @"CGBitmapContextCreate failure"); |
// Get rid of bitmap |
CFRelease(bitmap); |
return image; |
} |
@end |
@implementation OpenGLScreenReader |
#pragma mark ---------- Initialization ---------- |
-(id) init |
{ |
if (self = [super init]) |
{ |
// Create a full-screen OpenGL graphics context |
// Specify attributes of the GL graphics context |
NSOpenGLPixelFormatAttribute attributes[] = { |
NSOpenGLPFAFullScreen, |
NSOpenGLPFAScreenMask, |
CGDisplayIDToOpenGLDisplayMask(kCGDirectMainDisplay), |
(NSOpenGLPixelFormatAttribute) 0 |
}; |
NSOpenGLPixelFormat *glPixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes]; |
if (!glPixelFormat) |
{ |
return nil; |
} |
// Create OpenGL context used to render |
mGLContext = [[[NSOpenGLContext alloc] initWithFormat:glPixelFormat shareContext:nil] autorelease]; |
// Cleanup, pixel format object no longer needed |
[glPixelFormat release]; |
if (!mGLContext) |
{ |
[self release]; |
return nil; |
} |
[mGLContext retain]; |
// Set our context as the current OpenGL context |
[mGLContext makeCurrentContext]; |
// Set full-screen mode |
[mGLContext setFullScreen]; |
NSRect mainScreenRect = [[NSScreen mainScreen] frame]; |
mWidth = mainScreenRect.size.width; |
mHeight = mainScreenRect.size.height; |
mByteWidth = mWidth * 4; // Assume 4 bytes/pixel for now |
mByteWidth = (mByteWidth + 3) & ~3; // Align to 4 bytes |
mData = malloc(mByteWidth * mHeight); |
NSAssert( mData != 0, @"malloc failed"); |
} |
return self; |
} |
#pragma mark ---------- Screen Reader ---------- |
// Perform a simple, synchronous full-screen read operation using glReadPixels(). |
// Although this is not the most optimal technique, it is sufficient for doing |
// simple one-shot screen grabs. |
- (void) readFullScreenToBuffer |
{ |
[self readPartialScreenToBuffer: mWidth bufferHeight: mHeight bufferBaseAddress: mData]; |
} |
// Use this routine if you want to read only a portion of the screen pixels |
- (void) readPartialScreenToBuffer: (size_t) width bufferHeight:(size_t) height bufferBaseAddress: (void *) baseAddress |
{ |
// select front buffer as our source for pixel data |
glReadBuffer(GL_FRONT); |
//Read OpenGL context pixels directly. |
// For extra safety, save & restore OpenGL states that are changed |
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT); |
glPixelStorei(GL_PACK_ALIGNMENT, 4); /* Force 4-byte alignment */ |
glPixelStorei(GL_PACK_ROW_LENGTH, 0); |
glPixelStorei(GL_PACK_SKIP_ROWS, 0); |
glPixelStorei(GL_PACK_SKIP_PIXELS, 0); |
//Read a block of pixels from the frame buffer |
glReadPixels(0, 0, width, height, GL_BGRA, |
/* |
IMPORTANT |
For the pixel data format and type parameters you should *always* specify: |
format: GL_BGRA |
type: GL_UNSIGNED_INT_8_8_8_8_REV |
because this is the native format of the GPU for both PPC and Intel and will |
give you the best performance. Any deviation from this format will not give |
you optimal performance! |
BACKGROUND |
When using GL_UNSIGNED_INT_8_8_8_8_REV, the OpenGL implementation |
expects to find data in byte order ARGB on big-endian systems, but BGRA on |
little-endian systems. Because there is no explicit way in OpenGL to specify |
a byte order of ARGB with 32-bit or 16-bit packed pixels (which are common |
image formats on Macintosh PowerPC computers), many applications specify |
GL_BGRA with GL_UNSIGNED_INT_8_8_8_8_REV. This practice works on a |
big-endian system such as PowerPC, but the format is interpreted differently |
on a little-endian system, and causes images to be rendered with incorrect colors. |
To prevent images from being rendered incorrectly by this application on little |
endian systems, you must specify the ordering of the data (big/little endian) |
when creating Quartz bitmap contexts using the CGBitmapContextCreate function. |
See the createRGBImageFromBufferData: method in the Buffer.m source file for |
the details. |
Also, if you need to reverse endianness, consider using vImage after the read. See: |
http://developer.apple.com/documentation/Performance/Conceptual/vImage/ |
*/ |
GL_UNSIGNED_INT_8_8_8_8_REV, |
baseAddress); |
glPopClientAttrib(); |
//Check for OpenGL errors |
GLenum theError = GL_NO_ERROR; |
theError = glGetError(); |
NSAssert1( theError == GL_NO_ERROR, @"OpenGL error 0x%04X", theError); |
} |
// Create a TIFF file on the desktop from our data buffer |
-(void)createTIFFImageFileOnDesktop |
{ |
// glReadPixels writes things from bottom to top, but we |
// need a top to bottom representation, so we must flip |
// the buffer contents. |
[self flipImageData]; |
// Create a Quartz image from our pixel buffer bits |
CGImageRef imageRef = [self createRGBImageFromBufferData]; |
NSAssert( imageRef != 0, @"cgImageFromPixelBuffer failed"); |
// Make full pathname to the desktop directory |
NSString *desktopDirectory = nil; |
NSArray *paths = NSSearchPathForDirectoriesInDomains |
(NSDesktopDirectory, NSUserDomainMask, YES); |
if ([paths count] > 0) |
{ |
desktopDirectory = [paths objectAtIndex:0]; |
} |
NSMutableString *fullFilePathStr = [NSMutableString stringWithString:desktopDirectory]; |
NSAssert( fullFilePathStr != nil, @"stringWithString failed"); |
[fullFilePathStr appendString:@"/ScreenSnapshot.tiff"]; |
NSString *finalPath = [NSString stringWithString:fullFilePathStr]; |
NSAssert( finalPath != nil, @"stringWithString failed"); |
CFURLRef url = CFURLCreateWithFileSystemPath ( |
kCFAllocatorDefault, |
(CFStringRef)finalPath, |
kCFURLPOSIXPathStyle, |
false); |
NSAssert( url != 0, @"CFURLCreateWithFileSystemPath failed"); |
// Save our screen bits to an image file on disk |
// Save the image to the file |
CGImageDestinationRef dest = CGImageDestinationCreateWithURL(url, CFSTR("public.tiff"), 1, nil); |
NSAssert( dest != 0, @"CGImageDestinationCreateWithURL failed"); |
// Set the image in the image destination to be `image' with |
// optional properties specified in saved properties dict. |
CGImageDestinationAddImage(dest, imageRef, nil); |
bool success = CGImageDestinationFinalize(dest); |
NSAssert( success != 0, @"Image could not be written successfully"); |
CFRelease(dest); |
CGImageRelease(imageRef); |
CFRelease(url); |
} |
#pragma mark ---------- Cleanup ---------- |
-(void)dealloc |
{ |
// Get rid of GL context |
[NSOpenGLContext clearCurrentContext]; |
// disassociate from full screen |
[mGLContext clearDrawable]; |
// and release the context |
[mGLContext release]; |
// release memory for screen data |
free(mData); |
[super dealloc]; |
} |
@end |
Copyright © 2008 Apple Inc. All Rights Reserved. Terms of Use | Privacy Policy | Updated: 2008-08-14