自学教程：C++ CGDataProviderCreateWithData函数代码示例

bool MCGImageCreateCGDataProvider(MCGImageRef p_src, const MCGIntegerRectangle &p_src_rect, CGDataProviderRef &r_data_provider){	MCAssert(p_src_rect.origin.x >= 0 && p_src_rect.origin.y >= 0);	MCAssert(p_src_rect.origin.x + p_src_rect.size.width <= (uint32_t)MCGImageGetWidth(p_src));	MCAssert(p_src_rect.origin.y + p_src_rect.size.height <= (uint32_t)MCGImageGetHeight(p_src));		bool t_success = true;		MCGRaster t_raster;	if (t_success)		t_success = MCGImageGetRaster(p_src, t_raster);		CGDataProviderRef t_data_provider;	t_data_provider = nil;		if (t_success)	{		const void *t_src_ptr;		t_src_ptr = MCGRasterGetPixelPtr(t_raster, p_src_rect.origin.x, p_src_rect.origin.y);				t_data_provider = CGDataProviderCreateWithData(p_src, t_src_ptr, p_src_rect.size.height * t_raster.stride, MCGImageDataProviderReleaseDataCallback);		t_success = t_data_provider != nil;	}		if (t_success)	{		MCGImageRetain(p_src);		r_data_provider = t_data_provider;	}		return t_success;}

static CGImageRefcreate_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;}

CGImageRefgtkosx_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;}

/* 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 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;}

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;}

voidscreeninit(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);}

static CGDataProviderRef SkStreamToDataProvider(SkStream* stream) {    // TODO: use callbacks, so we don't have to load all the data into RAM    size_t len = stream->getLength();    void* data = sk_malloc_throw(len);    stream->read(data, len);    return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);}

static CGDataProviderRef SkStreamToDataProvider(SkStream* stream) {    // TODO: use callbacks, so we don't have to load all the data into RAM    SkAutoMalloc storage;    const size_t len = CopyStreamToStorage(&storage, stream);    void* data = storage.detach();    return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);}

void* CQuartz2D::CreateFont(FX_LPCBYTE pFontData, FX_DWORD dwFontSize){    CGDataProviderRef pDataProvider = CGDataProviderCreateWithData(NULL, pFontData, (size_t)dwFontSize, NULL);    if (NULL == pDataProvider) {        return NULL;    }    CGFontRef pCGFont = CGFontCreateWithDataProvider(pDataProvider);    CGDataProviderRelease(pDataProvider);    return pCGFont;}

static CGImageSourceRef data_to_CGImageSrc(SkData* data) {    CGDataProviderRef cgData = CGDataProviderCreateWithData(data, data->data(), data->size(),            nullptr);    if (!cgData) {        return nullptr;    }    CGImageSourceRef imageSrc = CGImageSourceCreateWithDataProvider(cgData, 0);    CGDataProviderRelease(cgData);    return imageSrc;}

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;}

bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output) {    size_t size = stream->getLength();    void* ptr = sk_malloc_throw(size);    stream->read(ptr, size);    CGDataProviderRef data = CGDataProviderCreateWithData(NULL, ptr, size,                                          CGDataProviderReleaseData_FromMalloc);    if (NULL == data) {        return false;    }    CGPDFDocumentRef pdf = CGPDFDocumentCreateWithProvider(data);    CGDataProviderRelease(data);    if (NULL == pdf) {        return false;    }    SkAutoPDFRelease releaseMe(pdf);    CGPDFPageRef page = CGPDFDocumentGetPage(pdf, 1);    if (NULL == page) {        return false;    }    CGRect bounds = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);    int w = (int)CGRectGetWidth(bounds);    int h = (int)CGRectGetHeight(bounds);    SkBitmap bitmap;    if (!bitmap.allocPixels(SkImageInfo::MakeN32Premul(w, h))) {        return false;    }    bitmap.eraseColor(SK_ColorWHITE);    size_t bitsPerComponent;    CGBitmapInfo info;    getBitmapInfo(bitmap, &bitsPerComponent, &info, NULL);    CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();    CGContextRef ctx = CGBitmapContextCreate(bitmap.getPixels(), w, h,                                             bitsPerComponent, bitmap.rowBytes(),                                             cs, info);    CGColorSpaceRelease(cs);    if (ctx) {        CGContextDrawPDFPage(ctx, page);        CGContextRelease(ctx);    }    output->swap(bitmap);    return true;}

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;}

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);}

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;}

/*	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;}

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 );    }

/*	createMaskFromAlphaOnlyContext creates a CGImageRef	from an alpha-only 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. */static CGImageRef createMaskFromAlphaOnlyContext(CGContextRef alphaContext){    CGImageRef mask;	unsigned char *rasterData = CGBitmapContextGetData(alphaContext);    size_t imageDataSize = CGBitmapContextGetBytesPerRow(alphaContext)*								CGBitmapContextGetHeight(alphaContext);    float invertDecode[] = { 1. , 0. };        	if(rasterData == NULL){		fprintf(stderr, "Context is not a bitmap context!/n");		return NULL;	}    // Create the data provider from the image data.    CGDataProviderRef dataProvider = CGDataProviderCreateWithData(NULL, 					    rasterData,					    imageDataSize,					    releaseBitmapContextImageData);    if(dataProvider == NULL){		// Must free the memory if the data provider couldn't be created		// since this routine now owns it.		free(rasterData);		fprintf(stderr, "Couldn't create data provider!/n");		return NULL;    }    mask = CGImageMaskCreate(CGBitmapContextGetWidth(alphaContext), 			  CGBitmapContextGetHeight(alphaContext), 			  CGBitmapContextGetBitsPerComponent(alphaContext), 			  CGBitmapContextGetBitsPerPixel(alphaContext), 			  CGBitmapContextGetBytesPerRow(alphaContext), 			  dataProvider,	// The decode is an inverted decode since a mask has the opposite	// sense than alpha, i.e. 0 in a mask paints 100% and 1 in a mask	// paints nothing.			  invertDecode,			  true);    // Release the data provider since the mask retains it.    CGDataProviderRelease(dataProvider);    if(mask == NULL){		fprintf(stderr, "Couldn't create image mask!/n");		return NULL;    }    return mask;}

/*********************************************************************** *              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;}

UncompressedImageLoadPNG(const void *data, size_t size){  CGDataProviderRef data_provider = CGDataProviderCreateWithData(      nullptr, data, size, nullptr);  if (nullptr == data_provider)    return UncompressedImage();    CGImageRef image = CGImageCreateWithPNGDataProvider(      data_provider, nullptr, false, kCGRenderingIntentDefault);    UncompressedImage result = CGImageToUncompressedImage(image);    if (nullptr != image)    CFRelease(image);  CFRelease(data_provider);    return result;}

CGDataProviderRef SkCreateDataProviderFromStream(SkStream* stream) {    // TODO: Replace with SkStream::getData() when that is added. Then we only    // have one version of CGDataProviderCreateWithData (i.e. same release proc)    const void* addr = stream->getMemoryBase();    if (addr) {        // special-case when the stream is just a block of ram        return CGDataProviderCreateWithData(stream, addr, stream->getLength(),                                            delete_stream_proc);    }    CGDataProviderSequentialCallbacks rec;    sk_bzero(&rec, sizeof(rec));    rec.version = 0;    rec.getBytes = get_bytes_proc;    rec.skipForward = skip_forward_proc;    rec.rewind = rewind_proc;    rec.releaseInfo = release_info_proc;    return CGDataProviderCreateSequential(stream, &rec);}

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;}