Swift 3 CGContext Memory Leak

Question

I'm using a CGBitMapContext() to convert colour spaces to ARGB and get the pixel data values, I malloc space for bit map context and free it after I'm done but am still seeing a Memory Leak in Instruments I'm thinking I'm likely doing something wrong so any help would be appreciated.

Here is the ARGBBitmapContext function

func createARGBBitmapContext(width: Int, height: Int) -> CGContext {
    var bitmapByteCount = 0
    var bitmapBytesPerRow = 0

    //Get image width, height
    let pixelsWide = width
    let pixelsHigh = height

    bitmapBytesPerRow = Int(pixelsWide) * 4
    bitmapByteCount = bitmapBytesPerRow * Int(pixelsHigh)


    let colorSpace = CGColorSpaceCreateDeviceRGB()
    // Here is the malloc call that Instruments complains of
    let bitmapData = malloc(bitmapByteCount)


    let context = CGContext(data: bitmapData, width: pixelsWide, height: pixelsHigh, bitsPerComponent: 8, bytesPerRow: bitmapBytesPerRow, space: colorSpace, bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue)

    // Do I need to free something here first?
    return context!
}

Here is where I use the context to retrieve all the pixel values as a list of UInt8s (and where the memory leaks)

extension UIImage {

    func ARGBPixelValues() -> [UInt8] {
        let width = Int(self.size.width)
        let height = Int(self.size.height)
        var pixels = [UInt8](repeatElement(0, count: width * height * 3))

        let rect = CGRect(x: 0, y: 0, width: width, height: height)
        let context = createARGBBitmapContext(inImage: self.cgImage!)
        context.clear(rect)
        context.draw(self.cgImage!, in: rect)

        var location = 0

        if let data = context.data {

            while location < (width * height) {
                let arrOffset = 3 * location
                let offset = 4 * (location)

                let R = data.load(fromByteOffset: offset + 1, as: UInt8.self)
                let G = data.load(fromByteOffset: offset + 2, as: UInt8.self)
                let B = data.load(fromByteOffset: offset + 3, as: UInt8.self)

                pixels[arrOffset]   = R
                pixels[arrOffset+1] = G
                pixels[arrOffset+2] = B

                location += 1
            }

            free(context.data) // Free the data consumed, perhaps this isn't right?
        }

        return pixels
    }
}

Instruments reports a malloc error of 1.48MiB which is right for my image size (540 x 720) I free the data but apparently that is not right.

I should mention that I know you can pass nil to CGContext init (and it will manage memory) but I'm more curious why using malloc creates an issue is there something more I should know (I'm more familiar with Obj-C).

Answer 1

Because CoreGraphics is not handled by ARC (like all other C libraries), you need to wrap your code with with an autorelease, even in Swift. Particularly if you are not on the main thread (which you should not be, if CoreGraphics is involved... .userInitiated or lower is appropriate).

func myFunc() {  
    for _ in 0 ..< makeMoneyFast {
        autoreleasepool {
            // Create CGImageRef etc...
            // Do Stuff... whir... whiz... PROFIT!
        }
    }
}

For those that care, your Objective-C should also be wrapped like:

BOOL result = NO;
NSMutableData* data = [[NSMutableData alloc] init];
@autoreleasepool {
    CGImageRef image = [self CGImageWithResolution:dpi
                                          hasAlpha:hasAlpha
                                     relativeScale:scale];

    NSAssert(image != nil, @"could not create image for TIFF export");

    if (image == nil)
        return nil;

    CGImageDestinationRef destRef = CGImageDestinationCreateWithData((CFMutableDataRef)data, kUTTypeTIFF, 1, NULL);
    CGImageDestinationAddImage(destRef, image, (CFDictionaryRef)options);
    result = CGImageDestinationFinalize(destRef);
    CFRelease(destRef);
}

if (result) {
    return [data copy];
} else {
    return nil;
}

See this answer for details.