SkBitmapProcState.cpp File Reference

#include "src/core/SkBitmapProcState.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkColorType.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkTileMode.h"
#include "include/private/base/SkMacros.h"
#include "include/private/base/SkTPin.h"
#include "src/core/SkMemset.h"
#include "src/core/SkMipmapAccessor.h"
#include <algorithm>
#include <cstring>
#include <tuple>

Go to the source code of this file.

Functions
static void	Clamp_S32_opaque_D32_nofilter_DX_shaderproc (const void *sIn, int x, int y, SkPMColor *dst, int count)
static void	S32_alpha_D32_nofilter_DX (const SkBitmapProcState &s, const uint32_t *xy, int count, SkPMColor *colors)
static void	S32_alpha_D32_nofilter_DXDY (const SkBitmapProcState &s, const uint32_t *xy, int count, SkPMColor *colors)
static bool	matrix_only_scale_translate (const SkMatrix &m)
static bool	just_trans_general (const SkMatrix &matrix)
static bool	just_trans_integral (const SkMatrix &m)
static bool	valid_for_filtering (unsigned dimension)
static void	Clamp_S32_D32_nofilter_trans_shaderproc (const void *sIn, int x, int y, SkPMColor *colors, int count)
static int	sk_int_mod (int x, int n)
static int	sk_int_mirror (int x, int n)
static void	Repeat_S32_D32_nofilter_trans_shaderproc (const void *sIn, int x, int y, SkPMColor *colors, int count)
static void	filter_32_alpha (unsigned t, SkPMColor color0, SkPMColor color1, SkPMColor *dstColor, unsigned alphaScale)
static void	S32_D32_constX_shaderproc (const void *sIn, int x, int y, SkPMColor *colors, int count)
static void	DoNothing_shaderproc (const void *, int x, int y, SkPMColor *colors, int count)

Function Documentation

Clamp_S32_D32_nofilter_trans_shaderproc()

static void Clamp_S32_D32_nofilter_trans_shaderproc ( const void *  sIn, int  x, int  y, SkPMColor *  colors, int  count  )

static

Definition at line 302 of file SkBitmapProcState.cpp.

                                                               {
    const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
    SkASSERT(s.fInvMatrix.isTranslate());
    SkASSERT(count > 0 && colors != nullptr);
    SkASSERT(!s.fBilerp);
 
    const int maxX = s.fPixmap.width() - 1;
    const int maxY = s.fPixmap.height() - 1;
    int ix = s.fFilterOneX + x;
    int iy = SkTPin(s.fFilterOneY + y, 0, maxY);
    const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
    // clamp to the left
    if (ix < 0) {
        int n = std::min(-ix, count);
        SkOpts::memset32(colors, row[0], n);
        count -= n;
        if (0 == count) {
            return;
        }
        colors += n;
        SkASSERT(-ix == n);
        ix = 0;
    }
    // copy the middle
    if (ix <= maxX) {
        int n = std::min(maxX - ix + 1, count);
        memcpy(colors, row + ix, n * sizeof(SkPMColor));
        count -= n;
        if (0 == count) {
            return;
        }
        colors += n;
    }
    SkASSERT(count > 0);
    // clamp to the right
    SkOpts::memset32(colors, row[maxX], count);
}

Clamp_S32_opaque_D32_nofilter_DX_shaderproc()

static void Clamp_S32_opaque_D32_nofilter_DX_shaderproc ( const void *  sIn, int  x, int  y, SkPMColor *  dst, int  count  )

static

