Реализация режимов PorterDuff - как бороться с альфа

Question

Я нахожусь в ситуации, когда мне нужно использовать растровое смешивание в Android. И сделайте его похожим на iOS-версию приложения.

Парни из iOS использовали режимы PorterDuff, которые в настоящее время отсутствуют в стандартном Android- классе PorterDuff.

Точно мне нужен режим мягкого света, но забудьте об этом - я решил разобраться с идеей о некоторых режимах, отсутствующих в Android.

Вот ссылки, которые я нашел во время исследования:

• википедия
• спецификация w3
• спецификации w3 svg

Все они включают желаемую формулу, так что, кажется, довольно просто написать метод и реализовать каждый режим смешивания, который мне может понадобиться.

Однако вот тут начинаются неприятности.

Формулы в ссылках выше имеют дело только с компонентом цвета, оставляя альфа в стороне, как будто это было само собой разумеющимся. Но это не так.

До сих пор у меня был такой код вопроса. Я думаю о переписывании overlay_byte(int sc, int dc, int sa, int da) метод для реализации формулы softlight, но не могу понять, что делать с sa а также da переменные.

PS: я знаю, что производительность голой java-реализации режима смешивания будет далека от нативного класса PorterDuff андроида, но об этом можно поговорить позже...

ДОБАВЛЕНО ПОЗЖЕ:

Со вчерашнего дня я провел более глубокое исследование и нашел способ реализовать режим смешивания мягкого света на Java. Вот источник (тот же, который работает внутри Android, когда мы используем стандартные режимы, такие как PorterDuff.Mode.LIGHTEN).

я взял softlight_byte метод оттуда и все, что он использует, и перевел его на Java (сделал все, что мог здесь). Результат работает, но дает неправильное изображение: нижняя часть выглядит нормально, но верхняя часть перезагружается. Вот мой код, переписанный на Java:

public Bitmap applyBlendMode(Bitmap srcBmp, Bitmap destBmp)
{
    int width = srcBmp.getWidth();
    int height = srcBmp.getHeight();
    int srcPixels[] = new int[width * height];;
    int destPixels[] = new int[width * height];
    int resultPixels[] = new int[width * height];
    int aS = 0, rS = 0, gS = 0, bS = 0;
    int rgbS = 0;
    int aD = 0, rD = 0, gD = 0, bD = 0;
    int rgbD = 0;

    try
    {
        srcBmp.getPixels(srcPixels, 0, width, 0, 0, width, height);
        destBmp.getPixels(destPixels, 0, width, 0, 0, width, height);
        srcBmp.recycle();
        destBmp.recycle();
    }
    catch(IllegalArgumentException e) {
    }
    catch(ArrayIndexOutOfBoundsException e) {
    }

    for(int y = 0; y < height; y++) {
        for(int x = 0; x < width; x++) {
            rgbS = srcPixels[y*width + x];
            aS = (rgbS >> 24) & 0xff;
            rS = (rgbS >> 16) & 0xff;
            gS = (rgbS >>  8) & 0xff;
            bS = (rgbS      ) & 0xff;

            rgbD = destPixels[y*width + x];
            aD = ((rgbD >> 24) & 0xff);
            rD = (rgbD >> 16) & 0xff;
            gD = (rgbD >>  8) & 0xff;
            bD = (rgbD      )  & 0xff;

            rS = softlight_byte(rD, rS, aS, aD);
            gS = softlight_byte(gD, gS, aS, aD);
            bS = softlight_byte(bD, bS, aS, aD);
            aS = aS + aD - Math.round((aS * aD)/255f);

            resultPixels[y*width + x] = ((int)aS << 24) | ((int)rS << 16) | ((int)gS << 8) | (int)bS;
        }
    }

    return Bitmap.createBitmap(resultPixels, width, height, srcBmp.getConfig());
}

int softlight_byte(int sc, int dc, int sa, int da) {

    int m = (da != 0) ? dc * 256 / da : 0;

    int rc;
    if (2 * sc <= sa) {
        rc = dc * (sa + ((2 * sc - sa) * (256 - m) >> 8));
    } else if (4 * dc <= da) {
        int tmp = (4 * m * (4 * m + 256) * (m - 256) >> 16) + 7 * m;
        rc = dc * sa + (da * (2 * sc - sa) * tmp >> 8);
    } else {
        int tmp = sqrtUnitByte(m) - m;
        rc = dc * sa + (da * (2 * sc - sa) * tmp >> 8);
    }
    return clampDiv255Round(rc + sc * (255 - da) + dc * (255 - sa));
}

/** returns 255 * sqrt(n/255) */
private int sqrtUnitByte(int n) {
    return skSqrtBits(n, 15 + 4);
}

/** Return the integer square root of value, with a bias of bitBias */
int skSqrtBits(int value, int bitBias) {

    if (value < 0) { Log.wtf(TAG, "ASSERTION!"); } // bitBias always 15+4, no check required
    int root = 0;
    int remHi = 0;
    int remLo = value;
    do {
        root <<= 1;
        remHi = (remHi<<2) | (remLo>>30);
        remLo <<= 2;
        int testDiv = (root << 1) + 1;
        if (remHi >= testDiv) {
            remHi -= testDiv;
            root++;
        }
    } while (--bitBias >= 0);
    return root;
}

int clampDiv255Round(int prod) {
    if (prod <= 0) {
        return 0;
    } else if (prod >= 255*255) {
        return 255;
    } else {
        return skDiv255Round(prod);
    }
}

/** Just the rounding step in SkDiv255Round: round(value / 255)
 */
private static int skDiv255Round(int prod) {
    prod += 128;
    return (prod + (prod >> 8)) >> 8;
}

Может кто-нибудь проверить это на возможные ошибки? Это действительно очень важно для меня!

PS: applyBlendMode был взят из ТАКОГО вопроса, о котором я упоминал выше, и softlight_byte(rD, rS, aS, aD); реализация - переписана с C++.