如何使用按位运算符使 ARGB 透明

Question

我需要制作透明度，有 2 个像素：

pixel1: {A, R, G, B} - 前景像素
Pixel2：{A，R，G，B} - 背景像素

A，R，G，B是字节值

每种颜色都由字节值表示

现在我计算透明度为：

newR = Pixel2_R * Alpha / 255 + Pixel1_R * (255 - Alpha) / 255
newG = Pixel2_G * Alpha / 255 + Pixel1_G * (255 - Alpha) / 255
newB = Pixel2_B * alpha / 255 + Pixel1_B * (255 - alpha) / 255

但速度太慢 我需要使用按位运算符（AND、OR、XOR、NEGATION、BIT MOVE）来执行此操作

我想在 Windows Phone 7 XNA 上执行此操作

--- 附加 C# 代码 ---

    public static uint GetPixelForOpacity(uint reduceOpacityLevel, uint pixelBackground, uint pixelForeground, uint pixelCanvasAlpha)
    {
        byte surfaceR = (byte)((pixelForeground & 0x00FF0000) >> 16);
        byte surfaceG = (byte)((pixelForeground & 0x0000FF00) >> 8);
        byte surfaceB = (byte)((pixelForeground & 0x000000FF));

        byte sourceR = (byte)((pixelBackground & 0x00FF0000) >> 16);
        byte sourceG = (byte)((pixelBackground & 0x0000FF00) >> 8);
        byte sourceB = (byte)((pixelBackground & 0x000000FF));

        uint newR = sourceR * pixelCanvasAlpha / 256 + surfaceR * (255 - pixelCanvasAlpha) / 256;
        uint newG = sourceG * pixelCanvasAlpha / 256 + surfaceG * (255 - pixelCanvasAlpha) / 256;
        uint newB = sourceB * pixelCanvasAlpha / 256 + surfaceB * (255 - pixelCanvasAlpha) / 256;

        return (uint)255 << 24 | newR << 16 | newG << 8 | newB;
    }

Answer 1

您无法仅使用按位运算进行 8 位 alpha 混合，除非您基本上使用基本运算（8 个移位加法）重新发明了乘法。

您可以执行其他答案中提到的两种方法：使用 256 而不是 255，或使用查找表。两者都有问题，但您可以减轻它们。这实际上取决于您在什么架构上执行此操作：乘法、除法、移位、加法和内存负载的相对速度。无论如何：

查找表：一个简单的 256x256 查找表为 64KB。这会破坏你的数据缓存并最终变得非常慢。我不会推荐它，除非你的CPU有一个非常慢的乘法器，但有低延迟的RAM。您可以通过丢弃一些 alpha 位（例如 A>>3）来提高性能，从而产生 32x256=8KB 的查找，这更有可能适合缓存。

使用 256 而不是 255：除以 256 的想法只是右移 8。这会稍微偏离并且倾向于向下舍入，使图像稍微变暗，例如，如果 R=255，A=255，则 (R*A )/256 = 254。您可以作一点，这样做：(R*A+R+A)/256 或只是 (R*A+R)/256 或 (R*A+ A)/256 = 255。或者，首先将 A 缩放至 0..256，例如：A = (256*A)/255。这只是一个昂贵的除以 255 而不是 6。然后，(R*A)/256 = 255。

Answer 2

我认为仅使用这些运算符无法以相同的精度完成此操作。我认为，你最好的选择是使用 LUT（只要 LUT 可以容纳在 CPU 缓存中，否则它甚至可能会更慢）

// allocate the LUT (64KB)
unsigned char lut[256*256] __cacheline_aligned; // __cacheline_aligned is a GCC-ism

// macro to access the LUT
#define LUT(pixel, alpha) (lut[(alpha)*256+(pixel)])

// precompute the LUT
for (int alpha_value=0; alpha_value<256; alpha_value++) {
  for (int pixel_value=0; pixel_value<256; pixel_value++) {
    LUT(pixel_value, alpha_value) = (unsigned char)((double)(pixel_value) * (double)(alpha_value) / 255.0));
  }
}

// in the loop
unsigned char ialpha = 255-alpha;
newR = LUT(pixel2_R, alpha) + LUT(pixel1_R, ialpha);
newG = LUT(pixel2_G, alpha) + LUT(pixel1_G, ialpha);
newB = LUT(pixel2_B, alpha) + LUT(pixel1_B, ialpha);

，否则你应该尝试对代码进行矢量化。但要做到这一点，您至少应该向我们提供有关您的 CPU 架构和编译器的更多信息。请记住，如果提供了正确的选项，您的编译器可能能够自动矢量化。