Definition at line 33 of file SkBitmapProcState.cpp.

                                                                                   {
    const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
    SkASSERT(s.fInvMatrix.isScaleTranslate());
    SkASSERT(s.fAlphaScale == 256);
 
    const unsigned maxX = s.fPixmap.width() - 1;
    SkFractionalInt fx;
    int dstY;
    {
        const SkBitmapProcStateAutoMapper mapper(s, x, y);
        const unsigned maxY = s.fPixmap.height() - 1;
        dstY = SkTPin<int>(mapper.intY(), 0, maxY);
        fx = mapper.fractionalIntX();
    }
 
    const SkPMColor* src = s.fPixmap.addr32(0, dstY);
    const SkFractionalInt dx = s.fInvSxFractionalInt;
 
    // Check if we're safely inside [0...maxX] so no need to clamp each computed index.
    //
    if ((uint64_t)SkFractionalIntToInt(fx) <= maxX &&
        (uint64_t)SkFractionalIntToInt(fx + dx * (count - 1)) <= maxX)
    {
        int count4 = count >> 2;
        for (int i = 0; i < count4; ++i) {
            SkPMColor src0 = src[SkFractionalIntToInt(fx)]; fx += dx;
            SkPMColor src1 = src[SkFractionalIntToInt(fx)]; fx += dx;
            SkPMColor src2 = src[SkFractionalIntToInt(fx)]; fx += dx;
            SkPMColor src3 = src[SkFractionalIntToInt(fx)]; fx += dx;
            dst[0] = src0;
            dst[1] = src1;
            dst[2] = src2;
            dst[3] = src3;
            dst += 4;
        }
        for (int i = (count4 << 2); i < count; ++i) {
            unsigned index = SkFractionalIntToInt(fx);
            SkASSERT(index <= maxX);
            *dst++ = src[index];
            fx += dx;
        }
    } else {
        for (int i = 0; i < count; ++i) {
            dst[i] = src[SkTPin<int>(SkFractionalIntToInt(fx), 0, maxX)];
            fx += dx;
        }
    }
}

DoNothing_shaderproc()

static void DoNothing_shaderproc ( const void *  , int  x, int  y, SkPMColor *  colors, int  count  )

static

Definition at line 519 of file SkBitmapProcState.cpp.

                                                               {
    // if we get called, the matrix is too tricky, so we just draw nothing
    SkOpts::memset32(colors, 0, count);
}

filter_32_alpha()

static void filter_32_alpha ( unsigned  t, SkPMColor  color0, SkPMColor  color1, SkPMColor *  dstColor, unsigned  alphaScale  )

inlinestatic

Definition at line 392 of file SkBitmapProcState.cpp.

                                                        {
    SkASSERT((unsigned)t <= 0xF);
    SkASSERT(alphaScale <= 256);
 
    const uint32_t mask = 0xFF00FF;
 
    int scale = 256 - 16*t;
    uint32_t lo = (color0 & mask) * scale;
    uint32_t hi = ((color0 >> 8) & mask) * scale;
 
    scale = 16*t;
    lo += (color1 & mask) * scale;
    hi += ((color1 >> 8) & mask) * scale;
 
    // TODO: if (alphaScale < 256) ...
    lo = ((lo >> 8) & mask) * alphaScale;
    hi = ((hi >> 8) & mask) * alphaScale;
 
    *dstColor = ((lo >> 8) & mask) | (hi & ~mask);
}

just_trans_general()

static bool just_trans_general ( const SkMatrix &  matrix )

static

For the purposes of drawing bitmaps, if a matrix is "almost" translate go ahead and treat it as if it were, so that subsequent code can go fast.

Definition at line 162 of file SkBitmapProcState.cpp.

                                                       {
    SkASSERT(matrix_only_scale_translate(matrix));
 
    const SkScalar tol = SK_Scalar1 / 32768;
 
    return SkScalarNearlyZero(matrix[SkMatrix::kMScaleX] - SK_Scalar1, tol)
        && SkScalarNearlyZero(matrix[SkMatrix::kMScaleY] - SK_Scalar1, tol);
}

just_trans_integral()

static bool just_trans_integral ( const SkMatrix &  m )

static

Determine if the matrix can be treated as integral-only-translate, for the purpose of filtering.

Definition at line 175 of file SkBitmapProcState.cpp.

                                                   {
    static constexpr SkScalar tol = SK_Scalar1 / 256;
 
    return m.getType() <= SkMatrix::kTranslate_Mask
        && SkScalarNearlyEqual(m.getTranslateX(), SkScalarRoundToScalar(m.getTranslateX()), tol)
        && SkScalarNearlyEqual(m.getTranslateY(), SkScalarRoundToScalar(m.getTranslateY()), tol);
}

matrix_only_scale_translate()

static bool matrix_only_scale_translate ( const SkMatrix &  m )

static

Definition at line 154 of file SkBitmapProcState.cpp.

                                                           {
    return (m.getType() & ~SkMatrix::kTranslate_Mask) == SkMatrix::kScale_Mask;
}

Repeat_S32_D32_nofilter_trans_shaderproc()

