我把这个答案留给那些也在寻找基于整数计算的alpha混合两种颜色的alpha（也就是说，允许“背景”或“基础”颜色也是半透明的）的人。它不是 * 非常 * 快，但肯定比它的浮点等价物快。
不幸的是，我问题中的代码存在缺陷，有时会给出256的结果，这在某些情况下会导致丑陋的黑色像素（(unsigned char)256 == 0）。
下面的代码提供了解决方案，也可以作为正确性检查。它验证：

• 结果alpha和结果颜色与浮点解的差异都不超过一个单位（1）。差异来自整数除法时的精度不足
• 结果alpha和结果颜色都不超过[0..255]的边界

从信息上来说，浮点alpha通常会保留在[0.0f..1.0f]范围内，现在它被规范化为[0.0f..255.0f]，这样我就可以将它与它的int对应项进行比较。
验证代码/解决方案如下。

#include <iostream>

int main()
{
    uint64_t diffs = 0;

    for (unsigned int baseAlpha = 0; baseAlpha < 256; baseAlpha++) 
    {
        printf("Processing a1 = %d\n", baseAlpha);

        for (unsigned int baseColor = 0; baseColor < 256; baseColor++)
            for (unsigned int targetAlpha = 0; targetAlpha < 256; targetAlpha++)
                for (unsigned int targetColor = 0; targetColor < 256; targetColor++)
                {
                    // Evaluate float result (FLOAT ALPHA BLENDING)
                    // R, G, B in [0.0f,255.0f]; 
                    // A in [0.0f, 1.0f]

                    float floatBaseAlpha = baseAlpha / 255.0f;
                    float floatTargetAlpha = targetAlpha / 255.0f;

                    float floatResultAlpha = (1 - floatTargetAlpha) * floatBaseAlpha + floatTargetAlpha;
                    float floatResultColor = 0.0f;
                    if (floatResultAlpha >= 1.0f / 255.0f)
                    {
                        floatResultColor = ((1 - floatTargetAlpha) * floatBaseAlpha * baseColor + floatTargetAlpha * targetColor) / floatResultAlpha;
                    }
                    else
                    {
                        floatResultColor = 0.0f;
                    }

                    floatResultAlpha *= 255.0f;

                    // Evaluate int result (INT ALPHA BLENDING)
                    // R, G, B, A in [0, 255]

                    int intResultAlpha = (((baseAlpha + targetAlpha) * 255) - targetAlpha * baseAlpha);
                    int intResultColor;
                    if (intResultAlpha > 0)
                    {
                        unsigned int divisor = intResultAlpha;

                        unsigned int baseAR = baseAlpha * baseColor;
                        intResultColor = (((targetAlpha * targetColor + baseAR) * 255) - (baseAR * targetAlpha)) / divisor;
                    }
                    else
                    {
                        intResultColor = 0;
                    }

                    intResultAlpha = intResultAlpha / 255;

                    // Compare

                    int alphaFromFloat = (int)floatResultAlpha;
                    int colorFromFloat = (int)floatResultColor;

                    int alphaFromInt = (int)intResultAlpha;
                    int colorFromInt = (int)intResultColor;

                    int aDiff = std::abs(alphaFromFloat - alphaFromInt);
                    int cDiff = std::abs(colorFromFloat - colorFromInt);

                    if (colorFromInt > 255 || colorFromInt < 0)
                    {
                        printf("Int color outside range!");
                    }

                    if (aDiff > 1 || cDiff > 1)
                    {
                        printf("Critical difference: bA: %u, bC: %u, tA: %u, tC: %u\n", baseAlpha, baseColor, targetAlpha, targetColor);
                        printf("Float result: A: %d, C: %d\n", alphaFromFloat, colorFromFloat);
                        printf("Int result: A: %d, C: %d\n", alphaFromInt, colorFromInt);
                        printf("Alpha difference: %d\n", aDiff);
                        printf("Color difference: %d\n", cDiff);
                    }

                    if (aDiff > 0 || cDiff > 0)
                        diffs++;
                }
    }

    printf("Total differences: %lld (%lld%%)\n", diffs, (100Ui64 * diffs / (1Ui64 << 32)));

    getchar();
}

字符串
结果令人惊讶地好-应用程序测试了所有可能的颜色和阿尔法组合，并且与浮点计算不同的那些组合（我认为是有效的）的百分比低于1%（组合总数为4 294 967 296）：

Total differences: 4959508 (0%)

型
阿尔法混合的流行优化是通过替换（* 255, / 255）操作，分别（<< 8, >> 8），等于（* 256, / 256）。由于我们需要乘和除以255而不是256，优化的代价是精度下降。坏消息是错误结果的数量急剧增加，但好消息是，误差仍然不超过alpha和颜色的单位值：

int intResultAlpha = (((baseAlpha + targetAlpha) << 8) - targetAlpha * baseAlpha);
int intResultColor;
if (intResultAlpha > 0)
{
    unsigned int divisor = intResultAlpha;

    unsigned int baseAR = baseAlpha * baseColor;
    intResultColor = (((targetAlpha * targetColor + baseAR) << 8) - (baseAR * targetAlpha)) / divisor;
}
else
{
    intResultColor = 0;
}

intResultAlpha = intResultAlpha >> 8;

Total differences: 1218912093 (28%)

的字符串
所以现在：

• 如果您关心精确的结果，请选择缓慢但精确的浮点解决方案（记住将alpha值保持在[0.0f..1.0f]范围内，而不是[0.0f..255.0f]！
• 如果你想要更快，但（可以忽略）不太准确的解决方案，选择整数解决方案与255的除法和乘法。
• 如果你想要更快，但不太准确的解决方案（虽然仍然不是肉眼），选择位移解决方案。
• 如果你想要更快的解决方案，选择其中一个并进一步优化它们（想法包括尝试将两个通道合并到一个64位int中，并尝试一次处理两个通道-改进33%或使用各种扩展（如MMX）在汇编程序中实现代码）。

如果你决定选择最后一个解决方案，不要忘记在这里发布另一个答案-我相信每个人都会从快速阿尔法混合算法中受益。