Subversion Repositories Games.Prince of Persia

namespace xbrz

{

        // -------------------------------------------------------------------------

        // | xBRZ: "Scale by rules" - high quality image upscaling filter by Zenju |

        // -------------------------------------------------------------------------

        // using a modified approach of xBR:

        // http://board.byuu.org/viewtopic.php?f=10&t=2248

        //  - new rule set preserving small image features

        //  - highly optimized for performance

        //  - support alpha channel

        //  - support multithreading

        //  - support 64-bit architectures

        //  - support processing image slices

        //  - support scaling up to 6xBRZ

        // -> map source (srcWidth * srcHeight) to target (scale * width x scale * height) image, optionally processing a half-open slice of rows [yFirst, yLast) only

        // -> support for source/target pitch in bytes!

        // -> if your emulator changes only a few image slices during each cycle (e.g. DOSBox) then there's no need to run xBRZ on the complete image:

        //    Just make sure you enlarge the source image slice by 2 rows on top and 2 on bottom (this is the additional range the xBRZ algorithm is using during analysis)

        //    CAVEAT: If there are multiple changed slices, make sure they do not overlap after adding these additional rows in order to avoid a memory race condition

        //    in the target image data if you are using multiple threads for processing each enlarged slice!

        // 

        // THREAD-SAFETY: - parts of the same image may be scaled by multiple threads as long as the [yFirst, yLast) ranges do not overlap!

        //                - there is a minor inefficiency for the first row of a slice, so avoid processing single rows only; suggestion: process at least 8-16 rows

        template <class Pix> inline Pix* byteAdvance(Pix* ptr, int bytes)

        {

            using PixNonConst = typename std::remove_cv<Pix>::type;

            using PixByte     = typename std::conditional<std::is_same<Pix, PixNonConst>::value, char, const char>::type;

            static_assert(std::is_integral<PixNonConst>::value, "Pix* is expected to be cast-able to char*");

            return reinterpret_cast<Pix*>(reinterpret_cast<PixByte*>(ptr) + bytes);

        }

//fill block  with the given color

template <class Pix> inline void fillBlock(Pix* trg, int pitch, Pix col, int blockWidth, int blockHeight)

{

    //for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch))

    //    std::fill(trg, trg + blockWidth, col);

    for (int y = 0; y < blockHeight; ++y, trg = byteAdvance(trg, pitch))

        for (int x = 0; x < blockWidth; ++x)

            trg[x] = col;

}

template <class PixSrc, class PixTrg, class PixConverter>

void nearestNeighborScale(const PixSrc* src, int srcWidth, int srcHeight, int srcPitch,

                          /**/  PixTrg* trg, int trgWidth, int trgHeight, int trgPitch,

                          int slice_type, int yFirst, int yLast, PixConverter pixCvrt /*convert PixSrc to PixTrg*/)

{

    static_assert(std::is_integral<PixSrc>::value, "PixSrc* is expected to be cast-able to char*");

    static_assert(std::is_integral<PixTrg>::value, "PixTrg* is expected to be cast-able to char*");

    static_assert(std::is_same<decltype(pixCvrt(PixSrc())), PixTrg>::value, "PixConverter returning wrong pixel format");

    if (srcPitch < srcWidth * static_cast<int>(sizeof(PixSrc))  ||

        trgPitch < trgWidth * static_cast<int>(sizeof(PixTrg)))

    {

        assert(false);

        return;

    }

    if (slice_type == XBRZ_SLICETYPE_SOURCE)

    {

            //nearest-neighbor (going over source image - fast for upscaling, since source is read only once

            yFirst = std::max(yFirst, 0);

            yLast  = std::min(yLast, srcHeight);

            if (yFirst >= yLast || trgWidth <= 0 || trgHeight <= 0) return;

            for (int y = yFirst; y < yLast; ++y)

            {

                //mathematically: ySrc = floor(srcHeight * yTrg / trgHeight)

                // => search for integers in: [ySrc, ySrc + 1) * trgHeight / srcHeight

                //keep within for loop to support MT input slices!

                const int yTrg_first = ( y      * trgHeight + srcHeight - 1) / srcHeight; //=ceil(y * trgHeight / srcHeight)

                const int yTrg_last  = ((y + 1) * trgHeight + srcHeight - 1) / srcHeight; //=ceil(((y + 1) * trgHeight) / srcHeight)

                const int blockHeight = yTrg_last - yTrg_first;

                if (blockHeight > 0)

                {

                    const PixSrc* srcLine = byteAdvance(src, y * srcPitch);

                    /**/  PixTrg* trgLine = byteAdvance(trg, yTrg_first * trgPitch);

                    int xTrg_first = 0;

                    {

                        const int xTrg_last = ((x + 1) * trgWidth + srcWidth - 1) / srcWidth;

                        const int blockWidth = xTrg_last - xTrg_first;

                        if (blockWidth > 0)

                        {

                            xTrg_first = xTrg_last;

                            const auto trgPix = pixCvrt(srcLine[x]);

                            fillBlock(trgLine, trgPitch, trgPix, blockWidth, blockHeight);

                            trgLine += blockWidth;

                        }

                    }

                }

            }

    }

    else if (slice_type == XBRZ_SLICETYPE_TARGET)

    {

            //nearest-neighbor (going over target image - slow for upscaling, since source is read multiple times missing out on cache! Fast for similar image sizes!)

            yFirst = std::max(yFirst, 0);

            yLast  = std::min(yLast, trgHeight);

            if (yFirst >= yLast || srcHeight <= 0 || srcWidth <= 0) return;

            for (int y = yFirst; y < yLast; ++y)

            {

                PixTrg* trgLine = byteAdvance(trg, y * trgPitch);

                const int ySrc = srcHeight * y / trgHeight;

                const PixSrc* srcLine = byteAdvance(src, ySrc * srcPitch);

                for (int x = 0; x < trgWidth; ++x)

                {

                    const int xSrc = srcWidth * x / trgWidth;

                    trgLine[x] = pixCvrt(srcLine[xSrc]);

                }

            }

    }

}

}

