Bitmap与Metal Texture互转时，pixelFormat的工作原理是怎样的？

我来帮你把MTLTexture像素格式和NSBitmapImageRep的关联理清楚，同时搞定带负值保留的图像相减需求～

NSBitmapImageRep的关键属性（比如bitsPerSample、samplesPerPixel、bitmapFormat）其实对应着像素数据的存储类型，而MTLPixelFormat就是Metal对这些存储类型的标准化定义。这里最关键的点是：

• 普通图片（PNG/JPG这类）对应的NSBitmapImageRep一般是8位无符号整数格式（bitsPerSample=8、samplesPerPixel=4、bitmapFormat=.32BitRGBA），对应Metal里的MTLPixelFormat.rgba8Unorm——但这种格式只能存0.0到1.0的数值，负值会被直接钳制到0，根本留不住。
• 要保留相减产生的负值，必须用浮点型的MTLPixelFormat，比如rgba32Float（每个通道32位浮点数）或rgba16Float（16位浮点数，内存占用更小），这类格式能存储任意正负的数值，完全满足计算需求。

1. 先调整你的textureFrom方法，适配浮点格式 #

你的现有方法默认处理的是整数格式的bitmap，要转成浮点型纹理，得先把bitmap的像素数据转换成浮点值，再创建对应的MTLTexture。修改后的代码如下：

func textureFrom(bitmap: NSBitmapImageRep, pixelFormat: MTLPixelFormat) -> MTLTexture? {
    guard !bitmap.isPlanar else { return nil }
    
    // 判断目标格式是否为浮点型
    let supportedFloatFormats: [MTLPixelFormat] = [.rgba32Float, .rgba16Float, .rgb32Float, .rgb16Float]
    let needsFloatConversion = supportedFloatFormats.contains(pixelFormat)
    
    var pixelData: UnsafeMutableRawPointer?
    var bytesPerRow: Int
    
    if needsFloatConversion {
        // 将bitmap的0-1范围的颜色值转成浮点型
        let width = bitmap.pixelsWide
        let height = bitmap.pixelsHigh
        let bytesPerPixel = pixelFormat == .rgba32Float ? 16 : 8 // RGBA32Float是4*4字节，RGBA16Float是4*2字节
        bytesPerRow = width * bytesPerPixel
        
        // 分配浮点像素内存
        pixelData = malloc(width * height * bytesPerPixel)
        guard let floatPixels = pixelData?.bindMemory(to: Float32.self, capacity: width * height * 4) else {
            free(pixelData)
            return nil
        }
        
        // 遍历每个像素，转换为浮点值
        for y in 0..<height {
            for x in 0..<width {
                let color = bitmap.colorAt(x: x, y: y)
                let pixelIndex = (y * width + x) * 4
                floatPixels[pixelIndex] = Float(color.redComponent)
                floatPixels[pixelIndex+1] = Float(color.greenComponent)
                floatPixels[pixelIndex+2] = Float(color.blueComponent)
                floatPixels[pixelIndex+3] = Float(color.alphaComponent)
            }
        }
    } else {
        // 原有整数格式的处理逻辑
        pixelData = bitmap.bitmapData
        bytesPerRow = bitmap.bytesPerRow
        guard pixelData != nil else { return nil }
    }
    
    defer {
        // 释放我们手动分配的浮点内存
        if needsFloatConversion {
            free(pixelData)
        }
    }
    
    // 创建纹理描述符，必须开启读写权限（因为要做计算）
    let textureDescriptor = MTLTextureDescriptor.texture2DDescriptor(
        pixelFormat: pixelFormat,
        width: bitmap.pixelsWide,
        height: bitmap.pixelsHigh,
        mipmapped: false
    )
    textureDescriptor.usage = [.shaderRead, .shaderWrite]
    
    guard let device = MTLCreateSystemDefaultDevice(),
          let texture = device.makeTexture(descriptor: textureDescriptor) else {
        return nil
    }
    
    // 将像素数据拷贝到纹理中
    let region = MTLRegionMake2D(0, 0, bitmap.pixelsWide, bitmap.pixelsHigh)
    texture.replace(region: region, mipmapLevel: 0, withBytes: pixelData!, bytesPerRow: bytesPerRow)
    
    return texture
}

2. 实现图像相减：两种方案任选 #

方案一：自定义Metal计算内核 #

写一个简单的相减 shader，直接输出负值：

#include <metal_stdlib>
using namespace metal;

// 内核函数：纹理A - 纹理B，结果保留负值
kernel void subtractTextures(
    texture2d<float, access::read> textureA [[texture(0)]],
    texture2d<float, access::read> textureB [[texture(1)]],
    texture2d<float, access::write> outputTexture [[texture(2)]],
    uint2 gid [[thread_position_in_grid]]
) {
    float4 colorA = textureA.read(gid);
    float4 colorB = textureB.read(gid);
    float4 result = colorA - colorB; // 直接相减，负值完全保留
    outputTexture.write(result, gid);
}

注意这里的纹理类型是float，和我们创建的rgba32Float格式完全匹配，计算后的负值会被完整存储。

方案二：用MPS内置方法（更快捷） #

Metal Performance Shaders有现成的MPSImageSubtract，只要传入浮点格式的纹理，就能自动处理相减并保留负值：

import MetalPerformanceShaders

func subtractImages(device: MTLDevice, textureA: MTLTexture, textureB: MTLTexture, commandBuffer: MTLCommandBuffer) -> MTLTexture? {
    // 必须确保输入纹理是浮点格式
    guard textureA.pixelFormat == .rgba32Float, textureB.pixelFormat == .rgba32Float else {
        return nil
    }
    
    // 创建输出纹理（同样用浮点格式）
    let outputDescriptor = MTLTextureDescriptor.texture2DDescriptor(
        pixelFormat: .rgba32Float,
        width: textureA.width,
        height: textureA.height,
        mipmapped: false
    )
    outputDescriptor.usage = [.shaderWrite, .shaderRead]
    guard let outputTexture = device.makeTexture(descriptor: outputDescriptor) else {
        return nil
    }
    
    // 执行相减操作
    let subtractFilter = MPSImageSubtract(device: device)
    subtractFilter.encode(
        commandBuffer: commandBuffer,
        primaryTexture: textureA,
        secondaryTexture: textureB,
        destinationTexture: outputTexture
    )
    
    return outputTexture
}

• 浮点纹理计算完成后，如果要转回到NSBitmapImageRep显示，需要自己处理负值映射（比如把-1.0到1.0的范围转成0-255的整数，或者用其他视觉化方式），因为普通图片格式不支持浮点像素。
• 如果你不需要极高的精度，用rgba16Float比rgba32Float更节省内存，计算速度也更快，完全能满足大多数相减场景的需求。

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