why the CGImageGetBytesPerRow() method return a weird value on some images?

Question

I got an image from a bigger image by

let partialCGImage = CGImageCreateWithImageInRect(CGImage, frame)

but sometimes I got wrong RGBA value. For example, I calculated the average red values of an image, but it turned out like a gray image. So I checked the info as follow.

image width: 64
image height: 64
image has 5120 bytes per row
image has 8 bits per component
image color space: <CGColorSpace 0x15d68fbd0> (kCGColorSpaceICCBased; kCGColorSpaceModelRGB; sRGB IEC61966-2.1)
image is mask: false
image bitmap info: CGBitmapInfo(rawValue: 8194)
image has 32 bits per pixel
image utt type: nil
image should interpolate: true
image  rendering intent: CGColorRenderingIntent
Bitamp Info: ------
Alpha info mask: Ture
Float components: False
Byte oder mask: Ture
Byte order default: False
Byte order 16 little: False
Byte order 32 little: Ture
Byte order 16 big: Ture
Byte order 32 big: False
Image Info ended---------------

Then I got a really weird problem, why the width and height are both 64 pxs, and the image has 8 bits(1 byte) per component(4 bytes per pixel), but the bytes per row is 5120?
And I notice the bitmap info of the normal image is quite different, it doesn't has any byte order infomation. I googled the different between little endian and big endian, but I got confused when they showed up together. I really need help since my project has already delayed for 2 days because of that. Thanks!

By the way, I used following code to get the RGBA value.

let pixelData=CGDataProviderCopyData(CGImageGetDataProvider(self.CGImage))
let data:UnsafePointer<UInt8> = CFDataGetBytePtr(pixelData)

var rs: [[Int]] = []
var gs: [[Int]] = []
var bs: [[Int]] = []

let widthMax = imageWidth
let heightMax = imageHeight
for indexX in 0...widthMax {
        var tempR: [Int] = []
        var tempG: [Int] = []
        var tempB: [Int] = []
        for indexY in 0...heightMax {
            let offSet = 4 * (indexX * imageWidth + indexY)
            **let r = Int(data[pixelInfo + offSet])
            let g = Int(data[pixelInfo + 1 + offSet])
            let b = Int(data[pixelInfo + 2 + offSet])**
            tempR.append(r)
            tempG.append(g)
            tempB.append(b)
        }
        rs.append(tempR)
        gs.append(tempG)
        bs.append(tempB)
    }

Ask me if you have problem with my code. Thank you for help.

Answer 1

In addition to the question about pixelInfo, raised by Segmentation, the calculation of offSet seem curious:

let offSet = 4 * (indexX * imageWidth + indexY)

The x and y values are backwards. Also, you also cannot assume that the bytes per row is always equal to 4 times the width in pixels because some image formats pad bytes per row. Anyway, it theoretically it should be:

let offSet = indexY * bytesPerRow + indexX * bytesPerPixel 

Also note that in addition to the x/y flip issue, you don't want 0 ... widthMax and 0 ... heightMax (as those will return widthMax + 1 and heightMax + 1 data points). Instead, you want to use 0 ..< widthMax and 0 ..< heightMax.

Also if you're dealing with random image files, there are other deeper problems here. For example, you can't make assumptions regarding RGBA vs ARGB vs CMYK, big endian vs little endian, etc., captured in the bitmap info field.

Rather than writing code that can deal with all of these variations in pixel buffers, Apple suggests alternative to take the image of some random configuration and render it to some consistent context configuration, and then you can navigate the buffer more easily. See Technical Q&A #1509.