template <unsigned int M, unsigned int N> inline

uint32_t gradientRGB(uint32_t pixFront, uint32_t pixBack) //blend front color with opacity M / N over opaque background: http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending

{

    static_assert(0 < M && M < N && N <= 1000, "");

    auto calcColor = [](unsigned char colFront, unsigned char colBack) -> unsigned char { return (colFront * M + colBack * (N - M)) / N; };

        return ((calcColor (GET_RED   (pixFront), GET_RED   (pixBack)) << 16)

              | (calcColor (GET_GREEN (pixFront), GET_GREEN (pixBack)) <<  8)

              | (calcColor (GET_BLUE  (pixFront), GET_BLUE  (pixBack)) <<  0));

}

template <unsigned int M, unsigned int N> inline

uint32_t gradientARGB(uint32_t pixFront, uint32_t pixBack) //find intermediate color between two colors with alpha channels (=> NO alpha blending!!!)

{

    static_assert(0 < M && M < N && N <= 1000, "");

    const unsigned int weightFront = GET_ALPHA (pixFront) * M;

    const unsigned int weightBack  = GET_ALPHA (pixBack) * (N - M);

    const unsigned int weightSum   = weightFront + weightBack;

    if (weightSum == 0)

        return 0;

    auto calcColor = [=](unsigned char colFront, unsigned char colBack)

    {

        return static_cast<unsigned char>((colFront * weightFront + colBack * weightBack) / weightSum);

    };

        return (((unsigned char) (weightSum / N))                      << 24)

              | (calcColor (GET_RED   (pixFront), GET_RED   (pixBack)) << 16)

              | (calcColor (GET_GREEN (pixFront), GET_GREEN (pixBack)) <<  8)

              | (calcColor (GET_BLUE  (pixFront), GET_BLUE  (pixBack)) <<  0);

}

//inline

//double fastSqrt(double n)

//{

//    __asm //speeds up xBRZ by about 9% compared to /*std::*/sqrt which internally uses the same assembler instructions but adds some "fluff"

//    {

//        fld n

//        fsqrt

//    }

//}

//

struct MatrixRotation;

struct MatrixRotation<ROT_0, I, J, N>

class OutputMatrix

    uint32_t& ref() const

private:

template <class T> inline

T square(T value) { return value * value; }

inline

double distRGB(uint32_t pix1, uint32_t pix2)

{

    const double r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2);

    const double g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2);

    const double b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2);

    //euklidean RGB distance

    return /*std::*/sqrt(square(r_diff) + square(g_diff) + square(b_diff));

}

inline

double distYCbCr(uint32_t pix1, uint32_t pix2, double lumaWeight)

