Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-29 15:52:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
1c24730f8d
gecko-dev/gfx/2d/QuartzSupport.mm
Nathan Froyd 974d8120f2 Bug 1161627 - part 2 - machine-convert TemporaryRef<T> to already_AddRefed<T>; r=ehsan 
This conversion was done with the script:

  find . -name '*.cpp' -o -name '*.h' -o -name '*.mm' -o -name '*.idl' | \
    egrep -v 'cairo-win32-refptr.h|RefPtr.h|TestRefPtr.cpp' | \
    xargs sed -i -e 's/mozilla::TemporaryRef</already_AddRefed</g' \
                 -e 's/TemporaryRef</already_AddRefed</g'

Manual fixups were performed in the following instances:

- We handled mfbt/RefPtr.h manually so as to not convert TemporaryRef itself
  into already_AddRefed.

- The following files had explicit Move() calls added to make up for the lack
  of a copy constructor on already_AddRefed:

  dom/base/ImageEncoder.cpp
  dom/media/MediaTaskQueue.{h,cpp}
  dom/media/webaudio/PannerNode.cpp

- A redundant overload for MediaTaskQueue::Dispatch was deleted.

- A few manual fixups were required in mfbt/tests/TestRefPtr.cpp.

- Comments, using declarations, and forward declarations relating to
  TemporaryRef in dom/canvas/ and gfx/layers/ were changed to refer to
  already_AddRefed.
2015-06-17 10:00:52 -04:00

