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));
}
bool ImageIODecoder::readHeader()
{
CFURLRef imageURLRef;
CGImageSourceRef sourceRef;
// diciu, if ReadHeader is called twice in a row make sure to release the previously allocated imageRef
if (imageRef != NULL)
CGImageRelease(imageRef);
imageRef = NULL;
imageURLRef = CFURLCreateFromFileSystemRepresentation( NULL,
(const UInt8*)m_filename.c_str(), m_filename.size(), false );
sourceRef = CGImageSourceCreateWithURL( imageURLRef, NULL );
CFRelease( imageURLRef );
if ( !sourceRef )
return false;
imageRef = CGImageSourceCreateImageAtIndex( sourceRef, 0, NULL );
CFRelease( sourceRef );
if( !imageRef )
return false;
m_width = CGImageGetWidth( imageRef );
m_height = CGImageGetHeight( imageRef );
CGColorSpaceRef colorSpace = CGImageGetColorSpace( imageRef );
if( !colorSpace )
return false;
m_type = CGColorSpaceGetNumberOfComponents( colorSpace ) > 1 ? CV_8UC3 : CV_8UC1;
return true;
}
bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
if (NULL == imageSrc) {
return false;
}
SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL);
if (NULL == image) {
return false;
}
SkAutoTCallVProc<CGImage, CGImageRelease> arimage(image);
const int width = CGImageGetWidth(image);
const int height = CGImageGetHeight(image);
bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return true;
}
if (!this->allocPixelRef(bm, NULL)) {
return false;
}
bm->lockPixels();
bm->eraseColor(SK_ColorTRANSPARENT);
// use the same colorspace, so we don't change the pixels at all
CGColorSpaceRef cs = CGImageGetColorSpace(image);
CGContextRef cg = CGBitmapContextCreate(bm->getPixels(), width, height, 8, bm->rowBytes(), cs, BITMAP_INFO);
if (NULL == cg) {
// perhaps the image's colorspace does not work for a context, so try just rgb
cs = CGColorSpaceCreateDeviceRGB();
cg = CGBitmapContextCreate(bm->getPixels(), width, height, 8, bm->rowBytes(), cs, BITMAP_INFO);
CFRelease(cs);
}
CGContextDrawImage(cg, CGRectMake(0, 0, width, height), image);
CGContextRelease(cg);
CGImageAlphaInfo info = CGImageGetAlphaInfo(image);
switch (info) {
case kCGImageAlphaNone:
case kCGImageAlphaNoneSkipLast:
case kCGImageAlphaNoneSkipFirst:
SkASSERT(SkBitmap::ComputeIsOpaque(*bm));
bm->setIsOpaque(true);
break;
default:
// we don't know if we're opaque or not, so compute it.
bm->computeAndSetOpaquePredicate();
}
bm->unlockPixels();
return true;
}
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);
}
Image::Image(CGImageRef image) :
_width(CGImageGetWidth(image)),
_height(CGImageGetHeight(image)),
_bitsPerComponent(CGImageGetBitsPerComponent(image)),
_bytesPerRow(CGImageGetBytesPerRow(image)),
_colorSpaceRef(CGImageGetColorSpace(image)),
_bitmapInfo(CGImageGetBitmapInfo(image)),
_pixels(new pixel3f[_width * _height]),
_copy(new pixel3f[_width * _height])
{
// Obtain mutable image data.
CFDataRef data = CGDataProviderCopyData(CGImageGetDataProvider(image));
_data = CFDataCreateMutableCopy(NULL, CFDataGetLength(data), data);
// Release data from image.
CFRelease(data);
}
static RetainPtr<CGImageRef> imageWithColorSpace(CGImageRef originalImage, ColorSpace colorSpace)
{
CGColorSpaceRef originalColorSpace = CGImageGetColorSpace(originalImage);
// If the image already has a (non-device) color space, we don't want to
// override it, so return.
if (!originalColorSpace || !CFEqual(originalColorSpace, deviceRGBColorSpaceRef()))
return originalImage;
switch (colorSpace) {
case DeviceColorSpace:
return originalImage;
case sRGBColorSpace:
return RetainPtr<CGImageRef>(AdoptCF, CGImageCreateCopyWithColorSpace(originalImage, sRGBColorSpaceRef()));
}
ASSERT_NOT_REACHED();
return originalImage;
}
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;
}
bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
if (NULL == imageSrc) {
return false;
}
SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL);
if (NULL == image) {
return false;
}
SkAutoTCallVProc<CGImage, CGImageRelease> arimage(image);
const int width = CGImageGetWidth(image);
const int height = CGImageGetHeight(image);
bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return true;
}
if (!this->allocPixelRef(bm, NULL)) {
return false;
}
bm->lockPixels();
bm->eraseColor(0);
// use the same colorspace, so we don't change the pixels at all
CGColorSpaceRef cs = CGImageGetColorSpace(image);
CGContextRef cg = CGBitmapContextCreate(bm->getPixels(), width, height,
8, bm->rowBytes(), cs, BITMAP_INFO);
CGContextDrawImage(cg, CGRectMake(0, 0, width, height), image);
CGContextRelease(cg);
bm->unlockPixels();
return true;
}
cv::Mat CGImageToMat(CGImageRef image) {
CGColorSpaceRef colorSpace = CGImageGetColorSpace(image);
CGFloat cols = CGImageGetWidth(image);
CGFloat rows = CGImageGetHeight(image);
cv::Mat cvMat(rows, cols, CV_8UC4); // 8 bits per component, 4 channels (color channels + alpha)
CGContextRef contextRef = CGBitmapContextCreate(cvMat.data, // Pointer to data
cols, // Width of bitmap
rows, // Height of bitmap
8, // Bits per component
cvMat.step[0], // Bytes per row
colorSpace, // Colorspace
kCGImageAlphaNoneSkipLast |
kCGBitmapByteOrderDefault); // Bitmap info flags
CGContextDrawImage(contextRef, CGRectMake(0, 0, cols, rows), image);
CGContextRelease(contextRef);
return cvMat;
}
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);
}
vl::Image
vl::ImageReader::read(const char * fileName, float * memory)
{
// intermediate buffer
char unsigned * pixels = NULL ;
int bytesPerPixel ;
int bytesPerRow ;
// Core graphics
CGBitmapInfo bitmapInfo ;
CFURLRef url = NULL ;
CGImageSourceRef imageSourceRef = NULL ;
CGImageRef imageRef = NULL ;
CGContextRef contextRef = NULL ;
CGColorSpaceRef sourceColorSpaceRef = NULL ;
CGColorSpaceRef colorSpaceRef = NULL ;
// initialize the image as null
Image image ;
image.width = 0 ;
image.height = 0 ;
image.depth = 0 ;
image.memory = NULL ;
image.error = 0 ;
// get file
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8 *)fileName, strlen(fileName), false) ;
check(url) ;
// get image source from file
imageSourceRef = CGImageSourceCreateWithURL(url, NULL) ;
check(imageSourceRef) ;
// get image from image source
imageRef = CGImageSourceCreateImageAtIndex(imageSourceRef, 0, NULL);
check(imageRef) ;
sourceColorSpaceRef = CGImageGetColorSpace(imageRef) ;
check(sourceColorSpaceRef) ;
image.width = CGImageGetWidth(imageRef);
image.height = CGImageGetHeight(imageRef);
image.depth = CGColorSpaceGetNumberOfComponents(sourceColorSpaceRef) ;
check(image.depth == 1 || image.depth == 3) ;
// decode image to L (8 bits per pixel) or RGBA (32 bits per pixel)
switch (image.depth) {
case 1:
colorSpaceRef = CGColorSpaceCreateDeviceGray();
bytesPerPixel = 1 ;
bitmapInfo = kCGImageAlphaNone ;
break ;
case 3:
colorSpaceRef = CGColorSpaceCreateDeviceRGB();
bytesPerPixel = 4 ;
bitmapInfo = kCGImageAlphaPremultipliedLast || kCGBitmapByteOrder32Big ;
/* this means
pixels[0] = R
pixels[1] = G
pixels[2] = B
pixels[3] = A
*/
break ;
}
check(colorSpaceRef) ;
bytesPerRow = image.width * bytesPerPixel ;
pixels = (char unsigned*)malloc(image.height * bytesPerRow) ;
check(pixels) ;
contextRef = CGBitmapContextCreate(pixels,
image.width, image.height,
8, bytesPerRow,
colorSpaceRef,
bitmapInfo) ;
check(contextRef) ;
CGContextDrawImage(contextRef, CGRectMake(0, 0, image.width, image.height), imageRef);
// copy pixels to MATLAB format
if (memory == NULL) {
image.memory = (float*)malloc(image.height * image.width * image.depth * sizeof(float)) ;
check(image.memory) ;
} else {
image.memory = memory ;
}
switch (image.depth) {
case 3:
vl::impl::imageFromPixels<impl::pixelFormatRGBA>(image, pixels, image.width * bytesPerPixel) ;
break ;
case 1:
vl::impl::imageFromPixels<impl::pixelFormatL>(image, pixels, image.width * bytesPerPixel) ;
break ;
}
done:
if (pixels) { free(pixels) ; }
if (contextRef) { CFRelease(contextRef) ; }
if (colorSpaceRef) { CFRelease(colorSpaceRef) ; }
if (imageRef) { CFRelease(imageRef) ; }
if (imageSourceRef) { CFRelease(imageSourceRef) ; }
if (url) { CFRelease(url) ; }
return image ;
}
void process_1_image (args cli_flags, char *files) {
char *out_file_name = get_out_filename (files, cli_flags);
if (file_exists (out_file_name)) {
printf ("| Output file %s already exists. skipping... ", out_file_name);
return;
}
// Origional Image Properties struct
img_prop o = (img_prop) malloc (sizeof (image_properties));
// set all the vales in the imapg properties struct to -1
null_ip (o);
// Create a data provider
CGDataProviderRef source_image_provider = CGDataProviderCreateWithFilename (files);
// Check for a null returned value
if (source_image_provider == NULL) {
// something went wrong
printf ("error: Couldn't create CGDataProvider from URL.\n");
exit (0);
}
// get the information from the image exif here
o->image_rot = get_exif_rot (source_image_provider);
// Create the image in memory from the JPEG data
CGImageRef source_image = CGImageCreateWithJPEGDataProvider (source_image_provider, NULL, no, kCGRenderingIntentDefault);
/********************************************/
/* Getting the colour space **/
o->colorSpace = CGImageGetColorSpace(source_image);
/********************************************/
// populate the image info struct
pop_img_props (source_image, o);
// create a data provider from the decoded JPEG data
CGDataProviderRef image_data_provider = CGImageGetDataProvider (source_image);
// Create a pointer to the data section of the image in memory
CFDataRef source_data_ptr = CGDataProviderCopyData (image_data_provider);
// The vImage_Buffers we will use
vImage_Buffer *vImage_source = (vImage_Buffer*) malloc (sizeof (vImage_Buffer));
// Check for NULL
if (NULL == vImage_source) {
printf ("Cannot malloc vImage_source buffer\n");
exit (0);
}
if (o->bits_ppixel == 24) {
// convert from 24bit to 32bit by adding the alpha channel.
source_data_ptr = convert24_32bit (source_data_ptr, o);
}
// Setup the vImage Buffer for the image
setupBuffer (vImage_source, o->image_h, o->image_w, o->bytes_row);
// Assign the data to the vImage Buffer for the source
vImage_source->data = (void *) CFDataGetBytePtr (source_data_ptr);
// Check for NULL
if (vImage_source->data == NULL)
printf ("Unable to get the vimage.data pointer\n");
if (o->image_rot != 1 && o->image_rot != 4 && o->image_rot != 2) // rotate the image
rotate_image (vImage_source, o, NULL);
// flip the image
if (o->image_rot == 2 || o->image_rot == 4 || o->image_rot == 7 || o->image_rot == 5)
flip_image (vImage_source, o, NULL);
// Resize the images
resize_image (vImage_source, o, cli_flags);
// Create a colour space to be compared against
CGColorSpaceRef rgb = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
if (NULL == rgb) {
fprintf(stderr, "Unable to create the reference colourspace.\n");
exit(0);
}
// Convert the colourspace to RGB
if (!CFEqual(rgb, o->colorSpace) && !cli_flags->disableCC) {
vImage_source->data = convert_space(vImage_source->data, o->image_w, o->image_h);
if (NULL == vImage_source->data) exit(0);
}
// release the reference colour space
CGColorSpaceRelease(rgb);
// save the image
save_image (vImage_source, o, cli_flags->quality, out_file_name);
// Release the source provider
CGDataProviderRelease (source_image_provider);
source_image_provider = NULL;
// Release the source image
CGImageRelease (source_image);
source_image = NULL;
free(source_data_ptr);
// Free the filename created by get_out_filename ()
free (out_file_name);
out_file_name = NULL;
// free the image properties
free (o);
o = NULL;
// if there is info in the buffer
if (vImage_source->data != NULL) {
free (vImage_source->data);
vImage_source->data = NULL;
}
// free the buffer
free (vImage_source);
vImage_source = NULL;
} // Process 1 image