| // RUN: %target-run-simple-swift |
| // REQUIRES: executable_test |
| |
| // REQUIRES: rdar50244151 |
| // REQUIRES: objc_interop |
| // UNSUPPORTED: OS=watchos |
| |
| import StdlibUnittest |
| import Accelerate |
| |
| var Accelerate_vImageTests = TestSuite("Accelerate_vImage") |
| |
| if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) { |
| let width = UInt(64) |
| let height = UInt(32) |
| let widthi = 64 |
| let heighti = 32 |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // MARK: Converter |
| // |
| //===----------------------------------------------------------------------===// |
| |
| Accelerate_vImageTests.test("vImage/CVConverters") { |
| let colorSpace = CGColorSpaceCreateDeviceRGB() |
| |
| let cgFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: colorSpace, |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.first.rawValue), |
| renderingIntent: .defaultIntent)! |
| |
| let cvFormat = vImageCVImageFormat.make(format: .format32ABGR, |
| matrix: kvImage_ARGBToYpCbCrMatrix_ITU_R_601_4.pointee, |
| chromaSiting: .center, |
| colorSpace: colorSpace, |
| alphaIsOpaqueHint: false)! |
| |
| let coreVideoToCoreGraphics = try! vImageConverter.make(sourceFormat: cvFormat, |
| destinationFormat: cgFormat, |
| flags: .printDiagnosticsToConsole) |
| |
| let coreGraphicsToCoreVideo = try! vImageConverter.make(sourceFormat: cgFormat, |
| destinationFormat: cvFormat, |
| flags: .printDiagnosticsToConsole) |
| |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let sourceCGBuffer = try! vImage_Buffer(cgImage: image) |
| var intermediateCVBuffer = try! vImage_Buffer(width: widthi, height: heighti, bitsPerPixel: 32) |
| var destinationCGBuffer = try! vImage_Buffer(width: widthi, height: heighti, bitsPerPixel: 32) |
| |
| try! coreGraphicsToCoreVideo.convert(source: sourceCGBuffer, |
| destination: &intermediateCVBuffer) |
| |
| try! coreVideoToCoreGraphics.convert(source: intermediateCVBuffer, |
| destination: &destinationCGBuffer) |
| |
| let destinationPixels: [UInt8] = arrayFromBuffer(buffer: destinationCGBuffer, |
| channelCount: 4, |
| count: pixels.count) |
| |
| expectEqual(destinationPixels, pixels) |
| |
| expectEqual(coreVideoToCoreGraphics.destinationBuffers(colorSpace: colorSpace), |
| coreGraphicsToCoreVideo.sourceBuffers(colorSpace: colorSpace)) |
| |
| expectEqual(coreVideoToCoreGraphics.sourceBuffers(colorSpace: colorSpace), |
| coreGraphicsToCoreVideo.destinationBuffers(colorSpace: colorSpace)) |
| } |
| |
| /* Disabled due to <rdar://problem/50209312> |
| Accelerate_vImageTests.test("vImage/BufferOrder") { |
| let sourceFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: CGColorSpaceCreateDeviceCMYK(), |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue), |
| renderingIntent: .defaultIntent)! |
| |
| let destinationFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 24, |
| colorSpace: CGColorSpace(name: CGColorSpace.genericLab)!, |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue), |
| renderingIntent: .defaultIntent)! |
| |
| let converter = try! vImageConverter.make(sourceFormat: sourceFormat, |
| destinationFormat: destinationFormat) |
| |
| let sBuffers = converter.sourceBuffers(colorSpace: sourceFormat.colorSpace.takeRetainedValue()) |
| let dBuffers = converter.destinationBuffers(colorSpace: destinationFormat.colorSpace.takeRetainedValue()) |
| |
| expectEqual(sBuffers, [.coreGraphics]) |
| expectEqual(dBuffers, [.coreGraphics]) |
| } |
| */ |
| |
| Accelerate_vImageTests.test("vImage/AnyToAnyError") { |
| var error = kvImageNoError |
| |
| let format = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: CGColorSpaceCreateDeviceCMYK(), |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue), |
| renderingIntent: .defaultIntent)! |
| |
| expectCrashLater() |
| _ = try! vImageConverter.make(sourceFormat: format, |
| destinationFormat: format, |
| flags: .imageExtend) |
| } |
| |
| Accelerate_vImageTests.test("vImage/AnyToAny") { |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let sourceFormat = vImage_CGImageFormat(cgImage: image)! |
| |
| let destinationFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: CGColorSpaceCreateDeviceCMYK(), |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue), |
| renderingIntent: .defaultIntent)! |
| |
| let sourceBuffer = try! vImage_Buffer(cgImage: image) |
| var destinationBuffer = try! vImage_Buffer(width: widthi, height: heighti, |
| bitsPerPixel: 32) |
| |
| // New API |
| |
| let converter = try! vImageConverter.make(sourceFormat: sourceFormat, |
| destinationFormat: destinationFormat) |
| |
| try! converter.convert(source: sourceBuffer, |
| destination: &destinationBuffer) |
| |
| let mustOperateOutOfPlace = try! converter.mustOperateOutOfPlace(source: sourceBuffer, |
| destination: destinationBuffer) |
| |
| // Legacy API |
| |
| var legacyDestinationBuffer = try! vImage_Buffer(width: widthi, height: heighti, |
| bitsPerPixel: 32) |
| |
| var legacyConverter: vImageConverter? |
| |
| withUnsafePointer(to: destinationFormat) { dest in |
| withUnsafePointer(to: sourceFormat) { src in |
| legacyConverter = vImageConverter_CreateWithCGImageFormat( |
| src, |
| dest, |
| nil, |
| vImage_Flags(kvImageNoFlags), |
| nil)?.takeRetainedValue() |
| } |
| } |
| |
| _ = withUnsafePointer(to: sourceBuffer) { src in |
| vImageConvert_AnyToAny(legacyConverter!, |
| src, |
| &legacyDestinationBuffer, |
| nil, |
| vImage_Flags(kvImageNoFlags)) |
| } |
| |
| var e = kvImageNoError |
| withUnsafePointer(to: sourceBuffer) { src in |
| withUnsafePointer(to: destinationBuffer) { dest in |
| e = vImageConverter_MustOperateOutOfPlace(legacyConverter!, |
| src, |
| dest, |
| vImage_Flags(kvImageNoFlags)) |
| } |
| } |
| let legacyMustOperateOutOfPlace = e == kvImageOutOfPlaceOperationRequired |
| |
| // Compare results |
| |
| let destinationPixels: [UInt8] = arrayFromBuffer(buffer: destinationBuffer, |
| channelCount: 4, |
| count: pixels.count) |
| let legacyDestinationPixels: [UInt8] = arrayFromBuffer(buffer: legacyDestinationBuffer, |
| channelCount: 4, |
| count: pixels.count) |
| |
| expectTrue(legacyDestinationPixels.elementsEqual(destinationPixels)) |
| |
| expectEqual(converter.sourceBufferCount, 1) |
| expectEqual(converter.destinationBufferCount, 1) |
| expectEqual(legacyMustOperateOutOfPlace, mustOperateOutOfPlace) |
| |
| sourceBuffer.free() |
| destinationBuffer.free() |
| legacyDestinationBuffer.free() |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // MARK: Buffer |
| // |
| //===----------------------------------------------------------------------===// |
| |
| Accelerate_vImageTests.test("vImage/IllegalSize") { |
| expectCrashLater() |
| let buffer = try! vImage_Buffer(width: -1, height: -1, |
| bitsPerPixel: 32) |
| } |
| |
| Accelerate_vImageTests.test("vImage/IllegalSize") { |
| expectCrashLater() |
| let buffer = try! vImage_Buffer(width: 99999999, height: 99999999, |
| bitsPerPixel: 99999999) |
| } |
| |
| Accelerate_vImageTests.test("vImage/InitWithInvalidImageFormat") { |
| let pixels: [UInt8] = (0 ..< width * height).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makePlanar8Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let format = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: CGColorSpace(name: CGColorSpace.sRGB)!, |
| bitmapInfo: CGBitmapInfo(rawValue: 0))! |
| |
| var error = kvImageNoError |
| |
| expectCrashLater() |
| let buffer = try! vImage_Buffer(cgImage: image, |
| format: format) |
| } |
| |
| Accelerate_vImageTests.test("vImage/CreateCGImage") { |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let buffer = try! vImage_Buffer(cgImage: image) |
| |
| let format = vImage_CGImageFormat(cgImage: image)! |
| |
| let bufferImage = try! buffer.createCGImage(format: format) |
| |
| let imagePixels = imageToPixels(image: image) |
| let bufferImagePixels = imageToPixels(image: bufferImage) |
| |
| expectTrue(imagePixels.elementsEqual(bufferImagePixels)) |
| |
| buffer.free() |
| } |
| |
| Accelerate_vImageTests.test("vImage/CopyBadWidth") { |
| var source = try! vImage_Buffer(width: 10, height: 100, bitsPerPixel: 32) |
| var destination = try! vImage_Buffer(width: 20, height: 20, bitsPerPixel: 32) |
| |
| expectCrashLater() |
| try! source.copy(destinationBuffer: &destination, |
| pixelSize: 4) |
| } |
| |
| Accelerate_vImageTests.test("vImage/CopyBadHeight") { |
| var source = try! vImage_Buffer(width: 100, height: 10, bitsPerPixel: 32) |
| var destination = try! vImage_Buffer(width: 20, height: 20, bitsPerPixel: 32) |
| |
| expectCrashLater() |
| try! source.copy(destinationBuffer: &destination, |
| pixelSize: 4) |
| } |
| |
| Accelerate_vImageTests.test("vImage/Copy") { |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let source = try! vImage_Buffer(cgImage: image) |
| |
| var destination = try! vImage_Buffer(width: widthi, height: heighti, |
| bitsPerPixel: 32) |
| |
| try! source.copy(destinationBuffer: &destination, |
| pixelSize: 4) |
| |
| let sourcePixels: [UInt8] = arrayFromBuffer(buffer: source, |
| channelCount: 4, |
| count: pixels.count) |
| let destinationPixels: [UInt8] = arrayFromBuffer(buffer: destination, |
| channelCount: 4, |
| count: pixels.count) |
| |
| expectTrue(sourcePixels.elementsEqual(destinationPixels)) |
| |
| source.free() |
| destination.free() |
| } |
| |
| Accelerate_vImageTests.test("vImage/InitializeWithFormat") { |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| let format = vImage_CGImageFormat(cgImage: image)! |
| |
| let buffer = try! vImage_Buffer(cgImage: image, |
| format: format) |
| |
| let bufferPixels: [UInt8] = arrayFromBuffer(buffer: buffer, |
| channelCount: 4, |
| count: pixels.count) |
| |
| expectTrue(bufferPixels.elementsEqual(pixels)) |
| expectEqual(buffer.rowBytes, Int(width) * 4) |
| expectEqual(buffer.width, width) |
| expectEqual(buffer.height, height) |
| |
| buffer.free() |
| } |
| |
| Accelerate_vImageTests.test("vImage/Alignment") { |
| // New API |
| |
| var alignment = try! vImage_Buffer.preferredAlignmentAndRowBytes(width: widthi, |
| height: heighti, |
| bitsPerPixel: 32) |
| |
| // Legacy API |
| |
| var legacyBuffer = vImage_Buffer() |
| let legacyAlignment = vImageBuffer_Init(&legacyBuffer, |
| height, width, |
| 32, |
| vImage_Flags(kvImageNoAllocate)) |
| |
| expectEqual(alignment.alignment, legacyAlignment) |
| expectEqual(alignment.rowBytes, legacyBuffer.rowBytes) |
| |
| legacyBuffer.free() |
| } |
| |
| Accelerate_vImageTests.test("vImage/CreateBufferFromCGImage") { |
| let pixels: [UInt8] = (0 ..< width * height * 4).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makeRGBA8888Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| // New API |
| |
| let buffer = try! vImage_Buffer(cgImage: image) |
| |
| // Legacy API |
| |
| let legacyBuffer: vImage_Buffer = { |
| var format = vImage_CGImageFormat(cgImage: image)! |
| |
| var buffer = vImage_Buffer() |
| |
| vImageBuffer_InitWithCGImage(&buffer, |
| &format, |
| nil, |
| image, |
| vImage_Flags(kvImageNoFlags)) |
| |
| return buffer |
| }() |
| |
| let bufferPixels: [UInt8] = arrayFromBuffer(buffer: buffer, |
| channelCount: 4, |
| count: pixels.count) |
| |
| let legacyBufferPixels: [UInt8] = arrayFromBuffer(buffer: legacyBuffer, |
| channelCount: 4, |
| count: pixels.count) |
| |
| expectTrue(bufferPixels.elementsEqual(legacyBufferPixels)) |
| |
| expectEqual(buffer.width, legacyBuffer.width) |
| expectEqual(buffer.height, legacyBuffer.height) |
| expectEqual(buffer.rowBytes, legacyBuffer.rowBytes) |
| |
| expectEqual(buffer.size, CGSize(width: Int(width), |
| height: Int(height))) |
| |
| buffer.free() |
| free(legacyBuffer.data) |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // MARK: CVImageFormat |
| // |
| //===----------------------------------------------------------------------===// |
| |
| Accelerate_vImageTests.test("vImage/MakeFromPixelBuffer") { |
| let pixelBuffer = makePixelBuffer(pixelFormat: kCVPixelFormatType_420YpCbCr8Planar)! |
| |
| let format = vImageCVImageFormat.make(buffer: pixelBuffer)! |
| |
| expectEqual(format.channels, [vImage.BufferType.luminance, |
| vImage.BufferType.Cb, |
| vImage.BufferType.Cr]) |
| } |
| |
| Accelerate_vImageTests.test("vImage/MakeFormat4444YpCbCrA8") { |
| let format = vImageCVImageFormat.make(format: .format4444YpCbCrA8, |
| matrix: kvImage_ARGBToYpCbCrMatrix_ITU_R_709_2.pointee, |
| chromaSiting: .center, |
| colorSpace: CGColorSpaceCreateDeviceRGB(), |
| alphaIsOpaqueHint: false)! |
| |
| // test alphaIsOpaqueHint |
| |
| expectEqual(format.alphaIsOpaqueHint, false) |
| |
| format.alphaIsOpaqueHint = true |
| |
| expectEqual(format.alphaIsOpaqueHint, true) |
| |
| // test colorSpace |
| |
| expectEqual(String(format.colorSpace!.name!), "kCGColorSpaceDeviceRGB") |
| |
| format.colorSpace = CGColorSpace(name: CGColorSpace.extendedLinearSRGB)! |
| |
| expectEqual(String(format.colorSpace!.name!), "kCGColorSpaceExtendedLinearSRGB") |
| |
| // test channel names |
| |
| let channels = format.channels |
| |
| expectEqual(channels, |
| [vImage.BufferType.Cb, |
| vImage.BufferType.luminance, |
| vImage.BufferType.Cr, |
| vImage.BufferType.alpha]) |
| |
| let description = format.channelDescription(bufferType: channels.first!) |
| |
| expectEqual(description?.min, 0) |
| expectEqual(description?.max, 255) |
| expectEqual(description?.full, 240) |
| expectEqual(description?.zero, 128) |
| } |
| |
| Accelerate_vImageTests.test("vImage/MakeFormat420YpCbCr8Planar") { |
| let format = vImageCVImageFormat.make(format: .format420YpCbCr8Planar, |
| matrix: kvImage_ARGBToYpCbCrMatrix_ITU_R_709_2.pointee, |
| chromaSiting: .center, |
| colorSpace: CGColorSpaceCreateDeviceRGB(), |
| alphaIsOpaqueHint: false)! |
| |
| // test chromaSiting |
| |
| expectEqual(format.chromaSiting, vImageCVImageFormat.ChromaSiting.center) |
| |
| format.chromaSiting = .dv420 |
| |
| expectEqual(format.chromaSiting, vImageCVImageFormat.ChromaSiting.dv420) |
| |
| // test formatCode |
| |
| expectEqual(format.formatCode, kCVPixelFormatType_420YpCbCr8Planar) |
| |
| // test channelCount |
| |
| expectEqual(format.channelCount, 3) |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // MARK: CGImageFormat |
| // |
| //===----------------------------------------------------------------------===// |
| |
| Accelerate_vImageTests.test("vImage/CGImageFormatIllegalValues") { |
| |
| let formatOne = vImage_CGImageFormat(bitsPerComponent: -1, |
| bitsPerPixel: 32, |
| colorSpace: CGColorSpaceCreateDeviceRGB(), |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue)) |
| |
| let formatTwo = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: -1, |
| colorSpace: CGColorSpaceCreateDeviceRGB(), |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue)) |
| |
| expectTrue(formatOne == nil) |
| expectTrue(formatTwo == nil) |
| } |
| |
| Accelerate_vImageTests.test("vImage/CGImageFormatFromCGImage") { |
| let pixels: [UInt8] = (0 ..< width * height).map { _ in |
| return UInt8.random(in: 0 ..< 255) |
| } |
| |
| let image = makePlanar8Image(from: pixels, |
| width: width, |
| height: height)! |
| |
| var format = vImage_CGImageFormat(cgImage: image)! |
| |
| var legacyFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 8, |
| colorSpace: Unmanaged.passRetained(CGColorSpaceCreateDeviceGray()), |
| bitmapInfo: CGBitmapInfo(rawValue: 0), |
| version: 0, |
| decode: nil, |
| renderingIntent: .defaultIntent) |
| |
| expectTrue(vImageCGImageFormat_IsEqual(&format, &legacyFormat)) |
| } |
| |
| Accelerate_vImageTests.test("vImage/CGImageFormatLightweightInit") { |
| let colorspace = CGColorSpaceCreateDeviceRGB() |
| let renderingIntent = CGColorRenderingIntent.defaultIntent |
| let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedFirst.rawValue) |
| |
| var format = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: colorspace, |
| bitmapInfo: bitmapInfo)! |
| |
| var legacyFormat = vImage_CGImageFormat(bitsPerComponent: 8, |
| bitsPerPixel: 32, |
| colorSpace: Unmanaged.passRetained(colorspace), |
| bitmapInfo: bitmapInfo, |
| version: 0, |
| decode: nil, |
| renderingIntent: renderingIntent) |
| |
| expectTrue(vImageCGImageFormat_IsEqual(&format, &legacyFormat)) |
| expectTrue(format.componentCount == 4) |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // |
| // MARK: Helper Functions |
| // |
| //===----------------------------------------------------------------------===// |
| |
| func makePixelBuffer(pixelFormat: OSType) -> CVPixelBuffer? { |
| var pixelBuffer: CVPixelBuffer? = nil |
| CVPixelBufferCreate(kCFAllocatorDefault, |
| 1, |
| 1, |
| pixelFormat, |
| [:] as CFDictionary?, |
| &pixelBuffer) |
| |
| return pixelBuffer |
| } |
| |
| func arrayFromBuffer<T>(buffer: vImage_Buffer, |
| channelCount: Int, |
| count: Int) -> Array<T> { |
| |
| if (buffer.rowBytes == Int(buffer.width) * MemoryLayout<T>.stride * channelCount) { |
| let ptr = buffer.data.bindMemory(to: T.self, |
| capacity: count) |
| |
| let buf = UnsafeBufferPointer(start: ptr, count: count) |
| return Array(buf) |
| } else { |
| var returnArray = [T]() |
| |
| let perRowCount = Int(buffer.width) * MemoryLayout<T>.stride * channelCount |
| var ptr = buffer.data.bindMemory(to: T.self, |
| capacity: perRowCount) |
| |
| for _ in 0 ..< buffer.height { |
| let buf = UnsafeBufferPointer(start: ptr, count: perRowCount) |
| |
| returnArray.append(contentsOf: Array(buf)) |
| |
| ptr = ptr.advanced(by: buffer.rowBytes) |
| } |
| |
| return returnArray |
| } |
| } |
| |
| func imageToPixels(image: CGImage) -> [UInt8] { |
| let pixelCount = image.width * image.height |
| |
| let pixelData = image.dataProvider?.data |
| let pixels: UnsafePointer<UInt8> = CFDataGetBytePtr(pixelData) |
| let buf = UnsafeBufferPointer(start: pixels, count: pixelCount) |
| return Array(buf) |
| } |
| |
| func makePlanar8Image(from pixels: [UInt8], |
| width: UInt, |
| height: UInt) -> CGImage? { |
| |
| if |
| let outputData = CFDataCreate(nil, pixels, pixels.count), |
| let cgDataProvider = CGDataProvider(data: outputData) { |
| |
| return CGImage(width: Int(width), |
| height: Int(height), |
| bitsPerComponent: 8, |
| bitsPerPixel: 8, |
| bytesPerRow: Int(width), |
| space: CGColorSpaceCreateDeviceGray(), |
| bitmapInfo: CGBitmapInfo(rawValue: 0), |
| provider: cgDataProvider, |
| decode: nil, |
| shouldInterpolate: false, |
| intent: CGColorRenderingIntent.defaultIntent) |
| |
| } |
| return nil |
| } |
| |
| func makeRGBA8888Image(from pixels: [UInt8], |
| width: UInt, |
| height: UInt) -> CGImage? { |
| |
| if |
| let outputData = CFDataCreate(nil, pixels, pixels.count), |
| let cgDataProvider = CGDataProvider(data: outputData) { |
| |
| return CGImage(width: Int(width), |
| height: Int(height), |
| bitsPerComponent: 8, |
| bitsPerPixel: 8 * 4, |
| bytesPerRow: Int(width) * 4, |
| space: CGColorSpace(name: CGColorSpace.sRGB)!, |
| bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.last.rawValue), |
| provider: cgDataProvider, |
| decode: nil, |
| shouldInterpolate: false, |
| intent: CGColorRenderingIntent.defaultIntent) |
| |
| } |
| return nil |
| } |
| } |
| runAllTests() |
