static UncompressedImage
CGImageToUncompressedImage(CGImageRef image)
{
if (image == nullptr)
return UncompressedImage();
size_t width = CGImageGetWidth(image);
size_t height = CGImageGetHeight(image);
if ((0 == width) || (0 == height))
return UncompressedImage();
size_t bits_per_pixel = CGImageGetBitsPerPixel(image);
size_t bits_per_component = CGImageGetBitsPerComponent(image);
CGColorSpaceRef colorspace = CGImageGetColorSpace(image);
size_t row_size;
UncompressedImage::Format format;
CGColorSpaceRef bitmap_colorspace;
CGBitmapInfo bitmap_info;
if ((8 == bits_per_pixel) &&
(8 == bits_per_component) &&
(CGColorSpaceGetModel(colorspace) == kCGColorSpaceModelMonochrome)) {
row_size = width;
format = UncompressedImage::Format::GRAY;
static CGColorSpaceRef grey_colorspace = CGColorSpaceCreateDeviceGray();
bitmap_colorspace = grey_colorspace;
bitmap_info = 0;
} else {
static CGColorSpaceRef rgb_colorspace = CGColorSpaceCreateDeviceRGB();
bitmap_colorspace = rgb_colorspace;
if ((24 == bits_per_pixel) && (8 == bits_per_component)) {
row_size = width * 3;
format = UncompressedImage::Format::RGB;
bitmap_info = kCGBitmapByteOrder32Big;
} else {
row_size = width * 4;
format = UncompressedImage::Format::RGBA;
bitmap_info = kCGImageAlphaPremultipliedLast |
kCGBitmapByteOrder32Big;
}
}
std::unique_ptr<uint8_t[]> uncompressed(new uint8_t[height * row_size]);
CGContextRef bitmap = CGBitmapContextCreate(uncompressed.get(), width, height,
8, row_size, bitmap_colorspace,
bitmap_info);
if (nullptr == bitmap) {
return UncompressedImage();
}
AtScopeExit(bitmap) { CFRelease(bitmap); };
CGContextDrawImage(bitmap, CGRectMake(0, 0, width, height), image);
return UncompressedImage(format, row_size, width, height,
std::move(uncompressed));
}
void pop_img_props (CGImageRef source_image, img_prop im_props) {
// Populate the remaining image property struct values
im_props->image_w = CGImageGetWidth (source_image);
im_props->image_h = CGImageGetHeight (source_image);
im_props->bits_ppixel = CGImageGetBitsPerPixel (source_image);
im_props->bytes_row = CGImageGetBytesPerRow (source_image);
} // pop_img_props
// Ok, a bit freaky coz we want non-premultipied alpha!
//
BBDataBuffer *BBLoadImageData( BBDataBuffer *buf,String path,Array<int> info ) {
path=String( "data/" )+path;
NSString *nspath=path.ToNSString();
//This was apparently buggy in iOS2.x, but NO MORE?
UIImage *uiimage=[ UIImage imageNamed:nspath ];
if( !uiimage ) return 0;
CGImageRef cgimage=uiimage.CGImage;
int width=CGImageGetWidth( cgimage );
int height=CGImageGetHeight( cgimage );
int pitch=CGImageGetBytesPerRow( cgimage );
int bpp=CGImageGetBitsPerPixel( cgimage );
if( bpp!=24 && bpp!=32 ) return 0;
CFDataRef cfdata=CGDataProviderCopyData( CGImageGetDataProvider( cgimage ) );
unsigned char *src=(unsigned char*)CFDataGetBytePtr( cfdata );
int srclen=(int)CFDataGetLength( cfdata );
if( !buf->_New( width*height*4 ) ) return 0;
unsigned char *dst=(unsigned char*)buf->WritePointer();
int y;
switch( bpp ) {
case 24:
for( y=0; y<height; ++y ) {
for( int x=0; x<width; ++x ) {
*dst++=*src++;
*dst++=*src++;
*dst++=*src++;
*dst++=255;
}
src+=pitch-width*3;
}
break;
case 32:
for( y=0; y<height; ++y ) {
memcpy( dst,src,width*4 );
dst+=width*4;
src+=pitch;
}
break;
}
if( info.Length()>0 ) info[0]=width;
if( info.Length()>1 ) info[1]=height;
CFRelease( cfdata );
return buf;
}
cv::Mat &osx_cv::toMat(
const CGImageRef &image,
cv::Mat &out,
osx::disp::RGBType destType
) {
cv::Mat temp;
size_t w = CGImageGetWidth(image), h = CGImageGetHeight(image);
if (CGImageGetBitsPerPixel(image) != 32) {
throw invalid_argument("`image` must be 32 bits per pixel");
}
temp.create(int(h), int(w), CV_8UC4);
CGColorSpaceRef colorSpace = CGImageGetColorSpace(image);
CGContextRef context = CGBitmapContextCreate(
temp.data,
w,
h,
CGImageGetBitsPerComponent(image),
CGImageGetBytesPerRow(image),
colorSpace,
CGImageGetAlphaInfo(image)
);
CGContextDrawImage(
context,
CGRectMake(0, 0, (CGFloat)w, (CGFloat)h),
image
);
_cvtRGBColor(temp, out, CGImageGetAlphaInfo(image), destType);
CGContextRelease(context);
return out;
}
Screenshot* ScreenShooter::take_screenshot(const CFStringRef format, float compression) {
CGImageRef* images = new CGImageRef[_dsp_count];
/* Grab the images */
for (unsigned int i = 0; i < _dsp_count; i++) {
images[i] = CGDisplayCreateImage(_displays[i]);
}
/* Calculate size of image to produce */
CGSize finalSize = CGSizeMake(_top_right.x - _bottom_left.x, _bottom_left.y - _top_right.y);
/* Round out the bitmap size information */
size_t bytesPerRow = finalSize.width * CGImageGetBitsPerPixel(images[0]) / 8;
/* Create context around bitmap */
CGContextRef context = CGBitmapContextCreate(
NULL, finalSize.width, finalSize.height,
CGImageGetBitsPerComponent(images[0]), bytesPerRow,
CGImageGetColorSpace(images[0]), CGImageGetBitmapInfo(images[0])
);
/* Draw images into the bitmap */
for (unsigned int i = 0; i < _dsp_count; i++)
{
/* Adjust the positions to account for coordinate system shifts
(displays origin is at top left; image origin is at bottom left) */
CGRect adjustedPoint = CGRectMake(_display_bounds[i].origin.x - _bottom_left.x,
_bottom_left.y - _display_bounds[i].size.height - _display_bounds[i].origin.y,
_display_bounds[i].size.width,
_display_bounds[i].size.height);
CGContextDrawImage(context, adjustedPoint, images[i]);
}
delete [] images;
return new Screenshot(context, format, compression);
}
/* Once we have our image (CGImageRef), we need to get it into an osg::Image */
osg::Image* CreateOSGImageFromCGImage(CGImageRef image_ref)
{
/* This code is adapted from Apple's Documentation found here:
* http://developer.apple.com/documentation/GraphicsImaging/Conceptual/OpenGL-MacProgGuide/index.html
* Listing 9-4††Using a Quartz image as a texture source.
* Unfortunately, this guide doesn't show what to do about
* non-RGBA image formats so I'm making the rest up
* (and it's probably all wrong).
*/
size_t the_width = CGImageGetWidth(image_ref);
size_t the_height = CGImageGetHeight(image_ref);
CGRect the_rect = {{0, 0}, {the_width, the_height}};
size_t bits_per_pixel = CGImageGetBitsPerPixel(image_ref);
size_t bytes_per_row = CGImageGetBytesPerRow(image_ref);
// size_t bits_per_component = CGImageGetBitsPerComponent(image_ref);
size_t bits_per_component = 8;
CGImageAlphaInfo alpha_info = CGImageGetAlphaInfo(image_ref);
GLint internal_format;
GLenum pixel_format;
GLenum data_type;
void* image_data = calloc(the_width * 4, the_height);
CGColorSpaceRef color_space;
CGBitmapInfo bitmap_info = CGImageGetBitmapInfo(image_ref);
switch(bits_per_pixel)
{
// Drat, if 8-bit, how do you distinguish
// between a 256 color GIF, a LUMINANCE map
// or an ALPHA map?
case 8:
{
// I probably did the formats all wrong for this case,
// especially the ALPHA case.
if(kCGImageAlphaNone == alpha_info)
{
/*
internal_format = GL_LUMINANCE;
pixel_format = GL_LUMINANCE;
*/
internal_format = GL_RGBA8;
pixel_format = GL_BGRA_EXT;
data_type = GL_UNSIGNED_INT_8_8_8_8_REV;
bytes_per_row = the_width*4;
// color_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
color_space = CGColorSpaceCreateDeviceRGB();
// bitmap_info = kCGImageAlphaPremultipliedFirst;
#if __BIG_ENDIAN__
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big; /* XRGB Big Endian */
#else
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little; /* XRGB Little Endian */
#endif
}
else
{
internal_format = GL_ALPHA;
pixel_format = GL_ALPHA;
data_type = GL_UNSIGNED_BYTE;
// bytes_per_row = the_width;
// color_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
color_space = CGColorSpaceCreateDeviceGray();
}
break;
}
case 24:
{
internal_format = GL_RGBA8;
pixel_format = GL_BGRA_EXT;
data_type = GL_UNSIGNED_INT_8_8_8_8_REV;
bytes_per_row = the_width*4;
// color_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
color_space = CGColorSpaceCreateDeviceRGB();
// bitmap_info = kCGImageAlphaNone;
#if __BIG_ENDIAN__
bitmap_info = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Big; /* XRGB Big Endian */
#else
bitmap_info = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Little; /* XRGB Little Endian */
#endif
break;
}
//
// Tatsuhiro Nishioka
// 16 bpp grayscale (8 bit white and 8 bit alpha) causes invalid argument combination
// in CGBitmapContextCreate.
// I guess it is safer to handle 16 bit grayscale image as 32-bit RGBA image.
// It works at least on FlightGear
//
case 16:
case 32:
case 48:
case 64:
{
internal_format = GL_RGBA8;
pixel_format = GL_BGRA_EXT;
data_type = GL_UNSIGNED_INT_8_8_8_8_REV;
bytes_per_row = the_width*4;
// color_space = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
color_space = CGColorSpaceCreateDeviceRGB();
// bitmap_info = kCGImageAlphaPremultipliedFirst;
#if __BIG_ENDIAN__
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big; /* XRGB Big Endian */
#else
bitmap_info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little; /* XRGB Little Endian */
#endif
break;
}
default:
{
// OSG_WARN << "Unknown file type in " << fileName.c_str() << " with " << origDepth << std::endl;
return NULL;
break;
}
}
// Sets up a context to be drawn to with image_data as the area to be drawn to
CGContextRef bitmap_context = CGBitmapContextCreate(
image_data,
the_width,
the_height,
bits_per_component,
bytes_per_row,
color_space,
bitmap_info
);
CGContextTranslateCTM(bitmap_context, 0, the_height);
CGContextScaleCTM(bitmap_context, 1.0, -1.0);
// Draws the image into the context's image_data
CGContextDrawImage(bitmap_context, the_rect, image_ref);
CGContextRelease(bitmap_context);
if (!image_data)
return NULL;
// alpha is premultiplied with rgba, undo it
vImage_Buffer vb;
vb.data = image_data;
vb.height = the_height;
vb.width = the_width;
vb.rowBytes = the_width * 4;
vImageUnpremultiplyData_RGBA8888(&vb, &vb, 0);
// changing it to GL_UNSIGNED_BYTE seems working, but I'm not sure if this is a right way.
//
data_type = GL_UNSIGNED_BYTE;
osg::Image* osg_image = new osg::Image;
osg_image->setImage(
the_width,
the_height,
1,
internal_format,
pixel_format,
data_type,
(unsigned char*)image_data,
osg::Image::USE_MALLOC_FREE // Assumption: osg_image takes ownership of image_data and will free
);
return osg_image;
}
//============================================================================
// NCGImage::SetObject : Set the object.
//----------------------------------------------------------------------------
bool NCGImage::SetObject(CGImageRef cfObject, bool takeOwnership)
{ size_t theWidth, theHeight, bitsPerPixel, bitsPerComponent;
NCFObject theObject(cfObject, takeOwnership);
NCFObject cgColorSpace, cgContext;
CGBitmapInfo bitmapInfo;
NImageFormat theFormat;
NImage theImage;
bool isValid;
// Get the state we need
theWidth = CGImageGetWidth( cfObject);
theHeight = CGImageGetHeight( cfObject);
bitsPerPixel = CGImageGetBitsPerPixel( cfObject);
bitsPerComponent = CGImageGetBitsPerComponent(cfObject);
// Select the image format
if (bitsPerPixel == 8 && bitsPerComponent == 8)
{
// Convert indexed images to 32bpp without alpha
theFormat = kNImageFormat_RGBX_8888;
bitmapInfo = kCGBitmapByteOrder32Big | kCGImageAlphaNoneSkipLast;
cgColorSpace = NCGColor::GetDeviceRGB();
}
else if (bitsPerPixel == 24 && bitsPerComponent == 8)
{
// Convert 24bpp images to 32bpp without alpha
theFormat = kNImageFormat_RGBX_8888;
bitmapInfo = kCGBitmapByteOrder32Big | kCGImageAlphaNoneSkipLast;
cgColorSpace = NCGColor::GetDeviceRGB();
}
else if (bitsPerPixel == 32 && bitsPerComponent == 8)
{
// Convert 32bpp images to 32bpp with alpha
theFormat = kNImageFormat_RGBA_8888;
bitmapInfo = kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast;
cgColorSpace = NCGColor::GetDeviceRGB();
}
else
{
NN_LOG("Unknown image format: %d/%d", bitsPerPixel, bitsPerComponent);
theFormat = kNImageFormatNone;
bitmapInfo = kCGImageAlphaNone;
}
if (!cgColorSpace.IsValid())
return(false);
// Set the object
theImage = NImage(NSize(theWidth, theHeight), theFormat);
isValid = cgContext.SetObject(CGBitmapContextCreate( theImage.GetPixels(),
theWidth,
theHeight,
bitsPerComponent,
theImage.GetBytesPerRow(),
cgColorSpace,
bitmapInfo));
if (isValid)
{
CGContextDrawImage(cgContext, ToCG(theImage.GetBounds()), cfObject);
*this = theImage;
}
return(isValid);
}
/* read image file */
int BIReadFile(
const char *fileName,
BIFileType fileType,
BIPadMode padMode,
unsigned padSize,
BIImageInfo *imageInfo, /* RETURNED */
unsigned char **bitmap) /* mallocd and RETURNED; caller must free */
{
CFURLRef fileURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(unsigned char*)fileName, strlen(fileName), FALSE);
if(fileURL == NULL) {
fprintf(stderr, "***BIReadFile: Error on CFURLCreateFromFileSystemRepresentation\n");
return -1;
}
CFStringRef keys[1] = {kCGImageSourceTypeIdentifierHint};
CFStringRef values[1] = {BIGetUTI(fileURL, fileType)};
if(values[0] == NULL) {
return -1;
}
CFDictionaryRef optionsDict = NULL;
CGImageSourceRef imageSourceRef = NULL;
CGImageRef imageRef = NULL;
CGColorSpaceRef rgbColorSpaceRef = NULL;
CGContextRef bitmapContextRef = NULL;
CGBitmapInfo bitmapInfo = 0;
CGImageAlphaInfo alpha;
unsigned bytesPerPixel = 4;
optionsDict = CFDictionaryCreate( kCFAllocatorDefault,
(const void **)keys, (const void **)values, 1,
&kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks );
/* subsequent errors to errOut: */
int ourRtn = 0;
/* source file --> CGImageRef */
imageSourceRef = CGImageSourceCreateWithURL(fileURL, optionsDict);
if(imageSourceRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGImageSourceCreateWithURL\n");
ourRtn = 1;
goto errOut;
}
CFRELEASE(fileURL);
imageRef = CGImageSourceCreateImageAtIndex(imageSourceRef, 0, optionsDict );
if(imageRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGImageSourceCreateImageAtIndex\n");
ourRtn = 1;
goto errOut;
}
imageInfo->imageWidth = CGImageGetWidth(imageRef);
imageInfo->imageHeight = CGImageGetHeight(imageRef);
imageInfo->bitsPerComponent = CGImageGetBitsPerComponent(imageRef);
imageInfo->bitsPerPixel = CGImageGetBitsPerPixel(imageRef);
if(imageInfo->bitsPerPixel == 8) {
/* the image is gray */
rgbColorSpaceRef = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
imageInfo->bytesPerRow = imageInfo->imageWidth;
alpha = kCGImageAlphaNone;
bitmapInfo = CGImageGetBitmapInfo(imageRef);
bytesPerPixel = 1;
}
else {
rgbColorSpaceRef = CGColorSpaceCreateDeviceRGB();
imageInfo->bytesPerRow = imageInfo->imageWidth * 4;
alpha = kCGImageAlphaPremultipliedLast;
bitmapInfo = kCGBitmapByteOrder32Big | alpha;
}
if(rgbColorSpaceRef == NULL) {
fprintf(stderr, "***BIReadFile: Error on CGColorSpaceCreateWithName\n");
ourRtn = 1;
goto errOut;
}
/* optionally pad */
imageInfo->effectHeight = imageInfo->imageHeight;
if(padMode != PM_None) {
if(padSize == 0) {
fprintf(stderr, "***Pad size of 0 invalid\n");
ourRtn = 1;
goto errOut;
}
unsigned padSizeBytes = padSize;
if(padMode == PM_Pixels) {
padSizeBytes *= bytesPerPixel;
}
imageInfo->bytesPerRow = ROUND_TO(imageInfo->bytesPerRow, padSizeBytes);
/* also round up row count */
imageInfo->effectHeight = ROUND_TO(imageInfo->imageHeight, padSize);
}
*bitmap = (unsigned char *)malloc(imageInfo->bytesPerRow * imageInfo->effectHeight);
bitmapContextRef = CGBitmapContextCreate(*bitmap,
imageInfo->imageWidth, imageInfo->imageHeight,
imageInfo->bitsPerComponent, imageInfo->bytesPerRow,
rgbColorSpaceRef,
bitmapInfo);
if(bitmapContextRef == NULL) {
fprintf(stderr, "***BIReadFile: Error creating CGBitmapContext\n");
ourRtn = 1;
goto errOut;
}
/* enable high quality interpolation */
CGContextSetInterpolationQuality(bitmapContextRef, kCGInterpolationHigh);
/* Draw into the context */
CGContextDrawImage(bitmapContextRef, CGRectMake(0, 0, imageInfo->imageWidth, imageInfo->imageHeight),
imageRef);
errOut:
CFRELEASE(optionsDict);
CFRELEASE(imageSourceRef);
CFRELEASE(imageRef);
CFRELEASE(rgbColorSpaceRef);
CFRELEASE(bitmapContextRef);
if(ourRtn) {
if(*bitmap) {
free(*bitmap);
*bitmap = NULL;
}
}
return ourRtn;
}
bool GraphicsContext3D::getImageData(Image* image,
unsigned int format,
unsigned int type,
bool premultiplyAlpha,
Vector<uint8_t>& outputVector)
{
if (!image)
return false;
CGImageRef cgImage;
RetainPtr<CGImageRef> decodedImage;
if (image->data()) {
ImageSource decoder(false);
decoder.setData(image->data(), true);
if (!decoder.frameCount())
return false;
decodedImage = decoder.createFrameAtIndex(0);
cgImage = decodedImage.get();
} else
cgImage = image->nativeImageForCurrentFrame();
if (!cgImage)
return false;
size_t width = CGImageGetWidth(cgImage);
size_t height = CGImageGetHeight(cgImage);
if (!width || !height)
return false;
size_t bitsPerComponent = CGImageGetBitsPerComponent(cgImage);
size_t bitsPerPixel = CGImageGetBitsPerPixel(cgImage);
if (bitsPerComponent != 8 && bitsPerComponent != 16)
return false;
if (bitsPerPixel % bitsPerComponent)
return false;
size_t componentsPerPixel = bitsPerPixel / bitsPerComponent;
SourceDataFormat srcDataFormat = kSourceFormatRGBA8;
AlphaOp neededAlphaOp = kAlphaDoNothing;
switch (CGImageGetAlphaInfo(cgImage)) {
case kCGImageAlphaPremultipliedFirst:
// This path is only accessible for MacOS earlier than 10.6.4.
// This is a special case for texImage2D with HTMLCanvasElement input,
// in which case image->data() should be null.
ASSERT(!image->data());
if (!premultiplyAlpha)
neededAlphaOp = kAlphaDoUnmultiply;
switch (componentsPerPixel) {
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatAR8;
else
srcDataFormat = kSourceFormatAR16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatARGB8;
else
srcDataFormat = kSourceFormatARGB16;
break;
default:
return false;
}
break;
case kCGImageAlphaFirst:
// This path is only accessible for MacOS earlier than 10.6.4.
if (premultiplyAlpha)
neededAlphaOp = kAlphaDoPremultiply;
switch (componentsPerPixel) {
case 1:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatA8;
else
srcDataFormat = kSourceFormatA16;
break;
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatAR8;
else
srcDataFormat = kSourceFormatAR16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatARGB8;
else
srcDataFormat = kSourceFormatARGB16;
break;
default:
return false;
}
break;
case kCGImageAlphaNoneSkipFirst:
// This path is only accessible for MacOS earlier than 10.6.4.
switch (componentsPerPixel) {
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatAR8;
else
srcDataFormat = kSourceFormatAR16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatARGB8;
else
srcDataFormat = kSourceFormatARGB16;
break;
default:
return false;
}
break;
case kCGImageAlphaPremultipliedLast:
// This is a special case for texImage2D with HTMLCanvasElement input,
// in which case image->data() should be null.
ASSERT(!image->data());
if (!premultiplyAlpha)
neededAlphaOp = kAlphaDoUnmultiply;
switch (componentsPerPixel) {
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRA8;
else
srcDataFormat = kSourceFormatRA16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRGBA8;
else
srcDataFormat = kSourceFormatRGBA16;
break;
default:
return false;
}
break;
case kCGImageAlphaLast:
if (premultiplyAlpha)
neededAlphaOp = kAlphaDoPremultiply;
switch (componentsPerPixel) {
case 1:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatA8;
else
srcDataFormat = kSourceFormatA16;
break;
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRA8;
else
srcDataFormat = kSourceFormatRA16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRGBA8;
else
srcDataFormat = kSourceFormatRGBA16;
break;
default:
return false;
}
break;
case kCGImageAlphaNoneSkipLast:
switch (componentsPerPixel) {
case 2:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRA8;
else
srcDataFormat = kSourceFormatRA16;
break;
case 4:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRGBA8;
else
srcDataFormat = kSourceFormatRGBA16;
break;
default:
return false;
}
break;
case kCGImageAlphaNone:
switch (componentsPerPixel) {
case 1:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatR8;
else
srcDataFormat = kSourceFormatR16;
break;
case 3:
if (bitsPerComponent == 8)
srcDataFormat = kSourceFormatRGB8;
else
srcDataFormat = kSourceFormatRGB16;
break;
default:
return false;
}
break;
default:
return false;
}
RetainPtr<CFDataRef> pixelData;
pixelData.adoptCF(CGDataProviderCopyData(CGImageGetDataProvider(cgImage)));
if (!pixelData)
return false;
const UInt8* rgba = CFDataGetBytePtr(pixelData.get());
outputVector.resize(width * height * 4);
unsigned int srcUnpackAlignment = 0;
size_t bytesPerRow = CGImageGetBytesPerRow(cgImage);
unsigned int padding = bytesPerRow - bitsPerPixel / 8 * width;
if (padding) {
srcUnpackAlignment = padding + 1;
while (bytesPerRow % srcUnpackAlignment)
++srcUnpackAlignment;
}
bool rt = packPixels(rgba, srcDataFormat, width, height, srcUnpackAlignment,
format, type, neededAlphaOp, outputVector.data());
return rt;
}
void CGImageLuminanceSource::init (CGImageRef cgimage, int left, int top, int width, int height) {
data_ = 0;
image_ = cgimage;
left_ = left;
top_ = top;
width_ = width;
height_ = height;
dataWidth_ = (int)CGImageGetWidth(image_);
dataHeight_ = (int)CGImageGetHeight(image_);
if (left_ + width_ > dataWidth_ ||
top_ + height_ > dataHeight_ ||
top_ < 0 ||
left_ < 0) {
throw IllegalArgumentException("Crop rectangle does not fit within image data.");
}
CGColorSpaceRef space = CGImageGetColorSpace(image_);
CGColorSpaceModel model = CGColorSpaceGetModel(space);
if (model != kCGColorSpaceModelMonochrome || CGImageGetBitsPerComponent(image_) != 8 || CGImageGetBitsPerPixel(image_) != 8) {
CGColorSpaceRef gray = CGColorSpaceCreateDeviceGray();
CGContextRef ctx = CGBitmapContextCreate(0, width, height, 8, width, gray, kCGImageAlphaNone);
CGColorSpaceRelease(gray);
if (top || left) {
CGContextClipToRect(ctx, CGRectMake(0, 0, width, height));
}
CGContextDrawImage(ctx, CGRectMake(-left, -top, width, height), image_);
image_ = CGBitmapContextCreateImage(ctx);
bytesPerRow_ = width;
top_ = 0;
left_ = 0;
dataWidth_ = width;
dataHeight_ = height;
CGContextRelease(ctx);
} else {
CGImageRetain(image_);
}
CGDataProviderRef provider = CGImageGetDataProvider(image_);
data_ = CGDataProviderCopyData(provider);
}
MMBitmapRef copyMMBitmapFromDisplayInRect(MMRect rect)
{
#if defined(IS_MACOSX)
size_t bytewidth;
uint8_t bitsPerPixel, bytesPerPixel;
uint8_t *buffer;
CGDirectDisplayID displayID = CGMainDisplayID();
//Replacement for CGDisplayBitsPerPixel.
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displayID);
size_t depth = 0;
CFStringRef pixEnc = CGDisplayModeCopyPixelEncoding(mode);
if(CFStringCompare(pixEnc, CFSTR(IO32BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 32;
else if(CFStringCompare(pixEnc, CFSTR(IO16BitDirectPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 16;
else if(CFStringCompare(pixEnc, CFSTR(IO8BitIndexedPixels), kCFCompareCaseInsensitive) == kCFCompareEqualTo)
depth = 8;
bitsPerPixel = (uint8_t) depth;
bytesPerPixel = bitsPerPixel / 8;
/* Align width to padding. */
bytewidth = ADD_PADDING(rect.size.width * bytesPerPixel);
/* Convert Quartz point to postscript point. */
rect.origin.y = CGDisplayPixelsHigh(displayID) - rect.origin.y - rect.size.height;
CGImageRef image = CGDisplayCreateImageForRect(displayID, CGRectMake(rect.origin.x, rect.origin.y, rect.size.width, rect.size.height));
// Request access to the raw pixel data via the image's DataProvider.
CGDataProviderRef provider = CGImageGetDataProvider(image);
CFDataRef data = CGDataProviderCopyData(provider);
size_t width, height;
width = CGImageGetWidth(image);
height = CGImageGetHeight(image);
size_t bpp = CGImageGetBitsPerPixel(image) / 8;
uint8 *pixels = malloc(width * height * bpp);
memcpy(pixels, CFDataGetBytePtr(data), width * height * bpp);
CFRelease(data);
CGImageRelease(image);
return createMMBitmap(pixels, rect.size.width, rect.size.height, bytewidth,
bitsPerPixel, bytesPerPixel);
#elif defined(USE_X11)
MMBitmapRef bitmap;
Display *display = XOpenDisplay(NULL);
XImage *image = XGetImage(display,
XDefaultRootWindow(display),
(int)rect.origin.x,
(int)rect.origin.y,
(unsigned int)rect.size.width,
(unsigned int)rect.size.height,
AllPlanes, ZPixmap);
XCloseDisplay(display);
if (image == NULL) return NULL;
bitmap = createMMBitmap((uint8_t *)image->data,
rect.size.width,
rect.size.height,
(size_t)image->bytes_per_line,
(uint8_t)image->bits_per_pixel,
(uint8_t)image->bits_per_pixel / 8);
image->data = NULL; /* Steal ownership of bitmap data so we don't have to
* copy it. */
XDestroyImage(image);
return bitmap;
#elif defined(IS_WINDOWS)
MMBitmapRef bitmap;
void *data;
HDC screen = NULL, screenMem = NULL;
HBITMAP dib;
BITMAPINFO bi;
/* Initialize bitmap info. */
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = (long)rect.size.width;
bi.bmiHeader.biHeight = -(long)rect.size.height; /* Non-cartesian, please */
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 32;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = (DWORD)(4 * rect.size.width * rect.size.height);
bi.bmiHeader.biXPelsPerMeter = 0;
bi.bmiHeader.biYPelsPerMeter = 0;
bi.bmiHeader.biClrUsed = 0;
bi.bmiHeader.biClrImportant = 0;
screen = GetDC(NULL); /* Get entire screen */
if (screen == NULL) return NULL;
/* Get screen data in display device context. */
dib = CreateDIBSection(screen, &bi, DIB_RGB_COLORS, &data, NULL, 0);
/* Copy the data into a bitmap struct. */
if ((screenMem = CreateCompatibleDC(screen)) == NULL ||
SelectObject(screenMem, dib) == NULL ||
!BitBlt(screenMem,
(int)rect.origin.x,
(int)rect.origin.y,
(int)rect.size.width,
(int)rect.size.height, screen, 0, 0, SRCCOPY)) {
/* Error copying data. */
ReleaseDC(NULL, screen);
DeleteObject(dib);
if (screenMem != NULL) DeleteDC(screenMem);
return NULL;
}
bitmap = createMMBitmap(NULL,
rect.size.width,
rect.size.height,
4 * rect.size.width,
(uint8_t)bi.bmiHeader.biBitCount,
4);
/* Copy the data to our pixel buffer. */
if (bitmap != NULL) {
bitmap->imageBuffer = malloc(bitmap->bytewidth * bitmap->height);
memcpy(bitmap->imageBuffer, data, bitmap->bytewidth * bitmap->height);
}
ReleaseDC(NULL, screen);
DeleteObject(dib);
DeleteDC(screenMem);
return bitmap;
#endif
}
