使用NSBitmapImageRep手动分配像素仍出现多余填充的问题

需求说明 #

• 手动分配并填充纯色像素数据；
• 支持RGB（hasAlpha=false时）和RGBA（hasAlpha=true时）两种格式；
• hasAlpha=false时确保无自动填充，内存为紧凑RGB数据，无多余字节；
• 仅依赖NSBitmapImageRep构建图像，不使用NSGraphicsContext或CGContext（因NSGraphicsContext不支持纯RGB图像）。

问题现象 #

当前函数仍出现多余填充，代码输出如下：

Expected Bytes Per Row: 3072 bytes/row
Actual Bytes Per Row: 4096 bytes/row
Image has padding! Extra 1024 bytes per row.

使用示例代码 #

let size: NSSize = NSSize(width: 1024, height: 1024)

let myImage = createImage(hasAlpha: false, pixelSize: size, color: .red)

if let validImage: NSImage = myImage {
    if let tiffData: Data = validImage.tiffRepresentation, let nsBitmapImageRep: NSBitmapImageRep = NSBitmapImageRep(data: tiffData) {

        let expectedBytesPerRow = nsBitmapImageRep.samplesPerPixel*nsBitmapImageRep.pixelsWide
        let actualBytesPerRow = nsBitmapImageRep.bytesPerRow
        
        print("Expected Bytes Per Row: \(expectedBytesPerRow) bytes/row")
        print("Actual Bytes Per Row: \(actualBytesPerRow) bytes/row")
        
        if actualBytesPerRow > expectedBytesPerRow {
            print("Image has padding! Extra \(actualBytesPerRow - expectedBytesPerRow) bytes per row.")
        } else {
            print("No padding detected.")
        }
        
    }
}

原实现函数 #

func createImage(hasAlpha: Bool, pixelSize: NSSize, color: NSColor) -> NSImage? {
    
    let width = Int(pixelSize.width)
    let height = Int(pixelSize.height)
    let components = hasAlpha ? 4 : 3  // RGBA or RGB
    let bitsPerSample = 8
    let bytesPerPixel = components
    let bytesPerRow = width * bytesPerPixel  // Ensure exact memory layout, no padding

    // Allocate memory for pixel buffer
    guard let pixelData = malloc(height * bytesPerRow)?.assumingMemoryBound(to: UInt8.self) else {
        print("Failed to allocate memory.")
        return nil
    }

    defer { free(pixelData) }  // Free memory on function exit

    // Convert color to RGB space
    let colorSpace = NSColorSpace.deviceRGB
    guard let colorInRGB = color.usingColorSpace(colorSpace) else {
        print("Failed to convert color to RGB space.")
        return nil
    }

    let red = UInt8(colorInRGB.redComponent * 255)
    let green = UInt8(colorInRGB.greenComponent * 255)
    let blue = UInt8(colorInRGB.blueComponent * 255)
    let alpha = hasAlpha ? UInt8(colorInRGB.alphaComponent * 255) : 255

    // Fill pixel buffer manually
    for y in 0..<height {
        for x in 0..<width {
            let pixelIndex = (y * bytesPerRow) + (x * bytesPerPixel)
            pixelData[pixelIndex] = red
            pixelData[pixelIndex + 1] = green
            pixelData[pixelIndex + 2] = blue
            if hasAlpha {
                pixelData[pixelIndex + 3] = alpha
            }
        }
    }

    // Create a pointer to the pixel buffer
    var pixelDataPlane: UnsafeMutablePointer<UInt8>? = pixelData

    // Create NSBitmapImageRep without extra padding
    guard let bitmapRep = NSBitmapImageRep(
        bitmapDataPlanes: &pixelDataPlane,  // Pass pointer to pointer
        pixelsWide: width,
        pixelsHigh: height,
        bitsPerSample: bitsPerSample,
        samplesPerPixel: components,
        hasAlpha: hasAlpha,
        isPlanar: false,
        colorSpaceName: .deviceRGB,
        bytesPerRow: bytesPerRow,  // Prevent unwanted padding
        bitsPerPixel: bitsPerSample * bytesPerPixel
    ) else {
        print("Failed to create bitmap representation.")
        return nil
    }

    // Create final NSImage
    let image = NSImage(size: pixelSize)
    image.addRepresentation(bitmapRep)

    return image
}

问题原因与解决方案 #

核心问题 #

通过tiffRepresentation转换图像时，系统会自动将RGB格式的图像转换为带Alpha通道或内存对齐的TIFF格式，导致你读取的NSBitmapImageRep是转换后的数据，而非原始的紧凑RGB内存布局。