static void Repeat_S32_D32_nofilter_trans_shaderproc ( const void *  sIn, int  x, int  y, SkPMColor *  colors, int  count  )

static

Definition at line 364 of file SkBitmapProcState.cpp.

                                                                {
    const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
    SkASSERT(s.fInvMatrix.isTranslate());
    SkASSERT(count > 0 && colors != nullptr);
    SkASSERT(!s.fBilerp);
 
    const int stopX = s.fPixmap.width();
    const int stopY = s.fPixmap.height();
    int ix = s.fFilterOneX + x;
    int iy = sk_int_mod(s.fFilterOneY + y, stopY);
    const SkPMColor* row = s.fPixmap.addr32(0, iy);
 
    ix = sk_int_mod(ix, stopX);
    for (;;) {
        int n = std::min(stopX - ix, count);
        memcpy(colors, row + ix, n * sizeof(SkPMColor));
        count -= n;
        if (0 == count) {
            return;
        }
        colors += n;
        ix = 0;
    }
}

S32_alpha_D32_nofilter_DX()

static void S32_alpha_D32_nofilter_DX ( const SkBitmapProcState &  s, const uint32_t *  xy, int  count, SkPMColor *  colors  )

static

Definition at line 83 of file SkBitmapProcState.cpp.

                                                                                        {
    SkASSERT(count > 0 && colors != nullptr);
    SkASSERT(s.fInvMatrix.isScaleTranslate());
    SkASSERT(!s.fBilerp);
    SkASSERT(4 == s.fPixmap.info().bytesPerPixel());
    SkASSERT(s.fAlphaScale <= 256);
 
    // xy is a 32-bit y-coordinate, followed by 16-bit x-coordinates.
    unsigned y = *xy++;
    SkASSERT(y < (unsigned)s.fPixmap.height());
 
    auto row = (const SkPMColor*)( (const char*)s.fPixmap.addr() + y * s.fPixmap.rowBytes() );
 
    if (1 == s.fPixmap.width()) {
        SkOpts::memset32(colors, SkAlphaMulQ(row[0], s.fAlphaScale), count);
        return;
    }
 
    // Step 4 xs == 2 uint32_t at a time.
    while (count >= 4) {
        uint32_t x01 = *xy++,
                 x23 = *xy++;
 
        SkPMColor p0 = row[UNPACK_PRIMARY_SHORT  (x01)];
        SkPMColor p1 = row[UNPACK_SECONDARY_SHORT(x01)];
        SkPMColor p2 = row[UNPACK_PRIMARY_SHORT  (x23)];
        SkPMColor p3 = row[UNPACK_SECONDARY_SHORT(x23)];
 
        *colors++ = SkAlphaMulQ(p0, s.fAlphaScale);
        *colors++ = SkAlphaMulQ(p1, s.fAlphaScale);
        *colors++ = SkAlphaMulQ(p2, s.fAlphaScale);
        *colors++ = SkAlphaMulQ(p3, s.fAlphaScale);
 
        count -= 4;
    }
 
    // Step 1 x == 1 uint16_t at a time.
    auto x = (const uint16_t*)xy;
    while (count --> 0) {
        *colors++ = SkAlphaMulQ(row[*x++], s.fAlphaScale);
    }
}

S32_alpha_D32_nofilter_DXDY()

static void S32_alpha_D32_nofilter_DXDY ( const SkBitmapProcState &  s, const uint32_t *  xy, int  count, SkPMColor *  colors  )

static

Definition at line 127 of file SkBitmapProcState.cpp.

                                                                                          {
    SkASSERT(count > 0 && colors != nullptr);
    SkASSERT(!s.fBilerp);
    SkASSERT(4 == s.fPixmap.info().bytesPerPixel());
    SkASSERT(s.fAlphaScale <= 256);
 
    auto src = (const char*)s.fPixmap.addr();
    size_t rb = s.fPixmap.rowBytes();
 
    while (count --> 0) {
        uint32_t XY = *xy++,
                 x  = XY & 0xffff,
                 y  = XY >> 16;
        SkASSERT(x < (unsigned)s.fPixmap.width ());
        SkASSERT(y < (unsigned)s.fPixmap.height());
        *colors++ = SkAlphaMulQ(((const SkPMColor*)(src + y*rb))[x], s.fAlphaScale);
    }
}

