SkBitmapProcState_matrixProcs.cpp File Reference

#include "include/core/SkMatrix.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkFixed.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkBitmapProcState.h"
#include "src/core/SkMemset.h"
#include <cstdint>
#include <cstring>

Go to the source code of this file.

Functions
static bool	can_truncate_to_fixed_for_decal (SkFixed fx, SkFixed dx, int count, unsigned max)
static void	decal_nofilter_scale (uint32_t dst[], SkFixed fx, SkFixed dx, int count)
template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, bool tryDecal>
static void	nofilter_scale (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley>
static void	nofilter_affine (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
static unsigned	extract_low_bits_clamp_clamp (SkFixed fx, int)
static unsigned	extract_low_bits_general (SkFixed fx, int max)
template<unsigned(*)(SkFixed, int) tile, unsigned(*)(SkFixed, int) extract_low_bits>
static uint32_t	pack (SkFixed f, unsigned max, SkFixed one)
template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, unsigned(*)(SkFixed, int) extract_low_bits, bool tryDecal>
static void	filter_scale (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, unsigned(*)(SkFixed, int) extract_low_bits>
static void	filter_affine (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
static unsigned	SK_USHIFT16 (unsigned x)
static unsigned	repeat (SkFixed fx, int max)
static unsigned	mirror (SkFixed fx, int max)
static unsigned	clamp (SkFixed fx, int max)
static U16CPU	int_clamp (int x, int n)
static int	sk_int_mod (int x, int n)
static U16CPU	int_repeat (int x, int n)
static U16CPU	int_mirror (int x, int n)
static void	fill_sequential (uint16_t xptr[], int pos, int count)
static void	fill_backwards (uint16_t xptr[], int pos, int count)
template<U16CPU(tiley)(int x, int n) >
static void	clampx_nofilter_trans (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
template<U16CPU(tiley)(int x, int n) >
static void	repeatx_nofilter_trans (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)
template<U16CPU(tiley)(int x, int n) >
static void	mirrorx_nofilter_trans (const SkBitmapProcState &s, uint32_t xy[], int count, int x, int y)

Variables
static const SkBitmapProcState::MatrixProc	ClampX_ClampY_Procs []
static const SkBitmapProcState::MatrixProc	RepeatX_RepeatY_Procs []
static const SkBitmapProcState::MatrixProc	MirrorX_MirrorY_Procs []

Function Documentation

can_truncate_to_fixed_for_decal()

static bool can_truncate_to_fixed_for_decal ( SkFixed  fx, SkFixed  dx, int  count, unsigned  max  )

inlinestatic

Definition at line 34 of file SkBitmapProcState_matrixProcs.cpp.

                                                                            {
    SkASSERT(count > 0);
 
    // if decal_ kept SkFractionalInt precision, this would just be dx <= 0
    // I just made up the 1/256. Just don't want to perceive accumulated error
    // if we truncate frDx and lose its low bits.
    if (dx <= SK_Fixed1 / 256) {
        return false;
    }
 
    // Note: it seems the test should be (fx <= max && lastFx <= max); but
    // historically it's been a strict inequality check, and changing produces
    // unexpected diffs.  Further investigation is needed.
 
    // We cast to unsigned so we don't have to check for negative values, which
    // will now appear as very large positive values, and thus fail our test!
    if ((unsigned)SkFixedFloorToInt(fx) >= max) {
        return false;
    }
 
    // Promote to 64bit (48.16) to avoid overflow.
    const uint64_t lastFx = fx + sk_64_mul(dx, count - 1);
 
    return SkTFitsIn<int32_t>(lastFx) && (unsigned)SkFixedFloorToInt(SkTo<int32_t>(lastFx)) < max;
}

clamp()

static unsigned clamp ( SkFixed  fx, int  max  )

static

Definition at line 271 of file SkBitmapProcState_matrixProcs.cpp.

                                           {
    return SkTPin(fx >> 16, 0, max);
}

clampx_nofilter_trans()

template<U16CPU(tiley)(int x, int n) >

static void clampx_nofilter_trans ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 343 of file SkBitmapProcState_matrixProcs.cpp.

                                                                          {
    SkASSERT(s.fInvMatrix.isTranslate());
 
    const SkBitmapProcStateAutoMapper mapper(s, x, y);
    *xy++ = tiley(mapper.intY(), s.fPixmap.height());
    int xpos = mapper.intX();
 
    const int width = s.fPixmap.width();
    if (1 == width) {
        // all of the following X values must be 0
        memset(xy, 0, count * sizeof(uint16_t));
        return;
    }
 
    uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
    int n;
 
    // fill before 0 as needed
    if (xpos < 0) {
        n = -xpos;
        if (n > count) {
            n = count;
        }
        memset(xptr, 0, n * sizeof(uint16_t));
        count -= n;
        if (0 == count) {
            return;
        }
        xptr += n;
        xpos = 0;
    }
 
    // fill in 0..width-1 if needed
    if (xpos < width) {
        n = width - xpos;
        if (n > count) {
            n = count;
        }
        fill_sequential(xptr, xpos, n);
        count -= n;
        if (0 == count) {
            return;
        }
        xptr += n;
    }
 
    // fill the remaining with the max value
    SkOpts::memset16(xptr, width - 1, count);
}

decal_nofilter_scale()

static void decal_nofilter_scale ( uint32_t  dst[], SkFixed  fx, SkFixed  dx, int  count  )

static

Definition at line 67 of file SkBitmapProcState_matrixProcs.cpp.

                                                                                    {
    // can_truncate_to_fixed_for_decal() checked only that stepping fx+=dx count-1
    // times doesn't overflow fx, so we take unusual care not to step count times.
    for (; count > 2; count -= 2) {
        *dst++ = pack_two_shorts( (fx +  0) >> 16,
                                  (fx + dx) >> 16);
        fx += dx+dx;
    }
 
    SkASSERT(count <= 2);
    switch (count) {
        case 2: ((uint16_t*)dst)[1] = SkToU16((fx + dx) >> 16); [[fallthrough]];
        case 1: ((uint16_t*)dst)[0] = SkToU16((fx +  0) >> 16);
    }
}

extract_low_bits_clamp_clamp()

static unsigned extract_low_bits_clamp_clamp ( SkFixed  fx, int    )

static

Definition at line 154 of file SkBitmapProcState_matrixProcs.cpp.

                                                                {
    // If we're already scaled up to by max like clamp/decal,
    // just grab the high four fractional bits.
    return (fx >> 12) & 0xf;
}

extract_low_bits_general()

static unsigned extract_low_bits_general ( SkFixed  fx, int  max  )

static

Definition at line 161 of file SkBitmapProcState_matrixProcs.cpp.

                                                              {
    // In repeat or mirror fx is in [0,1], so scale up by max first.
    // TODO: remove the +1 here and the -1 at the call sites...
    return extract_low_bits_clamp_clamp((fx & 0xffff) * (max+1), max);
}

fill_backwards()

static void fill_backwards ( uint16_t  xptr[], int  pos, int  count  )

static

Definition at line 335 of file SkBitmapProcState_matrixProcs.cpp.

                                                                {
    while (count --> 0) {
        SkASSERT(pos >= 0);
        *xptr++ = pos--;
    }
}

fill_sequential()

static void fill_sequential ( uint16_t  xptr[], int  pos, int  count  )

static

Definition at line 329 of file SkBitmapProcState_matrixProcs.cpp.

                                                                 {
    while (count --> 0) {
        *xptr++ = pos++;
    }
}

filter_affine()

template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, unsigned(*)(SkFixed, int) extract_low_bits>

static void filter_affine ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 228 of file SkBitmapProcState_matrixProcs.cpp.

                                                                  {
    SkASSERT(!s.fInvMatrix.hasPerspective());
 
    const SkBitmapProcStateAutoMapper mapper(s, x, y);
 
    SkFixed oneX = s.fFilterOneX,
            oneY = s.fFilterOneY;
 
    SkFractionalInt fx = mapper.fractionalIntX(),
                    fy = mapper.fractionalIntY(),
                    dx = s.fInvSxFractionalInt,
                    dy = s.fInvKyFractionalInt;
    unsigned maxX = s.fPixmap.width () - 1,
             maxY = s.fPixmap.height() - 1;
    while (count --> 0) {
        *xy++ = pack<tiley, extract_low_bits>(SkFractionalIntToFixed(fy), maxY, oneY);
        *xy++ = pack<tilex, extract_low_bits>(SkFractionalIntToFixed(fx), maxX, oneX);
 
        fy += dy;
        fx += dx;
    }
}

filter_scale()

template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, unsigned(*)(SkFixed, int) extract_low_bits, bool tryDecal>

static void filter_scale ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 191 of file SkBitmapProcState_matrixProcs.cpp.

                                                                 {
    SkASSERT(s.fInvMatrix.isScaleTranslate());
 
    const unsigned maxX = s.fPixmap.width() - 1;
    const SkFractionalInt dx = s.fInvSxFractionalInt;
    SkFractionalInt fx;
    {
        const SkBitmapProcStateAutoMapper mapper(s, x, y);
        const unsigned maxY = s.fPixmap.height() - 1;
        // compute our two Y values up front
        *xy++ = pack<tiley, extract_low_bits>(mapper.fixedY(), maxY, s.fFilterOneY);
        // now initialize fx
        fx = mapper.fractionalIntX();
    }
 
    // For historical reasons we check both ends are < maxX rather than <= maxX.
    // TODO: try changing this?  See also can_truncate_to_fixed_for_decal().
    if (tryDecal &&
        (unsigned)SkFractionalIntToInt(fx               ) < maxX &&
        (unsigned)SkFractionalIntToInt(fx + dx*(count-1)) < maxX) {
        while (count --> 0) {
            SkFixed fixedFx = SkFractionalIntToFixed(fx);
            SkASSERT((fixedFx >> (16 + 14)) == 0);
            *xy++ = (fixedFx >> 12 << 14) | ((fixedFx >> 16) + 1);
            fx += dx;
        }
        return;
    }
 
    while (count --> 0) {
        *xy++ = pack<tilex, extract_low_bits>(SkFractionalIntToFixed(fx), maxX, s.fFilterOneX);
        fx += dx;
    }
}

int_clamp()

static U16CPU int_clamp ( int  x, int  n  )

inlinestatic

Definition at line 292 of file SkBitmapProcState_matrixProcs.cpp.

                                             {
    if (x <  0) { x = 0; }
    if (x >= n) { x = n - 1; }
    return x;
}

int_mirror()

static U16CPU int_mirror ( int  x, int  n  )

inlinestatic

Definition at line 321 of file SkBitmapProcState_matrixProcs.cpp.

                                              {
    x = sk_int_mod(x, 2 * n);
    if (x >= n) {
        x = n + ~(x - n);
    }
    return x;
}

int_repeat()

static U16CPU int_repeat ( int  x, int  n  )

inlinestatic

Definition at line 317 of file SkBitmapProcState_matrixProcs.cpp.

                                              {
    return sk_int_mod(x, n);
}

mirror()

static unsigned mirror ( SkFixed  fx, int  max  )

static

Definition at line 262 of file SkBitmapProcState_matrixProcs.cpp.

                                            {
    SkASSERT(max < 65535);
    // s is 0xFFFFFFFF if we're on an odd interval, or 0 if an even interval
    SkFixed s = SkLeftShift(fx, 15) >> 31;
 
    // This should be exactly the same as repeat(fx ^ s, max) from here on.
    return SK_USHIFT16( ((fx ^ s) & 0xFFFF) * (max + 1) );
}

mirrorx_nofilter_trans()

template<U16CPU(tiley)(int x, int n) >

static void mirrorx_nofilter_trans ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 432 of file SkBitmapProcState_matrixProcs.cpp.

                                                                           {
    SkASSERT(s.fInvMatrix.isTranslate());
 
    const SkBitmapProcStateAutoMapper mapper(s, x, y);
    *xy++ = tiley(mapper.intY(), s.fPixmap.height());
    int xpos = mapper.intX();
 
    const int width = s.fPixmap.width();
    if (1 == width) {
        // all of the following X values must be 0
        memset(xy, 0, count * sizeof(uint16_t));
        return;
    }
 
    uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
    // need to know our start, and our initial phase (forward or backward)
    bool forward;
    int n;
    int start = sk_int_mod(xpos, 2 * width);
    if (start >= width) {
        start = width + ~(start - width);
        forward = false;
        n = start + 1;  // [start .. 0]
    } else {
        forward = true;
        n = width - start;  // [start .. width)
    }
    if (n > count) {
        n = count;
    }
    if (forward) {
        fill_sequential(xptr, start, n);
    } else {
        fill_backwards(xptr, start, n);
    }
    forward = !forward;
    xptr += n;
    count -= n;
 
    while (count >= width) {
        if (forward) {
            fill_sequential(xptr, 0, width);
        } else {
            fill_backwards(xptr, width - 1, width);
        }
        forward = !forward;
        xptr += width;
        count -= width;
    }
 
    if (count > 0) {
        if (forward) {
            fill_sequential(xptr, 0, count);
        } else {
            fill_backwards(xptr, width - 1, count);
        }
    }
}

nofilter_affine()

template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley>

static void nofilter_affine ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 131 of file SkBitmapProcState_matrixProcs.cpp.

                                                                    {
    SkASSERT(!s.fInvMatrix.hasPerspective());
 
    const SkBitmapProcStateAutoMapper mapper(s, x, y);
 
    SkFractionalInt fx = mapper.fractionalIntX(),
                    fy = mapper.fractionalIntY(),
                    dx = s.fInvSxFractionalInt,
                    dy = s.fInvKyFractionalInt;
    int maxX = s.fPixmap.width () - 1,
        maxY = s.fPixmap.height() - 1;
 
    while (count --> 0) {
        *xy++ = (tiley(SkFractionalIntToFixed(fy), maxY) << 16)
              | (tilex(SkFractionalIntToFixed(fx), maxX)      );
        fx += dx;
        fy += dy;
    }
}

nofilter_scale()

template<unsigned(*)(SkFixed, int) tilex, unsigned(*)(SkFixed, int) tiley, bool tryDecal>

static void nofilter_scale ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 85 of file SkBitmapProcState_matrixProcs.cpp.

                                                                   {
    SkASSERT(s.fInvMatrix.isScaleTranslate());
 
    // Write out our 32-bit y, and get our intial fx.
    SkFractionalInt fx;
    {
        const SkBitmapProcStateAutoMapper mapper(s, x, y);
        *xy++ = tiley(mapper.fixedY(), s.fPixmap.height() - 1);
        fx = mapper.fractionalIntX();
    }
 
    const unsigned maxX = s.fPixmap.width() - 1;
    if (0 == maxX) {
        // If width == 1, all the x-values must refer to that pixel, and must be zero.
        memset(xy, 0, count * sizeof(uint16_t));
        return;
    }
 
    const SkFractionalInt dx = s.fInvSxFractionalInt;
 
    if (tryDecal) {
        const SkFixed fixedFx = SkFractionalIntToFixed(fx);
        const SkFixed fixedDx = SkFractionalIntToFixed(dx);
 
        if (can_truncate_to_fixed_for_decal(fixedFx, fixedDx, count, maxX)) {
            decal_nofilter_scale(xy, fixedFx, fixedDx, count);
            return;
        }
    }
 
    // Remember, each x-coordinate is 16-bit.
    for (; count >= 2; count -= 2) {
        *xy++ = pack_two_shorts(tilex(SkFractionalIntToFixed(fx     ), maxX),
                                tilex(SkFractionalIntToFixed(fx + dx), maxX));
        fx += dx+dx;
    }
 
    auto xx = (uint16_t*)xy;
    while (count --> 0) {
        *xx++ = tilex(SkFractionalIntToFixed(fx), maxX);
        fx += dx;
    }
}

pack()

template<unsigned(*)(SkFixed, int) tile, unsigned(*)(SkFixed, int) extract_low_bits>

static uint32_t pack ( SkFixed  f, unsigned  max, SkFixed  one  )

static

Definition at line 183 of file SkBitmapProcState_matrixProcs.cpp.

                                                           {
    uint32_t packed = tile(f, max);                      // low coordinate in high bits
    packed = (packed <<  4) | extract_low_bits(f, max);  // (lerp weight _is_ coord fractional part)
    packed = (packed << 14) | tile((f + one), max);      // high coordinate in low bits
    return packed;
}

repeat()

static unsigned repeat ( SkFixed  fx, int  max  )

static

Definition at line 258 of file SkBitmapProcState_matrixProcs.cpp.

                                            {
    SkASSERT(max < 65535);
    return SK_USHIFT16((unsigned)(fx & 0xFFFF) * (max + 1));
}

repeatx_nofilter_trans()

template<U16CPU(tiley)(int x, int n) >

static void repeatx_nofilter_trans ( const SkBitmapProcState &  s, uint32_t  xy[], int  count, int  x, int  y  )

static

Definition at line 395 of file SkBitmapProcState_matrixProcs.cpp.

                                                                           {
    SkASSERT(s.fInvMatrix.isTranslate());
 
    const SkBitmapProcStateAutoMapper mapper(s, x, y);
    *xy++ = tiley(mapper.intY(), s.fPixmap.height());
    int xpos = mapper.intX();
 
    const int width = s.fPixmap.width();
    if (1 == width) {
        // all of the following X values must be 0
        memset(xy, 0, count * sizeof(uint16_t));
        return;
    }
 
    uint16_t* xptr = reinterpret_cast<uint16_t*>(xy);
    int start = sk_int_mod(xpos, width);
    int n = width - start;
    if (n > count) {
        n = count;
    }
    fill_sequential(xptr, start, n);
    xptr += n;
    count -= n;
 
    while (count >= width) {
        fill_sequential(xptr, 0, width);
        xptr += width;
        count -= width;
    }
 
    if (count > 0) {
        fill_sequential(xptr, 0, count);
    }
}

sk_int_mod()

static int sk_int_mod ( int  x, int  n  )

inlinestatic

Definition at line 305 of file SkBitmapProcState_matrixProcs.cpp.

                                           {
    SkASSERT(n > 0);
    if ((unsigned)x >= (unsigned)n) {
        if (x < 0) {
            x = n + ~(~x % n);
        } else {
            x = x % n;
        }
    }
    return x;
}

SK_USHIFT16()

static unsigned SK_USHIFT16 ( unsigned  x )

inlinestatic

Definition at line 254 of file SkBitmapProcState_matrixProcs.cpp.

                                               {
    return x >> 16;
}

Variable Documentation

ClampX_ClampY_Procs

const SkBitmapProcState::MatrixProc ClampX_ClampY_Procs[]

static

Initial value:

= {
    nofilter_scale <clamp, clamp, true>, filter_scale <clamp, clamp, extract_low_bits_clamp_clamp, true>,
    nofilter_affine<clamp, clamp>,       filter_affine<clamp, clamp, extract_low_bits_clamp_clamp>,
}

Definition at line 275 of file SkBitmapProcState_matrixProcs.cpp.

MirrorX_MirrorY_Procs

const SkBitmapProcState::MatrixProc MirrorX_MirrorY_Procs[]

static

Initial value:

= {
    nofilter_scale <mirror, mirror,  false>, filter_scale <mirror, mirror, extract_low_bits_general, false>,
    nofilter_affine<mirror, mirror>,         filter_affine<mirror, mirror, extract_low_bits_general>,
}

Definition at line 283 of file SkBitmapProcState_matrixProcs.cpp.

RepeatX_RepeatY_Procs

const SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs[]

static

Initial value:

= {
    nofilter_scale <repeat, repeat, false>, filter_scale <repeat, repeat, extract_low_bits_general, false>,
    nofilter_affine<repeat, repeat>,        filter_affine<repeat, repeat, extract_low_bits_general>
}

Definition at line 279 of file SkBitmapProcState_matrixProcs.cpp.