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

static void resolveColorSpace(const SkBitmap& bitmap, CGColorSpaceRef colorSpace){    int width = bitmap.width();    int height = bitmap.height();    CGImageRef srcImage = SkCreateCGImageRefWithColorspace(bitmap, colorSpace);    SkAutoLockPixels lock(bitmap);    void* pixels = bitmap.getPixels();    RetainPtr<CGContextRef> cgBitmap(AdoptCF, CGBitmapContextCreate(pixels, width, height, 8, width * 4, deviceRGBColorSpaceRef(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst));    if (!cgBitmap)        return;    CGContextSetBlendMode(cgBitmap.get(), kCGBlendModeCopy);    CGRect bounds = { {0, 0}, {width, height} };    CGContextDrawImage(cgBitmap.get(), bounds, srcImage);}

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;    bitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h);    bitmap.allocPixels();    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;}

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

CGContextRef SetupContext(){	//UIGraphicsBeginImageContext	int w = 480, h = 640;		//CGColorSpaceRef csICC = CGColorSpaceCreateWithIndex(15);	CGColorSpaceRef colourSpace = CGColorSpaceCreateDeviceRGB();	CGContextRef context = CGBitmapContextCreate(NULL, w, h, 8, CGBitmapGetAlignedBytesPerRow(w*4), colourSpace, kCGImageAlphaPremultipliedFirst);	CGColorSpaceRelease (colourSpace);	CGContextClear(context);	CGContextTranslateCTM(context, 0.0, 640.0);	CGContextScaleCTM(context, 1.0, -1.0);   return context;}

static CGContextRef makeCG(const SkImageInfo& info, const void* addr,                           size_t rowBytes) {    if (kPMColor_SkColorType != info.colorType() || NULL == addr) {        return NULL;    }    CGColorSpaceRef space = CGColorSpaceCreateDeviceRGB();    CGContextRef cg = CGBitmapContextCreate((void*)addr, info.width(), info.height(),                                            8, rowBytes, space, BITMAP_INFO_RGB);    CFRelease(space);    CGContextSetAllowsFontSubpixelQuantization(cg, false);    CGContextSetShouldSubpixelQuantizeFonts(cg, false);    return cg;}

bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output) {    CGDataProviderRef data = SkCreateDataProviderFromStream(stream);    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.tryAllocN32Pixels(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;}

CGImageRef CreatePDFPageImage(CGPDFPageRef page, CGFloat scale, bool transparentBackground){	CGSize pageSize = PDFPageGetSize(page, kCGPDFCropBox);		size_t width = scale * floorf(pageSize.width);	size_t height = scale * floorf(pageSize.height);	size_t bytesPerLine = width * 4;	uint64_t size = (uint64_t)height * (uint64_t)bytesPerLine;		if ((size == 0) || (size > SIZE_MAX))		return NULL;		void *bitmapData = malloc(size);	if (!bitmapData)		return NULL;	#if TARGET_OS_IPHONE	CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();#else	CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(&kCGColorSpaceSRGB ? kCGColorSpaceSRGB : kCGColorSpaceGenericRGB);#endif	CGContextRef context = CGBitmapContextCreate(bitmapData, width, height, 8, bytesPerLine, colorSpace, kCGImageAlphaPremultipliedFirst);		if (transparentBackground)	{		CGContextClearRect(context, CGRectMake(0, 0, width, height));	}	else	{		CGContextSetRGBFillColor(context, 1, 1, 1, 1); // white		CGContextFillRect(context, CGRectMake(0, 0, width, height));	}		// CGPDFPageGetDrawingTransform unfortunately does not upscale, see http://lists.apple.com/archives/quartz-dev/2005/Mar/msg00112.html	CGAffineTransform drawingTransform = PDFPageGetDrawingTransform(page, kCGPDFCropBox, scale);	CGContextConcatCTM(context, drawingTransform);		CGContextDrawPDFPage(context, page);		CGImageRef pdfImage = CGBitmapContextCreateImage(context);		CGContextRelease(context);	CGColorSpaceRelease(colorSpace);	free(bitmapData);		return pdfImage;}

PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool onscreen, bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect){    RECT frame;    if (!GetWindowRect(webViewWindow, &frame))        return nullptr;    BITMAPINFO bmp = {0};    bmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);    bmp.bmiHeader.biWidth = frame.right - frame.left;    bmp.bmiHeader.biHeight = -(frame.bottom - frame.top);    bmp.bmiHeader.biPlanes = 1;    bmp.bmiHeader.biBitCount = 32;    bmp.bmiHeader.biCompression = BI_RGB;    void* bits = 0;    HBITMAP bitmap = ::CreateDIBSection(0, &bmp, DIB_RGB_COLORS, &bits, 0, 0);    if (!bitmap)        return nullptr;    auto memoryDC = adoptGDIObject(::CreateCompatibleDC(0));    ::SelectObject(memoryDC.get(), bitmap);    SendMessage(webViewWindow, WM_PRINT, reinterpret_cast<WPARAM>(memoryDC.get()), PRF_CLIENT | PRF_CHILDREN | PRF_OWNED);    BITMAP info = {0};    GetObject(bitmap, sizeof(info), &info);    ASSERT(info.bmBitsPixel == 32);    // We create a context that has an alpha channel below so that the PNGs we generate will also    // have an alpha channel. But WM_PRINT doesn't necessarily write anything into the alpha    // channel, so we set the alpha channel to constant full opacity to make sure the resulting image is opaque.    makeAlphaChannelOpaque(info.bmBits, info.bmWidth, info.bmHeight);#if USE(CG)    RetainPtr<CGColorSpaceRef> colorSpace = adoptCF(CGColorSpaceCreateDeviceRGB());    CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8,                                                info.bmWidthBytes, colorSpace.get(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);#elif USE(CAIRO)     cairo_surface_t* image = cairo_image_surface_create_for_data((unsigned char*)info.bmBits, CAIRO_FORMAT_ARGB32,                                                       info.bmWidth, info.bmHeight, info.bmWidthBytes);     cairo_t* context = cairo_create(image);     cairo_surface_destroy(image); #endif    return BitmapContext::createByAdoptingBitmapAndContext(bitmap, context);}

static void copyImageData_color( CGImageRef imageRef, cv::Mat &image ){    size_t width = CGImageGetWidth(imageRef);    size_t height = CGImageGetHeight(imageRef);    image = cv::Mat( cv::Size( width, height ), CV_8UC3 );    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();    unsigned char *rawData = image.data;    size_t bytesPerPixel = 4;    size_t bytesPerRow = bytesPerPixel * width;    size_t bitsPerComponent = 8;    CGContextRef context = CGBitmapContextCreate(rawData, width, height,                                                 bitsPerComponent, bytesPerRow, colorSpace,                                                 kCGImageAlphaPremultipliedLast | kCGBitmapByteOrderDefault);    CGColorSpaceRelease(colorSpace);        CGContextDrawImage(context, CGRectMake(0, 0, width, height), imageRef);    CGContextRelease(context);}

draw__Bitmap draw__new_bitmap(int w, int h) {  init_if_needed();  int bytes_per_row = w * 4;  draw__Bitmap bitmap = CGBitmapContextCreate(NULL,   // data                                              w,                                              h,                                              8,      // bits per component                                              bytes_per_row,                                              generic_rgb_colorspace,                                              (CGBitmapInfo)kCGImageAlphaPremultipliedLast);  // Make (0, 0) correspond to the lower-left corner.  CGContextTranslateCTM(bitmap, 0, h);  CGContextScaleCTM(bitmap, 1.0, -1.0);  return bitmap;}

bool MCTileCacheCoreGraphicsCompositor_AllocateTile(void *p_context, int32_t p_size, const void *p_bits, uint32_t p_stride, void*& r_tile){	MCTileCacheCoreGraphicsCompositorContext *self;	self = (MCTileCacheCoreGraphicsCompositorContext *)p_context;		// If the stride is exactly one tile wide, we don't need a copy.	void *t_data;	t_data = nil;	if (p_stride == p_size * sizeof(uint32_t))		t_data = (void *)p_bits;	else if (MCMemoryAllocate(p_size * p_size * sizeof(uint32_t), t_data))	{		// Copy across each scanline of the tile into the buffer.		for(int32_t y = 0; y < p_size; y++)			memcpy((uint8_t *)t_data + y * p_size * sizeof(uint32_t), (uint8_t *)p_bits + p_stride * y, p_size * sizeof(uint32_t));	}		CGImageRef t_tile;	t_tile = nil;	if (t_data != nil)	{		// IM-2013-08-21: [[ RefactorGraphics ]] Refactor CGImage creation code to be pixel-format independent		CGBitmapInfo t_bm_info;		t_bm_info = MCGPixelFormatToCGBitmapInfo(kMCGPixelFormatNative, true);				CGContextRef t_cgcontext;		t_cgcontext = CGBitmapContextCreate((void *)t_data, p_size, p_size, 8, p_size * sizeof(uint32_t), self -> colorspace, t_bm_info);		if (t_cgcontext != nil)		{			t_tile = CGBitmapContextCreateImage(t_cgcontext);			CGContextRelease(t_cgcontext);		}	}		if (t_data != p_bits)		MCMemoryDeallocate(t_data);			if (t_tile == nil)		return false;	r_tile = t_tile;		return true;}

GDIObject<HBITMAP> allocImage(HDC dc, IntSize size, CGContextRef *targetRef){    BitmapInfo bmpInfo = BitmapInfo::create(size);    LPVOID bits;    auto hbmp = adoptGDIObject(::CreateDIBSection(dc, &bmpInfo, DIB_RGB_COLORS, &bits, 0, 0));    if (!targetRef)        return hbmp;    CGContextRef bitmapContext = CGBitmapContextCreate(bits, bmpInfo.bmiHeader.biWidth, bmpInfo.bmiHeader.biHeight, 8,                                                       bmpInfo.bmiHeader.biWidth * 4, deviceRGBColorSpaceRef(),                                                       kCGBitmapByteOrder32Little | kCGImageAlphaNoneSkipFirst);    if (!bitmapContext)        return GDIObject<HBITMAP>();    *targetRef = bitmapContext;    return hbmp;}

CGImageRef Image::createAbstraction(float stylization, uint quantization){	pixel4b *rgbPixels = (pixel4b *) CFDataGetMutableBytePtr(_data);		// Convert from RGB to Lab colorspace to perform operations on lightness channel.	RGBtoLab(rgbPixels, _pixels);		// Initial bilateral filter.	bilateral();		// Extract edges.	pixel3f *edges = createEdges(stylization);		// Additional bilateral filtering.	bilateral();	bilateral();		// Quantize lightness channel.	quantize(quantization);	 	// Overlay edges.	overlayEdges(edges);	 	// Convert back to RGB colorspace.	LabtoRGB(_pixels, rgbPixels);		// Create an image from the modified data.	CGContextRef context = CGBitmapContextCreate(		rgbPixels,		_width,		_height,		_bitsPerComponent,		_bytesPerRow,		_colorSpaceRef,		_bitmapInfo	);		CGImageRef image = CGBitmapContextCreateImage(context);		delete[] edges;		return image;}

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

void BitmapImage::checkForSolidColor(){    m_checkedForSolidColor = true;    m_isSolidColor = false;    if (frameCount() > 1)        return;    if (!haveFrameAtIndex(0)) {        IntSize size = m_source.frameSizeAtIndex(0, 0);        if (size.width() != 1 || size.height() != 1)            return;        if (!ensureFrameIsCached(0))            return;    }    CGImageRef image = nullptr;    if (m_frames.size())        image = m_frames[0].m_frame;    if (!image)        return;    // Currently we only check for solid color in the important special case of a 1x1 image.    if (CGImageGetWidth(image) == 1 && CGImageGetHeight(image) == 1) {        unsigned char pixel[4]; // RGBA        RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), deviceRGBColorSpaceRef(),            kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big));        if (!bitmapContext)            return;        GraphicsContext(bitmapContext.get()).setCompositeOperation(CompositeCopy);        CGRect destinationRect = CGRectMake(0, 0, 1, 1);        CGContextDrawImage(bitmapContext.get(), destinationRect, image);        if (!pixel[3])            m_solidColor = Color(0, 0, 0, 0);        else            m_solidColor = Color(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);        m_isSolidColor = true;    }}

/*! /internal    Returns the CoreGraphics CGContextRef of the paint device. 0 is    returned if it can't be obtained. It is the caller's responsibility to    CGContextRelease the context when finished using it.    /warning This function is only available on Mac OS X.    /warning This function is duplicated in qmacstyle_mac.mm*/CGContextRef qt_mac_cg_context(const QPaintDevice *pdev){    if (pdev->devType() == QInternal::Image) {         const QImage *i = static_cast<const  QImage*>(pdev);         QImage *image = const_cast< QImage*>(i);        CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB();        uint flags = kCGImageAlphaPremultipliedFirst;        flags |= kCGBitmapByteOrder32Host;        CGContextRef ret = 0;        ret = CGBitmapContextCreate(image->bits(), image->width(), image->height(),                                    8, image->bytesPerLine(), colorspace, flags);        CGContextTranslateCTM(ret, 0, image->height());        CGContextScaleCTM(ret, 1, -1);        return ret;    }    return 0;}

// ImageCodecDrawBand//		The base image decompressor calls your image decompressor component's ImageCodecDrawBand function// to decompress a band or frame. Your component must implement this function. If the ImageSubCodecDecompressRecord// structure specifies a progress function or data-loading function, the base image decompressor will never call ImageCodecDrawBand// at interrupt time. If the ImageSubCodecDecompressRecord structure specifies a progress function, the base image decompressor// handles codecProgressOpen and codecProgressClose calls, and your image decompressor component must not implement these functions.// If not, the base image decompressor may call the ImageCodecDrawBand function at interrupt time.// When the base image decompressor calls your ImageCodecDrawBand function, your component must perform the decompression specified// by the fields of the ImageSubCodecDecompressRecord structure. The structure includes any changes your component made to it// when performing the ImageCodecBeginBand function. If your component supports asynchronous scheduled decompression,// it may receive more than one ImageCodecBeginBand call before receiving an ImageCodecDrawBand call.pascal ComponentResult TextSubCodecDrawBand(TextSubGlobals glob, ImageSubCodecDecompressRecord *drp){	TextSubDecompressRecord *myDrp = (TextSubDecompressRecord *)drp->userDecompressRecord;	CGImageAlphaInfo alphaFormat = (myDrp->pixelFormat == k32ARGBPixelFormat) ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaPremultipliedLast;    CGContextRef c = CGBitmapContextCreate(drp->baseAddr, myDrp->width, myDrp->height,										   8, drp->rowBytes,  glob->colorSpace,										   alphaFormat);		CGContextClearRect(c, CGRectMake(0,0, myDrp->width, myDrp->height));		CFMutableStringRef buf;		if (drp->codecData[0] == '/n' && myDrp->dataSize == 1) goto leave; // skip empty packets	if (myDrp->dataSize > kMaxSubPacketSize) goto leave; // skip very large packets, they probably cause stack overflows		buf = (CFMutableStringRef)CFStringCreateWithBytesNoCopy(NULL, (UInt8*)drp->codecData, myDrp->dataSize, kCFStringEncodingUTF8, false, kCFAllocatorNull);	if (!buf) goto leave;		if (glob->translateSRT) {		CFStringRef origBuf = buf;		buf = CFStringCreateMutableCopy(NULL, 0, buf);		CFRelease(origBuf);		if (!buf) goto leave;		CFStringFindAndReplace(buf, CFSTR("<i>"),  CFSTR("{//i1}"), CFRangeMake(0,CFStringGetLength(buf)), 0);		CFStringFindAndReplace(buf, CFSTR("</i>"), CFSTR("{//i0}"), CFRangeMake(0,CFStringGetLength(buf)), 0);		CFStringFindAndReplace(buf, CFSTR("<"),    CFSTR("{"),      CFRangeMake(0,CFStringGetLength(buf)), 0);		CFStringFindAndReplace(buf, CFSTR(">"),    CFSTR("}"),      CFRangeMake(0,CFStringGetLength(buf)), 0);	}		SubRendererRenderPacket(glob->ssa, c, buf, myDrp->width, myDrp->height);		if (IsTransparentSubtitleHackEnabled())		ConvertImageToQDTransparent(drp->baseAddr, myDrp->pixelFormat, drp->rowBytes, myDrp->width, myDrp->height);			CFRelease(buf);	leave:	CGContextRelease(c);	return noErr;}

static CGContextRef createAlphaOnlyContext(size_t width, size_t height){    /*	This routine allocates data for a pixel array that contains 		width*height pixels, each pixel is 1 byte. The format is 		8 bits per pixel, where the data is the alpha value of the pixel.	*/    CGContextRef context;    size_t bytesPerRow;    unsigned char *rasterData;       // Minimum bytes per row is 1 byte per sample * number of samples.    bytesPerRow = width;    // Round to nearest multiple of BEST_BYTE_ALIGNMENT.    bytesPerRow = COMPUTE_BEST_BYTES_PER_ROW(bytesPerRow);        // Allocate the data for the raster. The total amount of data is bytesPerRow    // times the number of rows. The function 'calloc' is used so that the    // memory is initialized to 0.    rasterData = calloc(1, bytesPerRow * height);    if(rasterData == NULL){		fprintf(stderr, "Couldn't allocate the needed amount of memory!/n");		return NULL;    }         // This type of context is only available in Panther and later, otherwise    // this fails and returns a NULL context. The color space for an alpha    // only context is NULL and the BitmapInfo value is kCGImageAlphaOnly.    context = CGBitmapContextCreate(rasterData, width, height, 8, bytesPerRow, 					NULL, kCGImageAlphaOnly);    if(context == NULL){		// If the context couldn't be created then release the raster memory.		free(rasterData);		fprintf(stderr, "Couldn't create the context!/n");		return NULL;    }    // Clear the context bits so they are initially transparent.    CGContextClearRect(context, CGRectMake(0, 0, width, height));        return context;}

OSStatus GeneratePreviewForURL(void *thisInterface, QLPreviewRequestRef preview, CFURLRef url, CFStringRef contentTypeUTI, CFDictionaryRef options){	CGDataProviderRef dataProvider = CGDataProviderCreateWithURL(url);	if (!dataProvider) return -1;	CFDataRef data = CGDataProviderCopyData(dataProvider);	CGDataProviderRelease(dataProvider);	if (!data) return -1;		int width, height, channels;	unsigned char* rgbadata = SOIL_load_image_from_memory(CFDataGetBytePtr(data), CFDataGetLength(data), &width, &height, &channels, SOIL_LOAD_RGBA);	CFStringRef format=CFStringCreateWithBytes(NULL, CFDataGetBytePtr(data) + 0x54, 4, kCFStringEncodingASCII, false);    CFRelease(data);	if (!rgbadata) return -1;		CGColorSpaceRef rgb = CGColorSpaceCreateDeviceRGB();	CGContextRef context = CGBitmapContextCreate(rgbadata, width, height, 8, width * 4, rgb, kCGImageAlphaPremultipliedLast);	SOIL_free_image_data(rgbadata);	CGColorSpaceRelease(rgb);	if (!context) return -1;	CGImageRef image = CGBitmapContextCreateImage(context);	CGContextRelease(context);	if (!image) return -1;	/* Add basic metadata to title */	CFStringRef name = CFURLCopyLastPathComponent(url);	CFTypeRef keys[1] = {kQLPreviewPropertyDisplayNameKey};	CFTypeRef values[1] = {CFStringCreateWithFormat(NULL, NULL, CFSTR("%@ (%dx%d %@)"), name, width, height, format)}; 	CFDictionaryRef properties = CFDictionaryCreate(NULL, (const void**)keys, (const void**)values, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);	CFRelease(name);	context = QLPreviewRequestCreateContext(preview, CGSizeMake(width, height), true, properties);	CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);	QLPreviewRequestFlushContext(preview, context);		CGContextRelease(context);	CFRelease(format);	CFRelease(properties);		return noErr;}

int main (int argc, const char * argv[]){    if(argc >= 2) {        CGPDFDocumentRef doc = CGPDFDocumentCreateWithProvider(CGDataProviderCreateWithFilename(argv[1]));        size_t pages = CGPDFDocumentGetNumberOfPages(doc);                printf("%lu pages/n", pages);                for(size_t i = 1; i <= pages; i++) {            char filename[1024];                        snprintf(filename, 1024, "%s.%03lu.png", argv[1], i);                        printf("writing file: %s/n", filename);                     CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();            CGContextRef context = CGBitmapContextCreate(NULL, SIZE, SIZE, 8, 4 * SIZE, colorSpace, kCGImageAlphaPremultipliedLast);            CGColorSpaceRelease(colorSpace);                        CGContextDrawPDFDocument(context, CGRectMake(0, 0, SIZE, SIZE), doc, (int)i);                        CGImageRef image = CGBitmapContextCreateImage(context);                        CGImageDestinationRef dest = CGImageDestinationCreateWithURL(CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFStringCreateWithCString(kCFAllocatorDefault, filename, kCFStringEncodingASCII), kCFURLPOSIXPathStyle, false), kUTTypePNG, 1, NULL);                        CGImageDestinationAddImage(dest, image, NULL);                        CGImageDestinationFinalize(dest);                        CGImageRelease(image);            CGContextRelease(context);        }                CGPDFDocumentRelease(doc);    } else {        printf("pdf2png [filename]/n");        return 1;    }        return 0;}

void BitmapImage::checkForSolidColor(){    m_checkedForSolidColor = true;    if (frameCount() > 1) {        m_isSolidColor = false;        return;    }#if !PLATFORM(IOS)    CGImageRef image = frameAtIndex(0);#else    // Note, checkForSolidColor() may be called from frameAtIndex(). On iOS frameAtIndex() gets passed a scaleHint    // argument which it uses to tell CG to create a scaled down image. Since we don't know the scaleHint here, if    // we call frameAtIndex() again, we would pass it the default scale of 1 and would end up recreating the image.    // So we do a quick check and call frameAtIndex(0) only if we haven't yet created an image.    CGImageRef image = nullptr;    if (m_frames.size())        image = m_frames[0].m_frame;    if (!image)        image = frameAtIndex(0);#endif    // Currently we only check for solid color in the important special case of a 1x1 image.    if (image && CGImageGetWidth(image) == 1 && CGImageGetHeight(image) == 1) {        unsigned char pixel[4]; // RGBA        RetainPtr<CGContextRef> bitmapContext = adoptCF(CGBitmapContextCreate(pixel, 1, 1, 8, sizeof(pixel), deviceRGBColorSpaceRef(),                                                kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big));        if (!bitmapContext)            return;        GraphicsContext(bitmapContext.get()).setCompositeOperation(CompositeCopy);        CGRect destinationRect = CGRectMake(0, 0, 1, 1);        CGContextDrawImage(bitmapContext.get(), destinationRect, image);        if (!pixel[3])            m_solidColor = Color(0, 0, 0, 0);        else            m_solidColor = Color(pixel[0] * 255 / pixel[3], pixel[1] * 255 / pixel[3], pixel[2] * 255 / pixel[3], pixel[3]);        m_isSolidColor = true;    }}

RefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior scaleBehavior) const{    RetainPtr<CGImageRef> image;    if (m_resolutionScale == 1 || scaleBehavior == Unscaled) {        image = copyNativeImage(copyBehavior);        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(), FloatRect(FloatPoint::zero(), logicalSize()));        FloatSize imageSizeInUserSpace = scaleSizeToUserSpace(logicalSize(), m_data.backingStoreSize, internalSize());        CGContextDrawImage(context.get(), FloatRect(FloatPoint::zero(), imageSizeInUserSpace), image.get());        image = adoptCF(CGBitmapContextCreateImage(context.get()));    }    if (!image)        return nullptr;    return BitmapImage::create(image.get());}

CGImageRef CGimageResize(CGImageRef image, CGSize maxSize){    // calcualte size    CGFloat ratio = MAX(CGImageGetWidth(image)/maxSize.width,CGImageGetHeight(image)/maxSize.height);    size_t width = CGImageGetWidth(image)/ratio;    size_t height = CGImageGetHeight(image)/ratio;    // resize    CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB();    CGContextRef context = CGBitmapContextCreate(NULL, width, height,                                                 8, width*4, colorspace, kCGImageAlphaPremultipliedLast);    CGColorSpaceRelease(colorspace);        if(context == NULL) return nil;        // draw image to context (resizing it)    CGContextDrawImage(context, CGRectMake(0, 0, width, height), image);    // extract resulting image from context    CGImageRef imgRef = CGBitmapContextCreateImage(context);    CGContextRelease(context);        return imgRef;}

PassRefPtr<BitmapImage> BitmapImage::create(HBITMAP hBitmap){    DIBSECTION dibSection;    if (!GetObject(hBitmap, sizeof(DIBSECTION), &dibSection))        return 0;    ASSERT(dibSection.dsBm.bmBitsPixel == 32);    if (dibSection.dsBm.bmBitsPixel != 32)        return 0;    ASSERT(dibSection.dsBm.bmBits);    if (!dibSection.dsBm.bmBits)        return 0;    RetainPtr<CGContextRef> bitmapContext(AdoptCF, CGBitmapContextCreate(dibSection.dsBm.bmBits, dibSection.dsBm.bmWidth, dibSection.dsBm.bmHeight, 8,        dibSection.dsBm.bmWidthBytes, deviceRGBColorSpaceRef(), kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst));    // The BitmapImage takes ownership of this.    CGImageRef cgImage = CGBitmapContextCreateImage(bitmapContext.get());    return adoptRef(new BitmapImage(cgImage));}

static CGContextRef createContextWithBitmap(CFX_DIBitmap* pBitmap){    if (!pBitmap || pBitmap->IsCmykImage() || pBitmap->GetBPP() < 32) {        return NULL;    }    CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Little;    if (pBitmap->HasAlpha()) {        bitmapInfo |= kCGImageAlphaPremultipliedFirst;    } else {        bitmapInfo |= kCGImageAlphaNoneSkipFirst;    }    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();    CGContextRef context = CGBitmapContextCreate(pBitmap->GetBuffer(),                           pBitmap->GetWidth(),                           pBitmap->GetHeight(),                           8,                           pBitmap->GetPitch(),                           colorSpace,                           bitmapInfo);    CGColorSpaceRelease(colorSpace);    return context;}

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

PassRefPtr<BitmapContext> createBitmapContextFromWebView(bool onscreen, bool incrementalRepaint, bool sweepHorizontally, bool drawSelectionRect){    RECT frame;    if (!GetWindowRect(webViewWindow, &frame))        return 0;    BITMAPINFO bmp = {0};    bmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);    bmp.bmiHeader.biWidth = frame.right - frame.left;    bmp.bmiHeader.biHeight = -(frame.bottom - frame.top);    bmp.bmiHeader.biPlanes = 1;    bmp.bmiHeader.biBitCount = 32;    bmp.bmiHeader.biCompression = BI_RGB;    void* bits = 0;    HBITMAP bitmap = CreateDIBSection(0, &bmp, DIB_RGB_COLORS, &bits, 0, 0);    HDC memoryDC = CreateCompatibleDC(0);    SelectObject(memoryDC, bitmap);    SendMessage(webViewWindow, WM_PRINT, reinterpret_cast<WPARAM>(memoryDC), PRF_CLIENT | PRF_CHILDREN | PRF_OWNED);    DeleteDC(memoryDC);    BITMAP info = {0};    GetObject(bitmap, sizeof(info), &info);    ASSERT(info.bmBitsPixel == 32);#if USE(CG)    RetainPtr<CGColorSpaceRef> colorSpace(AdoptCF, CGColorSpaceCreateDeviceRGB());    CGContextRef context = CGBitmapContextCreate(info.bmBits, info.bmWidth, info.bmHeight, 8,                                                info.bmWidthBytes, colorSpace.get(), kCGBitmapByteOrder32Host | kCGImageAlphaPremultipliedFirst);#elif USE(CAIRO)     cairo_surface_t* image = cairo_image_surface_create_for_data((unsigned char*)info.bmBits, CAIRO_FORMAT_ARGB32,                                                       info.bmWidth, info.bmHeight, info.bmWidthBytes);     cairo_t* context = cairo_create(image);     cairo_surface_destroy(image); #endif    return BitmapContext::createByAdoptingBitmapAndContext(bitmap, context);}