修复后的函数 #

func createImage(hasAlpha: Bool, pixelSize: NSSize, color: NSColor) -> NSImage? {
    let width = Int(pixelSize.width)
    let height = Int(pixelSize.height)
    let components = hasAlpha ? 4 : 3
    let bitsPerSample = 8
    let bytesPerPixel = components
    let bytesPerRow = width * bytesPerPixel
    
    // 分配内存
    guard let pixelData = malloc(height * bytesPerRow)?.assumingMemoryBound(to: UInt8.self) else {
        print("内存分配失败")
        return nil
    }
    defer { free(pixelData) }
    
    // 转换颜色到RGB空间
    let colorSpace = NSColorSpace.deviceRGB
    guard let colorInRGB = color.usingColorSpace(colorSpace) else {
        print("颜色转换失败")
        return nil
    }
    
    let red = UInt8(colorInRGB.redComponent * 255)
    let green = UInt8(colorInRGB.greenComponent * 255)
    let blue = UInt8(colorInRGB.blueComponent * 255)
    let alpha = hasAlpha ? UInt8(colorInRGB.alphaComponent * 255) : 255
    
    // 批量填充像素数据（优化效率）
    if hasAlpha {
        let pixelValue: UInt32 = (UInt32(alpha) << 24) | (UInt32(red) << 16) | (UInt32(green) << 8) | UInt32(blue)
        memcpy(pixelData, &pixelValue, bytesPerPixel)
        let rowBytes = bytesPerRow
        for y in 1..<height {
            memcpy(pixelData + y * rowBytes, pixelData, rowBytes)
        }
    } else {
        let rowStart = pixelData
        for y in 0..<height {
            let currentRow = rowStart + y * bytesPerRow
            for x in 0..<width {
                let idx = x * 3
                currentRow[idx] = red
                currentRow[idx+1] = green
                currentRow[idx+2] = blue
            }
        }
    }
    
    // 创建无填充的BitmapRep
    var pixelDataPlane: UnsafeMutablePointer<UInt8>? = pixelData
    guard let bitmapRep = NSBitmapImageRep(
        bitmapDataPlanes: &pixelDataPlane,
        pixelsWide: width,
        pixelsHigh: height,
        bitsPerSample: bitsPerSample,
        samplesPerPixel: components,
        hasAlpha: hasAlpha,
        isPlanar: false,
        colorSpaceName: .deviceRGB,
        bytesPerRow: bytesPerRow,
        bitsPerPixel: bitsPerSample * components
    ) else {
        print("创建BitmapRep失败")
        return nil
    }
    
    // 直接验证原始BitmapRep的内存布局
    let expectedBytesPerRow = bitmapRep.samplesPerPixel * bitmapRep.pixelsWide
    let actualBytesPerRow = bitmapRep.bytesPerRow
    print("预期行字节数：\(expectedBytesPerRow) bytes/row")
    print("实际行字节数：\(actualBytesPerRow) bytes/row")
    if actualBytesPerRow > expectedBytesPerRow {
        print("存在填充！每行多余 \(actualBytesPerRow - expectedBytesPerRow) 字节")
    } else {
        print("无填充")
    }
    
    let image = NSImage(size: pixelSize)
    image.addRepresentation(bitmapRep)
    return image
}

正确验证方式 #

不要通过tiffRepresentation转换后验证，直接使用原始的NSBitmapImageRep：

let size = NSSize(width: 1024, height: 1024)
if let myImage = createImage(hasAlpha: false, pixelSize: size, color: .red),
   let bitmapRep = myImage.representations.first as? NSBitmapImageRep {
    let expected = bitmapRep.samplesPerPixel * bitmapRep.pixelsWide
    let actual = bitmapRep.bytesPerRow
    print("预期行字节数：\(expected)")
    print("实际行字节数：\(actual)")
    print(actual == expected ? "无填充" : "存在多余填充 \(actual - expected) 字节")
}

关键说明 #

1. TIFF格式的限制：TIFF默认会添加Alpha通道或对齐内存，导致读取到的是转换后的数据，而非原始紧凑RGB。
2. 直接验证原始BitmapRep：创建后的NSBitmapImageRep本身就是你需要的紧凑格式，直接读取它的属性即可验证。
3. 内存填充的避免：通过显式指定bytesPerRow为width * samplesPerPixel，强制系统使用无填充的内存布局。

内容的提问来源于stack exchange，提问作者Mango