static void quartz_format(GVJ_t *job)
{
/* image destination -> data consumer -> job's gvdevice */
/* data provider <- job's imagedata */
CGDataConsumerRef data_consumer = CGDataConsumerCreate(job, &device_data_consumer_callbacks);
CGImageDestinationRef image_destination = CGImageDestinationCreateWithDataConsumer(data_consumer, format_uti[job->device.id], 1, NULL);
CGDataProviderRef data_provider = CGDataProviderCreateDirect(job->imagedata, BYTES_PER_PIXEL * job->width * job->height, &memory_data_provider_callbacks);
/* add the bitmap image to the destination and save it */
CGColorSpaceRef color_space = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
CGImageRef image = CGImageCreate (
job->width, /* width in pixels */
job->height, /* height in pixels */
BITS_PER_COMPONENT, /* bits per component */
BYTES_PER_PIXEL * 8, /* bits per pixel */
BYTES_PER_PIXEL * job->width, /* bytes per row: exactly width # of pixels */
color_space, /* color space: sRGB */
kCGImageAlphaPremultipliedFirst, /* bitmap info: corresponds to CAIRO_FORMAT_ARGB32 */
data_provider, /* data provider: from imagedata */
NULL, /* decode: don't remap colors */
FALSE, /* don't interpolate */
kCGRenderingIntentDefault /* rendering intent (what to do with out-of-gamut colors): default */
);
CGImageDestinationAddImage(image_destination, image, NULL);
CGImageDestinationFinalize(image_destination);
/* clean up */
CGImageRelease(image);
CGColorSpaceRelease(color_space);
CGDataProviderRelease(data_provider);
if (image_destination)
CFRelease(image_destination);
CGDataConsumerRelease(data_consumer);
}
/* update imageRef */
static void icvPutImage( CvWindow* window )
{
Assert( window != 0 );
if( window->image == 0 ) return;
CGColorSpaceRef colorspace = NULL;
CGDataProviderRef provider = NULL;
int width = window->imageWidth = window->image->cols;
int height = window->imageHeight = window->image->rows;
colorspace = CGColorSpaceCreateDeviceRGB();
int size = 8;
int nbChannels = 3;
provider = CGDataProviderCreateWithData(NULL, window->image->data.ptr, width * height , NULL );
if (window->imageRef != NULL){
CGImageRelease(window->imageRef);
window->image == NULL;
}
window->imageRef = CGImageCreate( width, height, size , size*nbChannels , window->image->step, colorspace, kCGImageAlphaNone , provider, NULL, true, kCGRenderingIntentDefault );
icvDrawImage( window );
}
CGImageRef
gtkosx_create_cgimage_from_pixbuf (GdkPixbuf *pixbuf)
{
CGColorSpaceRef colorspace;
CGDataProviderRef data_provider;
CGImageRef image;
void *data;
gint rowstride;
gint pixbuf_width, pixbuf_height;
gboolean has_alpha;
pixbuf_width = gdk_pixbuf_get_width (pixbuf);
pixbuf_height = gdk_pixbuf_get_height (pixbuf);
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
data = gdk_pixbuf_get_pixels (pixbuf);
colorspace = CGColorSpaceCreateDeviceRGB ();
data_provider = CGDataProviderCreateWithData (NULL, data,
pixbuf_height * rowstride,
NULL);
image = CGImageCreate (pixbuf_width, pixbuf_height, 8,
has_alpha ? 32 : 24, rowstride,
colorspace,
has_alpha ? kCGImageAlphaLast : 0,
data_provider, NULL, FALSE,
kCGRenderingIntentDefault);
CGDataProviderRelease (data_provider);
CGColorSpaceRelease (colorspace);
return image;
}
CGImageRef qt_mac_image_to_cgimage(const QImage &image)
{
int bitsPerColor = 8;
int bitsPerPixel = 32;
if (image.depth() == 1) {
bitsPerColor = 1;
bitsPerPixel = 1;
}
QCFType<CGDataProviderRef> provider =
CGDataProviderCreateWithData(0, image.bits(), image.bytesPerLine() * image.height(),
0);
uint cgflags = kCGImageAlphaPremultipliedFirst;
#ifdef kCGBitmapByteOrder32Host //only needed because CGImage.h added symbols in the minor version
cgflags |= kCGBitmapByteOrder32Host;
#endif
CGImageRef cgImage = CGImageCreate(image.width(), image.height(), bitsPerColor, bitsPerPixel,
image.bytesPerLine(),
QCoreGraphicsPaintEngine::macGenericColorSpace(),
cgflags, provider,
0,
0,
kCGRenderingIntentDefault);
return cgImage;
}
//-----------------------------------------------------------------------------
CGImageRef CGBitmap::getCGImage ()
{
if (image == 0 && imageSource)
{
const void* keys[] = {kCGImageSourceShouldCache, kCGImageSourceShouldPreferRGB32};
const void* values[] = {kCFBooleanTrue, kCFBooleanTrue};
CFDictionaryRef options = CFDictionaryCreate (NULL, keys, values, 2, NULL, NULL);
image = CGImageSourceCreateImageAtIndex (imageSource, 0, options);
CFRelease (imageSource);
CFRelease (options);
imageSource = 0;
}
if ((dirty || image == 0) && bits)
{
freeCGImage ();
size_t rowBytes = getBytesPerRow ();
size_t byteCount = rowBytes * size.y;
size_t bitDepth = 32;
CGDataProviderRef provider = CGDataProviderCreateWithData (NULL, bits, byteCount, NULL);
CGBitmapInfo bitmapInfo = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Big;
image = CGImageCreate (size.x, size.y, 8, bitDepth, rowBytes, GetCGColorSpace (), bitmapInfo, provider, NULL, false, kCGRenderingIntentDefault);
CGDataProviderRelease (provider);
dirty = false;
}
return image;
}
static CGImageRef
create_image_from_surface (cairo_image_surface_t *image_surface, void *data)
{
CGImageRef image;
CGColorSpaceRef color_space;
CGDataProviderRef data_provider;
int width, height;
width = cairo_image_surface_get_width ((cairo_surface_t *)image_surface);
height = cairo_image_surface_get_height ((cairo_surface_t *)image_surface);
color_space = CGColorSpaceCreateDeviceRGB();
data_provider = CGDataProviderCreateWithData (NULL, data,
width * height * 4, NULL);
image = CGImageCreate (width, height,
8, 32,
width * 4,
color_space,
kCGImageAlphaPremultipliedFirst,
data_provider,
NULL,
FALSE, kCGRenderingIntentDefault);
CGColorSpaceRelease (color_space);
CGDataProviderRelease (data_provider);
return image;
}
NativeImagePtr ImageBuffer::copyNativeImage(BackingStoreCopy copyBehavior) const
{
CGImageRef image = 0;
if (!m_context->isAcceleratedContext()) {
switch (copyBehavior) {
case DontCopyBackingStore:
image = CGImageCreate(internalSize().width(), internalSize().height(), 8, 32, m_data.m_bytesPerRow.unsafeGet(), m_data.m_colorSpace, m_data.m_bitmapInfo, m_data.m_dataProvider.get(), 0, true, kCGRenderingIntentDefault);
break;
case CopyBackingStore:
image = CGBitmapContextCreateImage(context()->platformContext());
break;
default:
ASSERT_NOT_REACHED();
break;
}
}
#if USE(IOSURFACE_CANVAS_BACKING_STORE)
else {
image = wkIOSurfaceContextCreateImage(context()->platformContext());
#if defined(BUILDING_ON_LION)
m_data.m_lastFlushTime = currentTimeMS();
#endif
}
#endif
return image;
}
void
screeninit(void)
{
int fmt;
int dx, dy;
ProcessSerialNumber psn = { 0, kCurrentProcess };
TransformProcessType(&psn, kProcessTransformToForegroundApplication);
SetFrontProcess(&psn);
fmt = XBGR32; //XRGB32;
devRect = max_bounds();
dx = devRect.size.width;
dy = devRect.size.height;
gscreen = allocmemimage(Rect(0,0,dx,dy), fmt);
dataProviderRef = CGDataProviderCreateWithData(0, gscreen->data->bdata,
dx * dy * 4, 0);
fullScreenImage = CGImageCreate(dx, dy, 8, 32, dx * 4,
CGColorSpaceCreateDeviceRGB(),
kCGImageAlphaNoneSkipLast,
dataProviderRef, 0, 0, kCGRenderingIntentDefault);
devRect = CGDisplayBounds(CGMainDisplayID());
kproc("osxscreen", winproc, nil, 0);
kproc("osxflush", flushproc, nil, 0);
Sleep(&rend, isready, nil);
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
RetainPtr<CGImageRef> image;
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
RefPtr<ByteArray> arr;
if (CFEqual(uti.get(), jpegUTI())) {
// JPEGs don't have an alpha channel, so we have to manually composite on top of black.
arr = getPremultipliedImageData(IntRect(IntPoint(0, 0), internalSize()));
unsigned char *data = arr->data();
for (int i = 0; i < internalSize().width() * internalSize().height(); i++)
data[i * 4 + 3] = 255; // The image is already premultiplied, so we just need to make it opaque.
RetainPtr<CGDataProviderRef> dataProvider;
dataProvider.adoptCF(CGDataProviderCreateWithData(0, data, 4 * internalSize().width() * internalSize().height(), 0));
if (!dataProvider)
return "data:,";
image.adoptCF(CGImageCreate(internalSize().width(), internalSize().height(), 8, 32, 4 * internalSize().width(),
CGColorSpaceCreateDeviceRGB(), kCGBitmapByteOrderDefault | kCGImageAlphaLast,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
} else
image.adoptCF(copyNativeImage(CopyBackingStore));
if (!image)
return "data:,";
return CGImageToDataURL(image.get(), mimeType, quality);
}
bool MCGRasterToCGImage(const MCGRaster &p_raster, const MCGIntegerRectangle &p_src_rect, CGColorSpaceRef p_colorspace, bool p_copy, bool p_invert, CGImageRef &r_image)
{
bool t_success = true;
CGImageRef t_image = nil;
CGDataProviderRef t_data_provider = nil;
uint32_t t_dst_stride;
if (t_success)
t_success = MCGRasterCreateCGDataProvider(p_raster, p_src_rect, p_copy, p_invert, t_data_provider, t_dst_stride);
// IM-2014-05-20: [[ GraphicsPerformance ]] Opaque rasters should indicate no alpha in the bitmap info
bool t_alpha;
t_alpha = p_raster.format != kMCGRasterFormat_xRGB;
// IM-2013-08-21: [[ RefactorGraphics ]] Refactor CGImage creation code to be pixel-format independent
CGBitmapInfo t_bm_info;
t_bm_info = MCGPixelFormatToCGBitmapInfo(kMCGPixelFormatNative, t_alpha);
if (t_success)
{
t_image = CGImageCreate(p_src_rect.size.width, p_src_rect.size.height, 8, 32, t_dst_stride, p_colorspace, t_bm_info, t_data_provider, nil, true, kCGRenderingIntentDefault);
t_success = t_image != nil;
}
CGDataProviderRelease(t_data_provider);
if (t_success)
r_image = t_image;
return t_success;
}
static bool MCAlphaToCGImage(uindex_t p_width, uindex_t p_height, uint8_t* p_data, uindex_t p_stride, CGImageRef &r_image)
{
bool t_success = true;
CGImageRef t_image = nil;
CGColorSpaceRef t_colorspace = nil;
CFDataRef t_data = nil;
CGDataProviderRef t_dp = nil;
if (t_success)
t_success = nil != (t_data = CFDataCreate(kCFAllocatorDefault, (uint8_t*)p_data, p_stride * p_height));
if (t_success)
t_success = nil != (t_dp = CGDataProviderCreateWithCFData(t_data));
if (t_success)
t_success = nil != (t_colorspace = CGColorSpaceCreateDeviceGray());
if (t_success)
t_success = nil != (t_image = CGImageCreate(p_width, p_height, 8, 8, p_stride, t_colorspace, kCGImageAlphaNone, t_dp, nil, false, kCGRenderingIntentDefault));
CGColorSpaceRelease(t_colorspace);
CGDataProviderRelease(t_dp);
CFRelease(t_data);
if (t_success)
r_image = t_image;
return t_success;
}
RetainPtr<CGImageRef> UpdateChunk::createImage()
{
RetainPtr<CGDataProviderRef> provider(AdoptCF, CGDataProviderCreateWithData(0, m_data, size(), 0));
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGImageRef> image(AdoptCF, CGImageCreate(m_rect.width(), m_rect.height(), 8, 32, m_rect.width() * 4, colorSpace.get(), kCGImageAlphaPremultipliedLast, provider.get(), 0, false, kCGRenderingIntentDefault));
return image;
}
void GraphicsContext::drawWindowsBitmap(WindowsBitmap* image, const IntPoint& point)
{
// FIXME: Creating CFData is non-optimal, but needed to avoid crashing when printing. Ideally we should
// make a custom CGDataProvider that controls the WindowsBitmap lifetime. see <rdar://6394455>
RetainPtr<CFDataRef> imageData = adoptCF(CFDataCreate(kCFAllocatorDefault, image->buffer(), image->bufferLength()));
RetainPtr<CGDataProviderRef> dataProvider = adoptCF(CGDataProviderCreateWithCFData(imageData.get()));
RetainPtr<CGImageRef> cgImage = adoptCF(CGImageCreate(image->size().width(), image->size().height(), 8, 32, image->bytesPerRow(), deviceRGBColorSpaceRef(),
kCGBitmapByteOrder32Little | kCGImageAlphaFirst, dataProvider.get(), 0, true, kCGRenderingIntentDefault));
CGContextDrawImage(m_data->m_cgContext.get(), CGRectMake(point.x(), point.y(), image->size().width(), image->size().height()), cgImage.get());
}
CGImageRef CGImageCreate_wrap( float w, float h,
uint32 bitsPerComponent, uint32 bitsPerPixel,
uint32 bytesPerRow,
CGColorSpaceRef colorSpace,
uint32 bitmapInfo,
CGDataProviderRef provider,
bool shouldInterpolate,
uint32 colorRenderingIntent) {
return CGImageCreate(w, h, bitsPerComponent, bitsPerPixel, bytesPerRow, colorSpace,
bitmapInfo, provider, NULL, shouldInterpolate,
CGColorRenderingIntent(colorRenderingIntent));;
}
CGImageRef createCGImageFromGradient(int width,
int height,
pixelfmt_rgbx8888_t start,
pixelfmt_rgbx8888_t end,
int direction)
{
int bpp;
size_t bytesPerRow;
size_t bytesPerImage;
void *base;
void (*drawGradient)(uint32_t *base,
int width,
size_t bytesPerRow,
int height);
CGColorSpaceRef rgbColourSpace;
CGDataProviderRef dataProvider;
CGImageRef image;
bpp = 32;
bytesPerRow = ROWBYTES16ALIGNED(width, bpp);
bytesPerImage = bytesPerRow * height;
base = malloc(bytesPerImage);
if (base == NULL)
return NULL;
setupGradient32bpp(start, end);
drawGradient = (direction == 0) ? drawXGradient32bpp : drawYGradient32bpp;
drawGradient(base, width, bytesPerRow, height);
rgbColourSpace = CGColorSpaceCreateDeviceRGB();
dataProvider = CGDataProviderCreateWithData(NULL,
base,
bytesPerImage,
releaseDataCallback);
image = CGImageCreate(width, height,
8, bpp,
bytesPerRow,
rgbColourSpace,
kCGImageAlphaNoneSkipLast,
dataProvider,
NULL, // decode array
false, // should interpolate
kCGRenderingIntentDefault);
CGDataProviderRelease(dataProvider);
CGColorSpaceRelease(rgbColourSpace);
return image;
}
String ImageDataToDataURL(const ImageData& source, const String& mimeType, const double* quality)
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
RetainPtr<CGImageRef> image;
RetainPtr<CGDataProviderRef> dataProvider;
unsigned char* data = source.data()->data()->data();
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
Vector<uint8_t> dataVector;
if (CFEqual(uti.get(), jpegUTI())) {
// JPEGs don't have an alpha channel, so we have to manually composite on top of black.
dataVector.resize(4 * source.width() * source.height());
unsigned char *out = dataVector.data();
for (int i = 0; i < source.width() * source.height(); i++) {
// Multiply color data by alpha, and set alpha to 255.
int alpha = data[4 * i + 3];
if (alpha != 255) {
out[4 * i + 0] = data[4 * i + 0] * alpha / 255;
out[4 * i + 1] = data[4 * i + 1] * alpha / 255;
out[4 * i + 2] = data[4 * i + 2] * alpha / 255;
} else {
out[4 * i + 0] = data[4 * i + 0];
out[4 * i + 1] = data[4 * i + 1];
out[4 * i + 2] = data[4 * i + 2];
}
out[4 * i + 3] = 255;
}
data = out;
}
dataProvider.adoptCF(CGDataProviderCreateWithData(0, data,
4 * source.width() * source.height(), 0));
if (!dataProvider)
return "data:,";
image.adoptCF(CGImageCreate(source.width(), source.height(), 8, 32, 4 * source.width(),
CGColorSpaceCreateDeviceRGB(), kCGBitmapByteOrderDefault | kCGImageAlphaLast,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
if (!image)
return "data:,";
return CGImageToDataURL(image.get(), mimeType, quality);
}
CGImageRef NZCGImageCreateUsingWebPData(CFDataRef webPData)
{
uint8 *y = NULL, *u = NULL, *v = NULL;
int32_t width, height;
if (CFDataGetLength(webPData) > INT_MAX) // highly unlikely to happen; just checking anyway
return NULL;
// Step 1: Decode the data.
if (WebPDecode(CFDataGetBytePtr(webPData), (int)CFDataGetLength(webPData), &y, &u, &v, &width, &height) == webp_success)
{
const int32_t depth = 32;
const int wordsPerLine = (width*depth+31)/32;
size_t pixelBytesLength = 4*height*wordsPerLine; // Google's documentation is incorrect here; the length has to be quadrupled or we'll have an overrun
uint32 *pixelBytes = malloc(pixelBytesLength);
CFDataRef pixelData;
CGDataProviderRef dataProvider;
CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
CGImageRef theImage;
// Step 2: Convert the YUV data into RGB.
YUV420toRGBA(y, u, v, wordsPerLine, width, height, pixelBytes);
// Step 3: Convert the RGB data into a CGImageRef.
pixelData = CFDataCreateWithBytesNoCopy(NULL, (const UInt8 *)pixelBytes, pixelBytesLength, NULL);
dataProvider = CGDataProviderCreateWithCFData(pixelData);
theImage = CGImageCreate(width,
height,
8, // each component is one byte or 8 bits large
32, // our data has four components
wordsPerLine*4, // there are 32 bits or 4 bytes in a word
colorSpace,
kCGBitmapByteOrder32Host, // our data is in host-endian format
dataProvider,
NULL, // we don't care about decode arrays
true, // sure, why not interpolate?
kCGRenderingIntentDefault);
// Finally, clean up memory.
CGColorSpaceRelease(colorSpace);
CGDataProviderRelease(dataProvider);
CFRelease(pixelData);
free(y);
return theImage;
}
fprintf(stderr, "NZCGWebPFunctions: The data provided is not in WebP format.\n");
return NULL;
}
String ImageDataToDataURL(const ImageData& source, const String& mimeType, const double* quality)
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
CGImageAlphaInfo dataAlphaInfo = kCGImageAlphaLast;
unsigned char* data = source.data()->data();
Vector<uint8_t> premultipliedData;
if (CFEqual(uti.get(), jpegUTI())) {
// JPEGs don't have an alpha channel, so we have to manually composite on top of black.
size_t size = 4 * source.width() * source.height();
if (!premultipliedData.tryReserveCapacity(size))
return "data:,";
premultipliedData.resize(size);
unsigned char *buffer = premultipliedData.data();
for (size_t i = 0; i < size; i += 4) {
unsigned alpha = data[i + 3];
if (alpha != 255) {
buffer[i + 0] = data[i + 0] * alpha / 255;
buffer[i + 1] = data[i + 1] * alpha / 255;
buffer[i + 2] = data[i + 2] * alpha / 255;
} else {
buffer[i + 0] = data[i + 0];
buffer[i + 1] = data[i + 1];
buffer[i + 2] = data[i + 2];
}
}
dataAlphaInfo = kCGImageAlphaNoneSkipLast; // Ignore the alpha channel.
data = premultipliedData.data();
}
RetainPtr<CGDataProviderRef> dataProvider;
dataProvider = adoptCF(CGDataProviderCreateWithData(0, data, 4 * source.width() * source.height(), 0));
if (!dataProvider)
return "data:,";
RetainPtr<CGImageRef> image;
image = adoptCF(CGImageCreate(source.width(), source.height(), 8, 32, 4 * source.width(),
deviceRGBColorSpaceRef(), kCGBitmapByteOrderDefault | dataAlphaInfo,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
return CGImageToDataURL(image.get(), mimeType, quality);
}
CGImageRef UIMachineView::frameBuffertoCGImageRef(UIFrameBuffer *pFrameBuffer)
{
CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
Assert(cs);
/* Create the image copy of the framebuffer */
CGDataProviderRef dp = CGDataProviderCreateWithData(pFrameBuffer, pFrameBuffer->address(), pFrameBuffer->bitsPerPixel() / 8 * pFrameBuffer->width() * pFrameBuffer->height(), NULL);
Assert(dp);
CGImageRef ir = CGImageCreate(pFrameBuffer->width(), pFrameBuffer->height(), 8, 32, pFrameBuffer->bytesPerLine(), cs,
kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, dp, 0, false,
kCGRenderingIntentDefault);
Assert(ir);
CGDataProviderRelease(dp);
CGColorSpaceRelease(cs);
return ir;
}
CGImageRef ACSharedArtImageSourceCreateImageAtIndex(ACSharedArtImageSourceRef isrc, size_t index)
{
if (index >= ACSharedArtImageSourceGetEntryCount(isrc))
return NULL;
struct __ACSharedArtImageHeaderDataInfo dataInfoAtIndex = isrc->header->data_info[index];
CGDataProviderRef dataProvider = CGDataProviderCreateWithData(NULL,
(const void *) (ACSharedArtGetBytePtr(isrc->owner) + dataInfoAtIndex.relativeOffset + isrc->owner->header->dataOffset),
dataInfoAtIndex.length,
0);
CGColorSpaceRef clrSpace = CGColorSpaceCreateDeviceRGB();
CGImageRef imageRef = CGImageCreate(dataInfoAtIndex.width,dataInfoAtIndex.height,8,32,dataInfoAtIndex.width * 4,clrSpace,2,dataProvider,0,1,0);
CGColorSpaceRelease(clrSpace);
CGDataProviderRelease(dataProvider);
return imageRef;
}
void MacVegaPrinterListener::DrawBitmapClipped(const OpBitmap* bitmap, const OpRect& source, OpPoint p)
{
CGColorSpaceRef device = CGColorSpaceCreateDeviceRGB();
size_t data_size = bitmap->GetBytesPerLine()*bitmap->Height();
void* bitmap_data = malloc(data_size);
const void* source_data = const_cast<OpBitmap*>(bitmap)->GetPointer(OpBitmap::ACCESS_READONLY);
memcpy(bitmap_data, source_data, data_size);
const_cast<OpBitmap*>(bitmap)->ReleasePointer(FALSE);
CGDataProviderRef provider = CGDataProviderCreateWithData(bitmap_data, bitmap_data, data_size, DeleteBuffer);
CGImageRef image = CGImageCreate(bitmap->Width(), bitmap->Height(), 8, 32, bitmap->GetBytesPerLine(), device, kCGBitmapByteOrderVegaInternal, provider, NULL, true, kCGRenderingIntentAbsoluteColorimetric);
CGContextDrawImage(m_ctx, CGRectMake(source.x+p.x, m_winHeight-(source.y+p.y+source.height), source.width, source.height), image);
CFRelease(provider);
CFRelease(device);
CGImageRelease(image);
}
void drawGraphic( CGContextRef context, float x, float y )
{
static GWorldPtr imageGW = NULL;
static CGImageRef imageRef = NULL;
static CGDataProviderRef dataProviderRef = NULL;
Rect bounds;
static size_t width;
static size_t height;
size_t bitsPerComponent;
size_t bitsPerPixel;
size_t bytesPerRow;
PixMapHandle pmh;
// Load the image if we haven't already
if ( NULL == imageGW )
{
// Load and create the GWorld
imageGW = OpenImage();
if ( imageGW != NULL )
{
GetPortBounds( imageGW, &bounds );
width = bounds.right - bounds.left;
height = bounds.bottom - bounds.top;
pmh = GetPortPixMap( imageGW );
bitsPerComponent = (**pmh).cmpSize;
bitsPerPixel = (**pmh).pixelSize;
bytesPerRow = GetPixRowBytes( pmh );
LockPixels( pmh );
dataProviderRef = CGDataProviderCreateWithData( NULL, GetPixBaseAddr( pmh ), height * bytesPerRow, releaseData );
// Create the imageRef for that GWorld
imageRef = CGImageCreate( width, height, bitsPerComponent, bitsPerPixel, bytesPerRow, CGColorSpaceCreateDeviceRGB(), kCGImageAlphaPremultipliedFirst/*kCGImageAlphaNone*/, dataProviderRef, NULL, 0, kCGRenderingIntentDefault );
}
}
// Draw the image at 0,0
CGContextDrawImage( context, CGRectMake( x - 20, y, 40, 40 * height / width ), imageRef );
}
/* createImageFromBitmapContext creates a CGImageRef
from a bitmap context. Calling this routine
transfers 'ownership' of the raster data
in the bitmap context, to the image. If the
image can't be created, this routine frees
the memory associated with the raster.
*/
CGImageRef createImageFromBitmapContext(CGContextRef c)
{
CGImageRef image;
unsigned char *rasterData = CGBitmapContextGetData(c);
size_t imageDataSize =
CGBitmapContextGetBytesPerRow(c)*CGBitmapContextGetHeight(c);
if(rasterData == NULL){
fprintf(stderr, "Context is not a bitmap context!\n");
return NULL;
}
// Create the data provider from the image data, using
// the image releaser function releaseBitmapContextImageData.
CGDataProviderRef dataProvider = CGDataProviderCreateWithData(NULL,
rasterData,
imageDataSize,
releaseBitmapContextImageData);
if(dataProvider == NULL){
// Since this routine owns the raster memory, it must
// free it if it can't create the data provider.
free(rasterData);
fprintf(stderr, "Couldn't create data provider!\n");
return NULL;
}
// Now create the image. The parameters for the image closely match
// the parameters of the bitmap context. This code uses a NULL
// decode array and shouldInterpolate is true.
image = CGImageCreate(CGBitmapContextGetWidth(c),
CGBitmapContextGetHeight(c),
CGBitmapContextGetBitsPerComponent(c),
CGBitmapContextGetBitsPerPixel(c),
CGBitmapContextGetBytesPerRow(c),
CGBitmapContextGetColorSpace(c),
myCGContextGetBitmapInfo(c),
dataProvider,
NULL,
true,
kCGRenderingIntentDefault);
// Release the data provider since the image retains it.
CGDataProviderRelease(dataProvider);
if(image == NULL){
fprintf(stderr, "Couldn't create image!\n");
return NULL;
}
return image;
}
/***********************************************************************
* create_surface_image
*
* Caller must hold the surface lock. On input, *rect is the requested
* image rect, relative to the window whole_rect, a.k.a. visible_rect.
* On output, it's been intersected with that part backed by the surface
* and is the actual size of the returned image. copy_data indicates if
* the caller will keep the returned image beyond the point where the
* surface bits can be guaranteed to remain valid and unchanged. If so,
* the bits are copied instead of merely referenced by the image.
*
* IMPORTANT: This function is called from non-Wine threads, so it
* must not use Win32 or Wine functions, including debug
* logging.
*/
CGImageRef create_surface_image(void *window_surface, CGRect *rect, int copy_data)
{
CGImageRef cgimage = NULL;
struct macdrv_window_surface *surface = get_mac_surface(window_surface);
int width, height;
width = surface->header.rect.right - surface->header.rect.left;
height = surface->header.rect.bottom - surface->header.rect.top;
*rect = CGRectIntersection(cgrect_from_rect(surface->header.rect), *rect);
if (!CGRectIsEmpty(*rect))
{
CGRect visrect;
CGColorSpaceRef colorspace;
CGDataProviderRef provider;
int bytes_per_row, offset, size;
CGImageAlphaInfo alphaInfo;
visrect = CGRectOffset(*rect, -surface->header.rect.left, -surface->header.rect.top);
colorspace = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
bytes_per_row = get_dib_stride(width, 32);
offset = CGRectGetMinX(visrect) * 4 + (height - CGRectGetMaxY(visrect)) * bytes_per_row;
size = min(CGRectGetHeight(visrect) * bytes_per_row,
surface->info.bmiHeader.biSizeImage - offset);
if (copy_data)
{
CFDataRef data = CFDataCreate(NULL, (UInt8*)surface->bits + offset, size);
provider = CGDataProviderCreateWithCFData(data);
CFRelease(data);
}
else
provider = CGDataProviderCreateWithData(NULL, surface->bits + offset, size, NULL);
alphaInfo = surface->use_alpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
cgimage = CGImageCreate(CGRectGetWidth(visrect), CGRectGetHeight(visrect),
8, 32, bytes_per_row, colorspace,
alphaInfo | kCGBitmapByteOrder32Little,
provider, NULL, FALSE, kCGRenderingIntentDefault);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorspace);
}
return cgimage;
}
CGImageRef CGImageCreate_wrap( float w, float h,
uint32 bitsPerComponent, uint32 bitsPerPixel,
uint32 bytesPerRow,
CGColorSpaceRef colorSpace,
uint32 bitmapInfo,
CGDataProviderRef provider,
objVectorOop decodeArrayOop,
bool shouldInterpolate,
uint32 colorRenderingIntent,
void* FH) {
float* decodeArray; uint32 decodeLen;
return
convertFloatObjVector( decodeArrayOop, "CGImageCreate", FH, decodeArray, decodeLen)
? CGImageCreate(w, h, bitsPerComponent, bitsPerPixel, bytesPerRow, colorSpace,
bitmapInfo, provider, decodeArray, shouldInterpolate,
CGColorRenderingIntent(colorRenderingIntent))
: NULL;
}
String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
if (context().isAcceleratedContext())
flushContext();
RetainPtr<CFStringRef> uti = utiFromMIMEType(mimeType);
ASSERT(uti);
RefPtr<Uint8ClampedArray> premultipliedData;
RetainPtr<CGImageRef> image;
if (CFEqual(uti.get(), jpegUTI())) {
// JPEGs don't have an alpha channel, so we have to manually composite on top of black.
premultipliedData = getPremultipliedImageData(IntRect(IntPoint(0, 0), logicalSize()));
if (!premultipliedData)
return "data:,";
RetainPtr<CGDataProviderRef> dataProvider;
dataProvider = adoptCF(CGDataProviderCreateWithData(0, premultipliedData->data(), 4 * logicalSize().width() * logicalSize().height(), 0));
if (!dataProvider)
return "data:,";
image = adoptCF(CGImageCreate(logicalSize().width(), logicalSize().height(), 8, 32, 4 * logicalSize().width(),
deviceRGBColorSpaceRef(), kCGBitmapByteOrderDefault | kCGImageAlphaNoneSkipLast,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
} else if (m_resolutionScale == 1) {
image = copyNativeImage(CopyBackingStore);
image = createCroppedImageIfNecessary(image.get(), internalSize());
} else {
image = copyNativeImage(DontCopyBackingStore);
RetainPtr<CGContextRef> context = adoptCF(CGBitmapContextCreate(0, logicalSize().width(), logicalSize().height(), 8, 4 * logicalSize().width(), deviceRGBColorSpaceRef(), kCGImageAlphaPremultipliedLast));
CGContextSetBlendMode(context.get(), kCGBlendModeCopy);
CGContextClipToRect(context.get(), CGRectMake(0, 0, logicalSize().width(), logicalSize().height()));
FloatSize imageSizeInUserSpace = scaleSizeToUserSpace(logicalSize(), m_data.backingStoreSize, internalSize());
CGContextDrawImage(context.get(), CGRectMake(0, 0, imageSizeInUserSpace.width(), imageSizeInUserSpace.height()), image.get());
image = adoptCF(CGBitmapContextCreateImage(context.get()));
}
return CGImageToDataURL(image.get(), mimeType, quality);
}
/**
* Converts a QPixmap to a CGImage.
*
* @returns CGImageRef for the new image. (Remember to release it when finished with it.)
* @param aPixmap Pointer to the QPixmap instance to convert.
*/
CGImageRef darwinToCGImageRef(const QImage *pImage)
{
QImage *imageCopy = new QImage(*pImage);
/** @todo this code assumes 32-bit image input, the lazy bird convert image to 32-bit method is anything but optimal... */
if (imageCopy->format() != QImage::Format_ARGB32)
*imageCopy = imageCopy->convertToFormat(QImage::Format_ARGB32);
Assert(!imageCopy->isNull());
CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
CGDataProviderRef dp = CGDataProviderCreateWithData(imageCopy, pImage->bits(), pImage->numBytes(), darwinDataProviderReleaseQImage);
CGBitmapInfo bmpInfo = kCGImageAlphaFirst | kCGBitmapByteOrder32Host;
CGImageRef ir = CGImageCreate(imageCopy->width(), imageCopy->height(), 8, 32, imageCopy->bytesPerLine(), cs,
bmpInfo, dp, 0 /*decode */, 0 /* shouldInterpolate */,
kCGRenderingIntentDefault);
CGColorSpaceRelease(cs);
CGDataProviderRelease(dp);
Assert(ir);
return ir;
}
void GraphicsContext3D::paintToCanvas(const unsigned char* imagePixels, int imageWidth, int imageHeight, int canvasWidth, int canvasHeight, CGContextRef context)
{
if (!imagePixels || imageWidth <= 0 || imageHeight <= 0 || canvasWidth <= 0 || canvasHeight <= 0 || !context)
return;
int rowBytes = imageWidth * 4;
RetainPtr<CGDataProviderRef> dataProvider(AdoptCF, CGDataProviderCreateWithData(0, imagePixels, rowBytes * imageHeight, 0));
RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());
RetainPtr<CGImageRef> cgImage(AdoptCF, CGImageCreate(imageWidth, imageHeight, 8, 32, rowBytes, colorSpace.get(), kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
dataProvider.get(), 0, false, kCGRenderingIntentDefault));
// CSS styling may cause the canvas's content to be resized on
// the page. Go back to the Canvas to figure out the correct
// width and height to draw.
CGRect rect = CGRectMake(0, 0, canvasWidth, canvasHeight);
// We want to completely overwrite the previous frame's
// rendering results.
CGContextSaveGState(context);
CGContextSetBlendMode(context, kCGBlendModeCopy);
CGContextSetInterpolationQuality(context, kCGInterpolationNone);
CGContextDrawImage(context, rect, cgImage.get());
CGContextRestoreGState(context);
}
bool MCGImageToCGImage(MCGImageRef p_src, const MCGIntegerRectangle &p_src_rect, CGColorSpaceRef p_colorspace, bool p_invert, CGImageRef &r_image)
{
MCGRaster t_raster;
if (!MCGImageGetRaster(p_src, t_raster))
return false;
if (p_invert)
{
return MCGRasterToCGImage(t_raster, p_src_rect, p_colorspace, true, true, r_image);
}
// If we don't need to modify the data then create image with data provider that references the MCGImageRef
bool t_success = true;
CGImageRef t_image = nil;
CGDataProviderRef t_data_provider = nil;
if (t_success)
t_success = MCGImageCreateCGDataProvider(p_src, p_src_rect, t_data_provider);
bool t_alpha;
t_alpha = !MCGImageIsOpaque(p_src);
CGBitmapInfo t_bm_info;
t_bm_info = MCGPixelFormatToCGBitmapInfo(kMCGPixelFormatNative, t_alpha);
if (t_success)
{
t_image = CGImageCreate(p_src_rect.size.width, p_src_rect.size.height, 8, 32, t_raster.stride, p_colorspace, t_bm_info, t_data_provider, nil, true, kCGRenderingIntentDefault);
t_success = t_image != nil;
}
CGDataProviderRelease(t_data_provider);
if (t_success)
r_image = t_image;
return t_success;
}
void os_image_save_to_file(const char* filename, unsigned char* data, int width, int height, int channels) {
assert((channels == 3) || (channels == 4));
const int bytesPerRow = (width * channels);
const int bytesPerImage = (bytesPerRow * height);
const int bitsPerChannel = 8;
const int bitsPerPixel = (bitsPerChannel * channels);
CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB();
CFDataRef rgbData = CFDataCreate(NULL, data, bytesPerImage);
CGDataProviderRef provider = CGDataProviderCreateWithCFData(rgbData);
CGImageRef imageRef = CGImageCreate(
width,
height,
bitsPerChannel,
bitsPerPixel,
bytesPerRow,
colorspace,
kCGBitmapByteOrderDefault,
provider,
NULL,
true,
kCGRenderingIntentDefault);
CFRelease(rgbData);
CGDataProviderRelease(provider);
CGColorSpaceRelease(colorspace);
CFURLRef url = CFURLCreateFromFileSystemRepresentation(NULL, (const uint8_t*)filename, (CFIndex)strlen(filename), false);
CGImageDestinationRef destination = CGImageDestinationCreateWithURL(url, kUTTypePNG, 1, NULL);
CGImageDestinationAddImage(destination, imageRef, nil);
if (!CGImageDestinationFinalize(destination)) {
fprintf(stderr, "Failed to write image to %s\n", filename);
}
CFRelease(destination);
CFRelease(url);
CGImageRelease(imageRef);
}