S32_D32_constX_shaderproc()

static void S32_D32_constX_shaderproc ( const void *  sIn, int  x, int  y, SkPMColor *  colors, int  count  )

static

Definition at line 417 of file SkBitmapProcState.cpp.

                                                 {
    const SkBitmapProcState& s = *static_cast<const SkBitmapProcState*>(sIn);
    SkASSERT(s.fInvMatrix.isScaleTranslate());
    SkASSERT(count > 0 && colors != nullptr);
    SkASSERT(1 == s.fPixmap.width());
 
    int iY0;
    int iY1   SK_INIT_TO_AVOID_WARNING;
    int iSubY SK_INIT_TO_AVOID_WARNING;
 
    if (s.fBilerp) {
        SkBitmapProcState::MatrixProc mproc = s.getMatrixProc();
        uint32_t xy[2];
 
        mproc(s, xy, 1, x, y);
 
        iY0 = xy[0] >> 18;
        iY1 = xy[0] & 0x3FFF;
        iSubY = (xy[0] >> 14) & 0xF;
    } else {
        int yTemp;
 
        if (s.fInvMatrix.isTranslate()) {
            yTemp = s.fFilterOneY + y;
        } else{
            const SkBitmapProcStateAutoMapper mapper(s, x, y);
 
            // When the matrix has a scale component the setup code in
            // chooseProcs multiples the inverse matrix by the inverse of the
            // bitmap's width and height. Since this method is going to do
            // its own tiling and sampling we need to undo that here.
            if (SkTileMode::kClamp != s.fTileModeX || SkTileMode::kClamp != s.fTileModeY) {
                yTemp = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
            } else {
                yTemp = mapper.intY();
            }
        }
 
        const int stopY = s.fPixmap.height();
        switch (s.fTileModeY) {
            case SkTileMode::kClamp:
                iY0 = SkTPin(yTemp, 0, stopY-1);
                break;
            case SkTileMode::kRepeat:
                iY0 = sk_int_mod(yTemp, stopY);
                break;
            case SkTileMode::kMirror:
            default:
                iY0 = sk_int_mirror(yTemp, stopY);
                break;
        }
 
#ifdef SK_DEBUG
        {
            const SkBitmapProcStateAutoMapper mapper(s, x, y);
            int iY2;
 
            if (!s.fInvMatrix.isTranslate() &&
                (SkTileMode::kClamp != s.fTileModeX || SkTileMode::kClamp != s.fTileModeY)) {
                iY2 = SkFractionalIntToInt(mapper.fractionalIntY() * s.fPixmap.height());
            } else {
                iY2 = mapper.intY();
            }
 
            switch (s.fTileModeY) {
            case SkTileMode::kClamp:
                iY2 = SkTPin(iY2, 0, stopY-1);
                break;
            case SkTileMode::kRepeat:
                iY2 = sk_int_mod(iY2, stopY);
                break;
            case SkTileMode::kMirror:
            default:
                iY2 = sk_int_mirror(iY2, stopY);
                break;
            }
 
            SkASSERT(iY0 == iY2);
        }
#endif
    }
 
    const SkPMColor* row0 = s.fPixmap.addr32(0, iY0);
    SkPMColor color;
 
    if (s.fBilerp) {
        const SkPMColor* row1 = s.fPixmap.addr32(0, iY1);
        filter_32_alpha(iSubY, *row0, *row1, &color, s.fAlphaScale);
    } else {
        if (s.fAlphaScale < 256) {
            color = SkAlphaMulQ(*row0, s.fAlphaScale);
        } else {
            color = *row0;
        }
    }
 
    SkOpts::memset32(colors, color, count);
}

sk_int_mirror()

static int sk_int_mirror ( int  x, int  n  )

inlinestatic

Definition at line 356 of file SkBitmapProcState.cpp.

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

sk_int_mod()

static int sk_int_mod ( int  x, int  n  )

inlinestatic

Definition at line 344 of file SkBitmapProcState.cpp.

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

valid_for_filtering()

static bool valid_for_filtering ( unsigned  dimension )

static

Definition at line 183 of file SkBitmapProcState.cpp.

                                                    {
    // for filtering, width and height must fit in 14bits, since we use steal
    // 2 bits from each to store our 4bit subpixel data
    return (dimension & ~0x3FFF) == 0;
}