627 lines
21 KiB
Plaintext
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
// vim:set ts=2 sts=2 sw=2 et cin:
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "QuartzSupport.h"
#include "nsDebug.h"
#include "MacIOSurface.h"
#import <QuartzCore/QuartzCore.h>
#import <AppKit/NSOpenGL.h>
#include <dlfcn.h>
#include "GLDefs.h"
#define IOSURFACE_FRAMEWORK_PATH \
"/System/Library/Frameworks/IOSurface.framework/IOSurface"
#define OPENGL_FRAMEWORK_PATH \
"/System/Library/Frameworks/OpenGL.framework/OpenGL"
#define COREGRAPHICS_FRAMEWORK_PATH \
"/System/Library/Frameworks/ApplicationServices.framework/Frameworks/CoreGraphics.framework/CoreGraphics"
@interface CALayer (ContentsScale)
- (double)contentsScale;
- (void)setContentsScale:(double)scale;
@end
using mozilla::RefPtr;
CGColorSpaceRef CreateSystemColorSpace() {
CGColorSpaceRef cspace = ::CGDisplayCopyColorSpace(::CGMainDisplayID());
if (!cspace) {
cspace = ::CGColorSpaceCreateDeviceRGB();
}
return cspace;
}
nsCARenderer::~nsCARenderer() {
Destroy();
}
void cgdata_release_callback(void *aCGData, const void *data, size_t size) {
if (aCGData) {
free(aCGData);
}
}
void nsCARenderer::Destroy() {
if (mCARenderer) {
CARenderer* caRenderer = (CARenderer*)mCARenderer;
// Bug 556453:
// Explicitly remove the layer from the renderer
// otherwise it does not always happen right away.
caRenderer.layer = nullptr;
[caRenderer release];
}
if (mWrapperCALayer) {
CALayer* wrapperLayer = (CALayer*)mWrapperCALayer;
[wrapperLayer release];
}
if (mOpenGLContext) {
if (mFBO || mIOTexture || mFBOTexture) {
// Release these resources with the context that allocated them
CGLContextObj oldContext = ::CGLGetCurrentContext();
::CGLSetCurrentContext(mOpenGLContext);
if (mFBOTexture) {
::glDeleteTextures(1, &mFBOTexture);
}
if (mIOTexture) {
::glDeleteTextures(1, &mIOTexture);
}
if (mFBO) {
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
::glDeleteFramebuffersEXT(1, &mFBO);
}
if (oldContext)
::CGLSetCurrentContext(oldContext);
}
::CGLDestroyContext((CGLContextObj)mOpenGLContext);
}
if (mCGImage) {
::CGImageRelease(mCGImage);
}
// mCGData is deallocated by cgdata_release_callback
mCARenderer = nil;
mWrapperCALayer = nil;
mFBOTexture = 0;
mOpenGLContext = nullptr;
mCGImage = nullptr;
mIOSurface = nullptr;
mFBO = 0;
mIOTexture = 0;
}
nsresult nsCARenderer::SetupRenderer(void *aCALayer, int aWidth, int aHeight,
double aContentsScaleFactor,
AllowOfflineRendererEnum aAllowOfflineRenderer) {
mAllowOfflineRenderer = aAllowOfflineRenderer;
if (aWidth == 0 || aHeight == 0 || aContentsScaleFactor <= 0)
return NS_ERROR_FAILURE;
if (aWidth == mUnsupportedWidth &&
aHeight == mUnsupportedHeight) {
return NS_ERROR_FAILURE;
}
CGLPixelFormatAttribute attributes[] = {
kCGLPFAAccelerated,
kCGLPFADepthSize, (CGLPixelFormatAttribute)24,
kCGLPFAAllowOfflineRenderers,
(CGLPixelFormatAttribute)0
};
if (mAllowOfflineRenderer == DISALLOW_OFFLINE_RENDERER) {
attributes[3] = (CGLPixelFormatAttribute)0;
}
GLint screen;
CGLPixelFormatObj format;
if (::CGLChoosePixelFormat(attributes, &format, &screen) != kCGLNoError) {
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
if (::CGLCreateContext(format, nullptr, &mOpenGLContext) != kCGLNoError) {
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
::CGLDestroyPixelFormat(format);
CARenderer* caRenderer = [[CARenderer rendererWithCGLContext:mOpenGLContext
options:nil] retain];
if (caRenderer == nil) {
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
CALayer* wrapperCALayer = [[CALayer layer] retain];
if (wrapperCALayer == nil) {
[caRenderer release];
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
mCARenderer = caRenderer;
mWrapperCALayer = wrapperCALayer;
caRenderer.layer = wrapperCALayer;
[wrapperCALayer addSublayer:(CALayer*)aCALayer];
mContentsScaleFactor = aContentsScaleFactor;
size_t intScaleFactor = ceil(mContentsScaleFactor);
SetBounds(aWidth, aHeight);
// We target rendering to a CGImage if no shared IOSurface are given.
if (!mIOSurface) {
mCGData = malloc(aWidth*intScaleFactor*aHeight*4*intScaleFactor);
if (!mCGData) {
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
memset(mCGData, 0, aWidth*intScaleFactor*aHeight*4*intScaleFactor);
CGDataProviderRef dataProvider = nullptr;
dataProvider = ::CGDataProviderCreateWithData(mCGData,
mCGData, aHeight*intScaleFactor*aWidth*4*intScaleFactor,
cgdata_release_callback);
if (!dataProvider) {
cgdata_release_callback(mCGData, mCGData,
aHeight*intScaleFactor*aWidth*4*intScaleFactor);
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
CGColorSpaceRef colorSpace = CreateSystemColorSpace();
mCGImage = ::CGImageCreate(aWidth * intScaleFactor, aHeight * intScaleFactor,
8, 32, aWidth * intScaleFactor * 4, colorSpace,
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
dataProvider, nullptr, true, kCGRenderingIntentDefault);
::CGDataProviderRelease(dataProvider);
::CGColorSpaceRelease(colorSpace);
if (!mCGImage) {
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
}
CGLContextObj oldContext = ::CGLGetCurrentContext();
::CGLSetCurrentContext(mOpenGLContext);
if (mIOSurface) {
// Create the IOSurface mapped texture.
::glGenTextures(1, &mIOTexture);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mIOTexture);
::glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
::glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
MacIOSurfaceLib::CGLTexImageIOSurface2D(mOpenGLContext, GL_TEXTURE_RECTANGLE_ARB,
GL_RGBA, aWidth * intScaleFactor,
aHeight * intScaleFactor,
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
mIOSurface->mIOSurfacePtr, 0);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
} else {
::glGenTextures(1, &mFBOTexture);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mFBOTexture);
::glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
::glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
}
// Create the fbo
::glGenFramebuffersEXT(1, &mFBO);
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
if (mIOSurface) {
::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, mIOTexture, 0);
} else {
::glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_RECTANGLE_ARB, mFBOTexture, 0);
}
// Make sure that the Framebuffer configuration is supported on the client machine
GLenum fboStatus;
fboStatus = ::glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (fboStatus != GL_FRAMEBUFFER_COMPLETE_EXT) {
NS_ERROR("FBO not supported");
if (oldContext)
::CGLSetCurrentContext(oldContext);
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
return NS_ERROR_FAILURE;
}
SetViewport(aWidth, aHeight);
GLenum result = ::glGetError();
if (result != GL_NO_ERROR) {
NS_ERROR("Unexpected OpenGL Error");
mUnsupportedWidth = aWidth;
mUnsupportedHeight = aHeight;
Destroy();
if (oldContext)
::CGLSetCurrentContext(oldContext);
return NS_ERROR_FAILURE;
}
if (oldContext)
::CGLSetCurrentContext(oldContext);
return NS_OK;
}
void nsCARenderer::SetBounds(int aWidth, int aHeight) {
CARenderer* caRenderer = (CARenderer*)mCARenderer;
CALayer* wrapperLayer = (CALayer*)mWrapperCALayer;
NSArray* sublayers = [wrapperLayer sublayers];
CALayer* pluginLayer = (CALayer*) [sublayers objectAtIndex:0];
// Create a transaction and disable animations
// to make the position update instant.
[CATransaction begin];
NSMutableDictionary *newActions =
[[NSMutableDictionary alloc] initWithObjectsAndKeys:
[NSNull null], @"onOrderIn",
[NSNull null], @"onOrderOut",
[NSNull null], @"sublayers",
[NSNull null], @"contents",
[NSNull null], @"position",
[NSNull null], @"bounds",
nil];
wrapperLayer.actions = newActions;
[newActions release];
// If we're in HiDPI mode, mContentsScaleFactor will (presumably) be 2.0.
// For some reason, to make things work properly in HiDPI mode we need to
// make caRenderer's 'bounds' and 'layer' different sizes -- to set 'bounds'
// to the size of 'layer's backing store. And to avoid this possibly
// confusing the plugin, we need to hide it's effects from the plugin by
// making pluginLayer (usually the CALayer* provided by the plugin) a
// sublayer of our own wrapperLayer (see bug 829284).
size_t intScaleFactor = ceil(mContentsScaleFactor);
[CATransaction setValue: [NSNumber numberWithFloat:0.0f] forKey: kCATransactionAnimationDuration];
[CATransaction setValue: (id) kCFBooleanTrue forKey: kCATransactionDisableActions];
[wrapperLayer setBounds:CGRectMake(0, 0, aWidth, aHeight)];
[wrapperLayer setPosition:CGPointMake(aWidth/2.0, aHeight/2.0)];
[pluginLayer setBounds:CGRectMake(0, 0, aWidth, aHeight)];
[pluginLayer setFrame:CGRectMake(0, 0, aWidth, aHeight)];
caRenderer.bounds = CGRectMake(0, 0, aWidth * intScaleFactor, aHeight * intScaleFactor);
if (mContentsScaleFactor != 1.0) {
CGAffineTransform affineTransform = [wrapperLayer affineTransform];
affineTransform.a = mContentsScaleFactor;
affineTransform.d = mContentsScaleFactor;
affineTransform.tx = ((double)aWidth)/mContentsScaleFactor;
affineTransform.ty = ((double)aHeight)/mContentsScaleFactor;
[wrapperLayer setAffineTransform:affineTransform];
} else {
// These settings are the default values. But they might have been
// changed as above if we were previously running in a HiDPI mode
// (i.e. if we just switched from that to a non-HiDPI mode).
[wrapperLayer setAffineTransform:CGAffineTransformIdentity];
}
[CATransaction commit];
}
void nsCARenderer::SetViewport(int aWidth, int aHeight) {
size_t intScaleFactor = ceil(mContentsScaleFactor);
aWidth *= intScaleFactor;
aHeight *= intScaleFactor;
::glViewport(0.0, 0.0, aWidth, aHeight);
::glMatrixMode(GL_PROJECTION);
::glLoadIdentity();
::glOrtho (0.0, aWidth, 0.0, aHeight, -1, 1);
// Render upside down to speed up CGContextDrawImage
::glTranslatef(0.0f, aHeight, 0.0);
::glScalef(1.0, -1.0, 1.0);
}
void nsCARenderer::AttachIOSurface(MacIOSurface *aSurface) {
if (mIOSurface &&
aSurface->GetIOSurfaceID() == mIOSurface->GetIOSurfaceID()) {
return;
}
mIOSurface = aSurface;
// Update the framebuffer and viewport
if (mCARenderer) {
CARenderer* caRenderer = (CARenderer*)mCARenderer;
size_t intScaleFactor = ceil(mContentsScaleFactor);
int width = caRenderer.bounds.size.width / intScaleFactor;
int height = caRenderer.bounds.size.height / intScaleFactor;
CGLContextObj oldContext = ::CGLGetCurrentContext();
::CGLSetCurrentContext(mOpenGLContext);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mIOTexture);
MacIOSurfaceLib::CGLTexImageIOSurface2D(mOpenGLContext, GL_TEXTURE_RECTANGLE_ARB,
GL_RGBA, mIOSurface->GetDevicePixelWidth(),
mIOSurface->GetDevicePixelHeight(),
GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
mIOSurface->mIOSurfacePtr, 0);
::glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
// Rebind the FBO to make it live
::glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
if (static_cast<int>(mIOSurface->GetWidth()) != width ||
static_cast<int>(mIOSurface->GetHeight()) != height) {
width = mIOSurface->GetWidth();
height = mIOSurface->GetHeight();
SetBounds(width, height);
SetViewport(width, height);
}
if (oldContext) {
::CGLSetCurrentContext(oldContext);
}
}
}
IOSurfaceID nsCARenderer::GetIOSurfaceID() {
if (!mIOSurface) {
return 0;
}
return mIOSurface->GetIOSurfaceID();
}
nsresult nsCARenderer::Render(int aWidth, int aHeight,
double aContentsScaleFactor,
CGImageRef *aOutCGImage) {
if (!aOutCGImage && !mIOSurface) {
NS_ERROR("No target destination for rendering");
} else if (aOutCGImage) {
// We are expected to return a CGImageRef, we will set
// it to nullptr in case we fail before the image is ready.
*aOutCGImage = nullptr;
}
if (aWidth == 0 || aHeight == 0 || aContentsScaleFactor <= 0)
return NS_OK;
if (!mCARenderer || !mWrapperCALayer) {
return NS_ERROR_FAILURE;
}
CARenderer* caRenderer = (CARenderer*)mCARenderer;
CALayer* wrapperLayer = (CALayer*)mWrapperCALayer;
size_t intScaleFactor = ceil(aContentsScaleFactor);
int renderer_width = caRenderer.bounds.size.width / intScaleFactor;
int renderer_height = caRenderer.bounds.size.height / intScaleFactor;
if (renderer_width != aWidth || renderer_height != aHeight ||
mContentsScaleFactor != aContentsScaleFactor) {
// XXX: This should be optimized to not rescale the buffer
// if we are resizing down.
// caLayer may be the CALayer* provided by the plugin, so we need to
// preserve it across the call to Destroy().
NSArray* sublayers = [wrapperLayer sublayers];
CALayer* caLayer = (CALayer*) [sublayers objectAtIndex:0];
// mIOSurface is set by AttachIOSurface(), not by SetupRenderer(). So
// since it may have been set by a prior call to AttachIOSurface(), we
// need to preserve it across the call to Destroy().
mozilla::RefPtr<MacIOSurface> ioSurface = mIOSurface;
Destroy();
mIOSurface = ioSurface;
if (SetupRenderer(caLayer, aWidth, aHeight, aContentsScaleFactor,
mAllowOfflineRenderer) != NS_OK) {
return NS_ERROR_FAILURE;
}
caRenderer = (CARenderer*)mCARenderer;
}
CGLContextObj oldContext = ::CGLGetCurrentContext();
::CGLSetCurrentContext(mOpenGLContext);
if (!mIOSurface) {
// If no shared IOSurface is given render to our own
// texture for readback.
::glGenTextures(1, &mFBOTexture);
}
GLenum result = ::glGetError();
if (result != GL_NO_ERROR) {
NS_ERROR("Unexpected OpenGL Error");
Destroy();
if (oldContext)
::CGLSetCurrentContext(oldContext);
return NS_ERROR_FAILURE;
}
::glClearColor(0.0, 0.0, 0.0, 0.0);
::glClear(GL_COLOR_BUFFER_BIT);
[CATransaction commit];
double caTime = ::CACurrentMediaTime();
[caRenderer beginFrameAtTime:caTime timeStamp:nullptr];
[caRenderer addUpdateRect:CGRectMake(0,0, aWidth * intScaleFactor,
aHeight * intScaleFactor)];
[caRenderer render];
[caRenderer endFrame];
// Read the data back either to the IOSurface or mCGImage.
if (mIOSurface) {
::glFlush();
} else {
::glPixelStorei(GL_PACK_ALIGNMENT, 4);
::glPixelStorei(GL_PACK_ROW_LENGTH, 0);
::glPixelStorei(GL_PACK_SKIP_ROWS, 0);
::glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
::glReadPixels(0.0f, 0.0f, aWidth * intScaleFactor,
aHeight * intScaleFactor,
GL_BGRA, GL_UNSIGNED_BYTE,
mCGData);
*aOutCGImage = mCGImage;
}
if (oldContext) {
::CGLSetCurrentContext(oldContext);
}
return NS_OK;
}
nsresult nsCARenderer::DrawSurfaceToCGContext(CGContextRef aContext,
MacIOSurface *surf,
CGColorSpaceRef aColorSpace,
int aX, int aY,
size_t aWidth, size_t aHeight) {
surf->Lock();
size_t bytesPerRow = surf->GetBytesPerRow();
size_t ioWidth = surf->GetWidth();
size_t ioHeight = surf->GetHeight();
// We get rendering glitches if we use a width/height that falls
// outside of the IOSurface.
if (aWidth + aX > ioWidth)
aWidth = ioWidth - aX;
if (aHeight + aY > ioHeight)
aHeight = ioHeight - aY;
if (aX < 0 || static_cast<size_t>(aX) >= ioWidth ||
aY < 0 || static_cast<size_t>(aY) >= ioHeight) {
surf->Unlock();
return NS_ERROR_FAILURE;
}
void* ioData = surf->GetBaseAddress();
double scaleFactor = surf->GetContentsScaleFactor();
size_t intScaleFactor = ceil(surf->GetContentsScaleFactor());
CGDataProviderRef dataProvider = ::CGDataProviderCreateWithData(ioData,
ioData, ioHeight*intScaleFactor*(bytesPerRow)*4,
nullptr); //No release callback
if (!dataProvider) {
surf->Unlock();
return NS_ERROR_FAILURE;
}
CGImageRef cgImage = ::CGImageCreate(ioWidth * intScaleFactor,
ioHeight * intScaleFactor, 8, 32, bytesPerRow, aColorSpace,
kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
dataProvider, nullptr, true, kCGRenderingIntentDefault);
::CGDataProviderRelease(dataProvider);
if (!cgImage) {
surf->Unlock();
return NS_ERROR_FAILURE;
}
CGImageRef subImage = ::CGImageCreateWithImageInRect(cgImage,
::CGRectMake(aX * scaleFactor,
aY * scaleFactor,
aWidth * scaleFactor,
aHeight * scaleFactor));
if (!subImage) {
::CGImageRelease(cgImage);
surf->Unlock();
return NS_ERROR_FAILURE;
}
::CGContextScaleCTM(aContext, 1.0f, -1.0f);
::CGContextDrawImage(aContext,
CGRectMake(aX * scaleFactor,
(-(CGFloat)aY - (CGFloat)aHeight) * scaleFactor,
aWidth * scaleFactor,
aHeight * scaleFactor),
subImage);
::CGImageRelease(subImage);
::CGImageRelease(cgImage);
surf->Unlock();
return NS_OK;
}
void nsCARenderer::DetachCALayer() {
CALayer* wrapperLayer = (CALayer*)mWrapperCALayer;
NSArray* sublayers = [wrapperLayer sublayers];
CALayer* oldLayer = (CALayer*) [sublayers objectAtIndex:0];
[oldLayer removeFromSuperlayer];
}
void nsCARenderer::AttachCALayer(void *aCALayer) {
CALayer* wrapperLayer = (CALayer*)mWrapperCALayer;
NSArray* sublayers = [wrapperLayer sublayers];
CALayer* oldLayer = (CALayer*) [sublayers objectAtIndex:0];
[oldLayer removeFromSuperlayer];
[wrapperLayer addSublayer:(CALayer*)aCALayer];
}
#ifdef DEBUG
int sSaveToDiskSequence = 0;
void nsCARenderer::SaveToDisk(MacIOSurface *surf) {
surf->Lock();
size_t bytesPerRow = surf->GetBytesPerRow();
size_t ioWidth = surf->GetWidth();
size_t ioHeight = surf->GetHeight();
void* ioData = surf->GetBaseAddress();
CGDataProviderRef dataProvider = ::CGDataProviderCreateWithData(ioData,
ioData, ioHeight*(bytesPerRow)*4,
nullptr); //No release callback
if (!dataProvider) {
surf->Unlock();
return;
}
CGColorSpaceRef colorSpace = CreateSystemColorSpace();
CGImageRef cgImage = ::CGImageCreate(ioWidth, ioHeight, 8, 32, bytesPerRow,
colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
dataProvider, nullptr, true, kCGRenderingIntentDefault);
::CGDataProviderRelease(dataProvider);
::CGColorSpaceRelease(colorSpace);
if (!cgImage) {
surf->Unlock();
return;
}
char cstr[1000];
sprintf(cstr, "file:///Users/benoitgirard/debug/iosurface_%i.png", ++sSaveToDiskSequence);
CFStringRef cfStr = ::CFStringCreateWithCString(kCFAllocatorDefault, cstr, kCFStringEncodingMacRoman);
printf("Exporting: %s\n", cstr);
CFURLRef url = ::CFURLCreateWithString( nullptr, cfStr, nullptr);
::CFRelease(cfStr);
CFStringRef type = kUTTypePNG;
size_t count = 1;
CFDictionaryRef options = nullptr;
CGImageDestinationRef dest = ::CGImageDestinationCreateWithURL(url, type, count, options);
::CFRelease(url);
::CGImageDestinationAddImage(dest, cgImage, nullptr);
::CGImageDestinationFinalize(dest);
::CFRelease(dest);
::CGImageRelease(cgImage);
surf->Unlock();
return;
}
#endif
Reference in New Issue View Git Blame Copy Permalink