{

    //http://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion

    //YCbCr conversion is a matrix multiplication => take advantage of linearity by subtracting first!

    const int r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2); //we may delay division by 255 to after matrix multiplication

    const int g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2); //

    const int b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2); //substraction for int is noticeable faster than for double!

    //const double k_b = 0.0722; //ITU-R BT.709 conversion

    //const double k_r = 0.2126; //

    const double k_b = 0.0593; //ITU-R BT.2020 conversion

    const double k_r = 0.2627; //

    const double k_g = 1 - k_b - k_r;

    const double scale_b = 0.5 / (1 - k_b);

    const double scale_r = 0.5 / (1 - k_r);

    const double y   = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr!

    const double c_b = scale_b * (b_diff - y);

    const double c_r = scale_r * (r_diff - y);

    //we skip division by 255 to have similar range like other distance functions

    return /*std::*/sqrt(square(lumaWeight * y) + square(c_b) + square(c_r));

}

inline double distYCbCrBuffered(uint32_t pix1, uint32_t pix2)

{

    //30% perf boost compared to plain distYCbCr()!

    //consumes 64 MB memory; using double is only 2% faster, but takes 128 MB

    static const std::vector<float> diffToDist = []

    {

        std::vector<float> tmp;

        for (uint32_t i = 0; i < 256 * 256 * 256; ++i) //startup time: 114 ms on Intel Core i5 (four cores)

        {

            const int r_diff = GET_RED (i) * 2 - 0xFF;

            const int g_diff = GET_GREEN (i) * 2 - 0xFF;

            const int b_diff = GET_BLUE (i) * 2 - 0xFF;

            const double k_b = 0.0593; //ITU-R BT.2020 conversion

            const double k_r = 0.2627; //

            const double k_g = 1 - k_b - k_r;

            const double scale_b = 0.5 / (1 - k_b);

            const double scale_r = 0.5 / (1 - k_r);

            const double y   = k_r * r_diff + k_g * g_diff + k_b * b_diff; //[!], analog YCbCr!

            const double c_b = scale_b * (b_diff - y);

            const double c_r = scale_r * (r_diff - y);

            tmp.push_back(static_cast<float>(/*std::*/sqrt(square(y) + square(c_b) + square(c_r))));

        }

        return tmp;

    }();

    //if (pix1 == pix2) -> 8% perf degradation!

    //    return 0;

    //if (pix1 < pix2)

    //    std::swap(pix1, pix2); -> 30% perf degradation!!!

#if 1

    const int r_diff = static_cast<int>(GET_RED   (pix1)) - GET_RED   (pix2);

    const int g_diff = static_cast<int>(GET_GREEN (pix1)) - GET_GREEN (pix2);

    const int b_diff = static_cast<int>(GET_BLUE  (pix1)) - GET_BLUE  (pix2);

    return diffToDist[(((r_diff + 0xFF) / 2) << 16) | //slightly reduce precision (division by 2) to squeeze value into single byte

                      (((g_diff + 0xFF) / 2) <<  8) |

                      (( b_diff + 0xFF) / 2)];

#else //not noticeably faster:

    const int r_diff_tmp = ((pix1 & 0xFF0000) + 0xFF0000 - (pix2 & 0xFF0000)) / 2;

    const int g_diff_tmp = ((pix1 & 0x00FF00) + 0x00FF00 - (pix2 & 0x00FF00)) / 2; //slightly reduce precision (division by 2) to squeeze value into single byte

    const int b_diff_tmp = ((pix1 & 0x0000FF) + 0x0000FF - (pix2 & 0x0000FF)) / 2;

    return diffToDist[(r_diff_tmp & 0xFF0000) | (g_diff_tmp & 0x00FF00) | (b_diff_tmp & 0x0000FF)];

#endif

}

template <class ColorDistance>

    auto dist = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT); };

inline bool blendingNeeded(unsigned char b) { return b != 0; }

FORCE_INLINE //perf: quite worth it!

void blendPixel(const Kernel_3x3& ker,

                uint32_t* target, int trgWidth,

        auto eq   = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT) < XBRZ_CFG_EQUAL_COLOR_TOLERANCE; };

        auto dist = [&](uint32_t pix1, uint32_t pix2) { return ColorDistance::dist(pix1, pix2, XBRZ_CFG_LUMINANCE_WEIGHT); };

        {

            if (getBottomR(blend) >= BLEND_DOMINANT)

                return true;

            //make sure there is no second blending in an adjacent rotation for this pixel: handles insular pixels, mario eyes

            if (getTopR(blend) != BLEND_NONE && !eq(e, g)) //but support double-blending for 90° corners

                return false;

            if (getBottomL(blend) != BLEND_NONE && !eq(e, c))

                return false;

            //no full blending for L-shapes; blend corner only (handles "mario mushroom eyes")

            if (!eq(e, i) && eq(g, h) && eq(h, i) && eq(i, f) && eq(f, c))

                return false;