EXC_BAD_INSTRUCTION快速抖动功能

Question

I've been trying to create a dithering function in Swift but I keep running into issues. I've noticed the code loops just fine for the first 9000 or so pixels of a random image I selected. But then it gives me a runtime error, I've looked everywhere and I can't seem to solve the issue. Please help.

file:///Users/jeffn/Desktop/MyPlayground34.playground/: error: Playground execution aborted: error: Execution was interrupted, reason: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0). The process has been left at the point where it was interrupted, use "thread return -x" to return to the state before expression evaluation.

   import UIKit





 struct Pixel {
var value: UInt32
var red: UInt8 {
    get { return UInt8(value & 0xFF) }
    set { value = UInt32(newValue) | (value & 0xFFFFFF00) }
}
var green: UInt8 {
    get { return UInt8((value >> 8) & 0xFF) }
    set { value = (UInt32(newValue) << 8) | (value & 0xFFFF00FF) }
}
var blue: UInt8 {
    get { return UInt8((value >> 16) & 0xFF) }
    set { value = (UInt32(newValue) << 16) | (value & 0xFF00FFFF) }
}
var alpha: UInt8 {
    get { return UInt8((value >> 24) & 0xFF) }
    set { value = (UInt32(newValue) << 24) | (value & 0x00FFFFFF) }
}}

 public struct RGBA {
var pixels: UnsafeMutableBufferPointer<Pixel>
var width: Int
var height: Int

init?(image: UIImage) {
    guard let cgImage = image.cgImage else { return nil }
    width = Int(image.size.width)
    height = Int(image.size.height)
    let bitsPerComponent = 8
    let bytesPerPixel = 4
    let bytesPerRow = width * bytesPerPixel
    let imageData = UnsafeMutablePointer<Pixel>.allocate(capacity: width * height)
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    var bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Big.rawValue
    bitmapInfo |= CGImageAlphaInfo.premultipliedLast.rawValue & CGBitmapInfo.alphaInfoMask.rawValue
    guard let imageContext = CGContext(data: imageData, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo) else { return nil }
    imageContext.draw(cgImage, in: CGRect(origin: CGPoint(x: 0,y :0), size: image.size))
    pixels = UnsafeMutableBufferPointer<Pixel>(start: imageData, count: width * height)
}

public func toUIImage() -> UIImage? {
    let bitsPerComponent = 8
    let bytesPerPixel = 4
    let bytesPerRow = width * bytesPerPixel
    let colorSpace = CGColorSpaceCreateDeviceRGB()
    var bitmapInfo: UInt32 = CGBitmapInfo.byteOrder32Big.rawValue
    bitmapInfo |= CGImageAlphaInfo.premultipliedLast.rawValue & CGBitmapInfo.alphaInfoMask.rawValue
    let imageContext = CGContext(data: pixels.baseAddress, width: width, height: height, bitsPerComponent: bitsPerComponent, bytesPerRow: bytesPerRow, space: colorSpace, bitmapInfo: bitmapInfo, releaseCallback: nil, releaseInfo: nil)
    guard let cgImage = imageContext!.makeImage() else {return nil}
    let image = UIImage(cgImage: cgImage)
    return image
}
}

public func contrast(image: UIImage) -> RGBA {
let rgba = RGBA(image: image)!

var new_red: UInt8 = 0
var new_green = 0
var new_blue = 0
var new_alpha = 0

var error_red: UInt8 = 0
var error_green = 0
var error_blue = 0
var error_alpha = 0

var pixel_1_red: UInt8 = 0

var output_red: UInt8 = 0

let w1: Double = 7.00/16.00
let w2: Double = 3.00/16.00
let w3: Double = 5.00/16.00
let w4: Double = 1.00/16.00


for y in 0..<rgba.height-1{
    for x in 0..<rgba.width-1{
        var index = y * rgba.width + x
        var index_1 = y*rgba.width + x + 1

        var pixel = rgba.pixels[index]
        var pixel_1 = rgba.pixels[index_1]
        pixel_1_red = pixel_1.red



        if(pixel.red < 128){new_red = 0} else {new_red = 255}
        error_red = new_red - pixel.red


        var double_error_red = Double(error_red)*w1
        var int_error_red = UInt8(double_error_red)

        output_red = pixel_1_red + int_error_red


        pixel_1.red = output_red
        rgba.pixels[index_1] = pixel_1


    }
}

return rgba
}




 let image = UIImage(named: "newlowpassfilter.jpg")!
 let rgba = contrast(image: image)
 let newImage = rgba.toUIImage()
 image

 newImage

Answer 1

Maybe integer overflow is your issue.

With testing with one of my sample jpg-image, this line caused overflow:

output_red = pixel_1_red + int_error_red

You may need to change the line to something like this:

let temp_red = Int(pixel_1_red) + Int(int_error_red)
output_red = temp_red > 255 ? 255 : UInt8(temp_red)

In Swift, + operator detects overflow and causes app crash, and overflow ignoring operator &+ does not suit for image processing. You may need to care about the result range of each operation in your code.