SkMaskBlurFilter.cpp File Reference

#include "src/core/SkMaskBlurFilter.h"
#include "include/core/SkColorPriv.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkVx.h"
#include "src/core/SkGaussFilter.h"
#include <cmath>
#include <climits>

Go to the source code of this file.

Typedefs
using	ToA8 = decltype(bw_to_a8)
using	fp88 = skvx::Vec< 8, uint16_t >
using	BlurX = decltype(blur_x_radius_1)
using	BlurY = decltype(blur_y_radius_1)

Functions
static void	bw_to_a8 (uint8_t *a8, const uint8_t *from, int width)
static void	lcd_to_a8 (uint8_t *a8, const uint8_t *from, int width)
static void	argb32_to_a8 (uint8_t *a8, const uint8_t *from, int width)
static fp88	load (const uint8_t *from, int width, ToA8 *toA8)
static void	store (uint8_t *to, const fp88 &v, int width)
static void	blur_x_radius_1 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &, const fp88 &, const fp88 &, fp88 *d0, fp88 *d8)
static void	blur_x_radius_2 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &, const fp88 &, fp88 *d0, fp88 *d8)
static void	blur_x_radius_3 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &, fp88 *d0, fp88 *d8)
static void	blur_x_radius_4 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &g4, fp88 *d0, fp88 *d8)
static void	blur_row (BlurX blur, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &g4, const uint8_t *src, int srcW, uint8_t *dst, int dstW)
static void	blur_x_rect (BlurX blur, uint16_t *gauss, const uint8_t *src, size_t srcStride, int srcW, uint8_t *dst, size_t dstStride, int dstW, int dstH)
static void	direct_blur_x (int radius, uint16_t *gauss, const uint8_t *src, size_t srcStride, int srcW, uint8_t *dst, size_t dstStride, int dstW, int dstH)
static fp88	blur_y_radius_1 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &, const fp88 &, const fp88 &, fp88 *d01, fp88 *d12, fp88 *, fp88 *, fp88 *, fp88 *, fp88 *, fp88 *)
static fp88	blur_y_radius_2 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &, const fp88 &, fp88 *d01, fp88 *d12, fp88 *d23, fp88 *d34, fp88 *, fp88 *, fp88 *, fp88 *)
static fp88	blur_y_radius_3 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &, fp88 *d01, fp88 *d12, fp88 *d23, fp88 *d34, fp88 *d45, fp88 *d56, fp88 *, fp88 *)
static fp88	blur_y_radius_4 (const fp88 &s0, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &g4, fp88 *d01, fp88 *d12, fp88 *d23, fp88 *d34, fp88 *d45, fp88 *d56, fp88 *d67, fp88 *d78)
static void	blur_column (ToA8 toA8, BlurY blur, int radius, int width, const fp88 &g0, const fp88 &g1, const fp88 &g2, const fp88 &g3, const fp88 &g4, const uint8_t *src, size_t srcRB, int srcH, uint8_t *dst, size_t dstRB)
static void	blur_y_rect (ToA8 toA8, const int strideOf8, BlurY blur, int radius, uint16_t *gauss, const uint8_t *src, size_t srcRB, int srcW, int srcH, uint8_t *dst, size_t dstRB)
static void	direct_blur_y (ToA8 toA8, const int strideOf8, int radius, uint16_t *gauss, const uint8_t *src, size_t srcRB, int srcW, int srcH, uint8_t *dst, size_t dstRB)
static SkIPoint	small_blur (double sigmaX, double sigmaY, const SkMask &src, SkMaskBuilder *dst)

Variables
static constexpr uint16_t	_____ = 0u
static constexpr uint16_t	kHalf = 0x80u

Typedef Documentation

BlurX

using BlurX = decltype(blur_x_radius_1)

Definition at line 545 of file SkMaskBlurFilter.cpp.

BlurY

using BlurY = decltype(blur_y_radius_1)

Definition at line 761 of file SkMaskBlurFilter.cpp.

fp88

using fp88 = skvx::Vec<8, uint16_t>

Definition at line 297 of file SkMaskBlurFilter.cpp.

ToA8

using ToA8 = decltype(bw_to_a8)

Definition at line 295 of file SkMaskBlurFilter.cpp.

Function Documentation

argb32_to_a8()

static void argb32_to_a8 ( uint8_t *  a8, const uint8_t *  from, int  width  )

static

Definition at line 288 of file SkMaskBlurFilter.cpp.

                                                                      {
    SkASSERT(0 < width && width <= 8);
    for (int i = 0; i < width; ++i) {
        uint32_t rgba = reinterpret_cast<const uint32_t*>(from)[i];
        a8[i] = SkGetPackedA32(rgba);
    }
}

blur_column()

static void blur_column ( ToA8  toA8, BlurY  blur, int  radius, int  width, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  g4, const uint8_t *  src, size_t  srcRB, int  srcH, uint8_t *  dst, size_t  dstRB  )

static

Definition at line 764 of file SkMaskBlurFilter.cpp.

                                    {
    fp88 d01(kHalf), d12(kHalf), d23(kHalf), d34(kHalf),
         d45(kHalf), d56(kHalf), d67(kHalf), d78(kHalf);
 
    auto flush = [&](uint8_t* to, const fp88& v0, const fp88& v1) {
        store(to, v0, width);
        to += dstRB;
        store(to, v1, width);
        return to + dstRB;
    };
 
    for (int y = 0; y < srcH; y += 1) {
        auto s = load(src, width, toA8);
        auto b = blur(s,
                      g0, g1, g2, g3, g4,
                      &d01, &d12, &d23, &d34, &d45, &d56, &d67, &d78);
        store(dst, b, width);
        src += srcRB;
        dst += dstRB;
    }
 
    if (radius >= 1) {
        dst = flush(dst, d01, d12);
    }
    if (radius >= 2) {
        dst = flush(dst, d23, d34);
    }
    if (radius >= 3) {
        dst = flush(dst, d45, d56);
    }
    if (radius >= 4) {
              flush(dst, d67, d78);
    }
}

blur_row()

static void blur_row ( BlurX  blur, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  g4, const uint8_t *  src, int  srcW, uint8_t *  dst, int  dstW  )

static

Definition at line 548 of file SkMaskBlurFilter.cpp.

                                      {
    // Clear the buffer to handle summing wider than source.
    fp88 d0(kHalf), d8(kHalf);
 
    // Go by multiples of 8 in src.
    int x = 0;
    for (; x <= srcW - 8; x += 8) {
        blur(load(src, 8, nullptr), g0, g1, g2, g3, g4, &d0, &d8);
 
        store(dst, d0, 8);
 
        d0 = d8;
        d8 = fp88(kHalf);
 
        src += 8;
        dst += 8;
    }
 
    // There are src values left, but the remainder of src values is not a multiple of 8.
    int srcTail = srcW - x;
    if (srcTail > 0) {
 
        blur(load(src, srcTail, nullptr), g0, g1, g2, g3, g4, &d0, &d8);
 
        int dstTail = std::min(8, dstW - x);
        store(dst, d0, dstTail);
 
        d0 = d8;
        dst += dstTail;
        x += dstTail;
    }
 
    // There are dst mask values to complete.
    int dstTail = dstW - x;
    if (dstTail > 0) {
        store(dst, d0, dstTail);
    }
}

blur_x_radius_1()

static void blur_x_radius_1 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  , const fp88 &  , const fp88 &  , fp88 *  d0, fp88 *  d8  )

static

Definition at line 414 of file SkMaskBlurFilter.cpp.

                            {
 
    auto v1 = mulhi(s0, g1);
    auto v0 = mulhi(s0, g0);
 
    // D[n..n+7]  += S[n..n+7] * G[1]
    *d0 += v1;
 
    //D[n..n+8]  += {0, S[n..n+7] * G[0]}
    *d0 += fp88{_____, v0[0], v0[1], v0[2], v0[3], v0[4], v0[5], v0[6]};
    *d8 += fp88{v0[7], _____, _____, _____, _____, _____, _____, _____};
 
    // D[n..n+9]  += {0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5]};
    *d8 += fp88{v1[6], v1[7], _____, _____, _____, _____, _____, _____};
 
}

blur_x_radius_2()

static void blur_x_radius_2 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  , const fp88 &  , fp88 *  d0, fp88 *  d8  )

static

Definition at line 435 of file SkMaskBlurFilter.cpp.

                            {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
 
    // D[n..n+7]  += S[n..n+7] * G[2]
    *d0 += v2;
 
    // D[n..n+8]  += {0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5], v1[6]};
    *d8 += fp88{v1[7], _____, _____, _____, _____, _____, _____, _____};
 
    // D[n..n+9]  += {0, 0, S[n..n+7] * G[0]}
    *d0 += fp88{_____, _____, v0[0], v0[1], v0[2], v0[3], v0[4], v0[5]};
    *d8 += fp88{v0[6], v0[7], _____, _____, _____, _____, _____, _____};
 
    // D[n..n+10]  += {0, 0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, _____, v1[0], v1[1], v1[2], v1[3], v1[4]};
    *d8 += fp88{v1[5], v1[6], v1[7], _____, _____, _____, _____, _____};
 
    // D[n..n+11]  += {0, 0, 0, 0, S[n..n+7] * G[2]}
    *d0 += fp88{_____, _____, _____, _____, v2[0], v2[1], v2[2], v2[3]};
    *d8 += fp88{v2[4], v2[5], v2[6], v2[7], _____, _____, _____, _____};
}

blur_x_radius_3()

static void blur_x_radius_3 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  , fp88 *  d0, fp88 *  d8  )

static

Definition at line 463 of file SkMaskBlurFilter.cpp.

                            {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
    auto v3 = mulhi(s0, g3);
 
    // D[n..n+7]  += S[n..n+7] * G[3]
    *d0 += v3;
 
    // D[n..n+8]  += {0, S[n..n+7] * G[2]}
    *d0 += fp88{_____, v2[0], v2[1], v2[2], v2[3], v2[4], v2[5], v2[6]};
    *d8 += fp88{v2[7], _____, _____, _____, _____, _____, _____, _____};
 
    // D[n..n+9]  += {0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5]};
    *d8 += fp88{v1[6], v1[7], _____, _____, _____, _____, _____, _____};
 
    // D[n..n+10]  += {0, 0, 0, S[n..n+7] * G[0]}
    *d0 += fp88{_____, _____, _____, v0[0], v0[1], v0[2], v0[3], v0[4]};
    *d8 += fp88{v0[5], v0[6], v0[7], _____, _____, _____, _____, _____};
 
    // D[n..n+11]  += {0, 0, 0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, _____, _____, v1[0], v1[1], v1[2], v1[3]};
    *d8 += fp88{v1[4], v1[5], v1[6], v1[7], _____, _____, _____, _____};
 
    // D[n..n+12]  += {0, 0, 0, 0, 0, S[n..n+7] * G[2]}
    *d0 += fp88{_____, _____, _____, _____, _____, v2[0], v2[1], v2[2]};
    *d8 += fp88{v2[3], v2[4], v2[5], v2[6], v2[7], _____, _____, _____};
 
    // D[n..n+13]  += {0, 0, 0, 0, 0, 0, S[n..n+7] * G[3]}
    *d0 += fp88{_____, _____, _____, _____, _____, _____, v3[0], v3[1]};
    *d8 += fp88{v3[2], v3[3], v3[4], v3[5], v3[6], v3[7], _____, _____};
}

blur_x_radius_4()

static void blur_x_radius_4 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  g4, fp88 *  d0, fp88 *  d8  )

static

Definition at line 500 of file SkMaskBlurFilter.cpp.

                            {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
    auto v3 = mulhi(s0, g3);
    auto v4 = mulhi(s0, g4);
 
    // D[n..n+7]  += S[n..n+7] * G[4]
    *d0 += v4;
 
    // D[n..n+8]  += {0, S[n..n+7] * G[3]}
    *d0 += fp88{_____, v3[0], v3[1], v3[2], v3[3], v3[4], v3[5], v3[6]};
    *d8 += fp88{v3[7], _____, _____, _____, _____, _____, _____, _____};
 
    // D[n..n+9]  += {0, 0, S[n..n+7] * G[2]}
    *d0 += fp88{_____, _____, v2[0], v2[1], v2[2], v2[3], v2[4], v2[5]};
    *d8 += fp88{v2[6], v2[7], _____, _____, _____, _____, _____, _____};
 
    // D[n..n+10]  += {0, 0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, _____, v1[0], v1[1], v1[2], v1[3], v1[4]};
    *d8 += fp88{v1[5], v1[6], v1[7], _____, _____, _____, _____, _____};
 
    // D[n..n+11]  += {0, 0, 0, 0, S[n..n+7] * G[0]}
    *d0 += fp88{_____, _____, _____, _____, v0[0], v0[1], v0[2], v0[3]};
    *d8 += fp88{v0[4], v0[5], v0[6], v0[7], _____, _____, _____, _____};
 
    // D[n..n+12]  += {0, 0, 0, 0, 0, S[n..n+7] * G[1]}
    *d0 += fp88{_____, _____, _____, _____, _____, v1[0], v1[1], v1[2]};
    *d8 += fp88{v1[3], v1[4], v1[5], v1[6], v1[7], _____, _____, _____};
 
    // D[n..n+13]  += {0, 0, 0, 0, 0, 0, S[n..n+7] * G[2]}
    *d0 += fp88{_____, _____, _____, _____, _____, _____, v2[0], v2[1]};
    *d8 += fp88{v2[2], v2[3], v2[4], v2[5], v2[6], v2[7], _____, _____};
 
    // D[n..n+14]  += {0, 0, 0, 0, 0, 0, 0, S[n..n+7] * G[3]}
    *d0 += fp88{_____, _____, _____, _____, _____, _____, _____, v3[0]};
    *d8 += fp88{v3[1], v3[2], v3[3], v3[4], v3[5], v3[6], v3[7], _____};
 
    // D[n..n+15]  += {0, 0, 0, 0, 0, 0, 0, 0, S[n..n+7] * G[4]}
    *d8 += v4;
}

blur_x_rect()

static void blur_x_rect ( BlurX  blur, uint16_t *  gauss, const uint8_t *  src, size_t  srcStride, int  srcW, uint8_t *  dst, size_t  dstStride, int  dstW, int  dstH  )

static

Definition at line 592 of file SkMaskBlurFilter.cpp.

                                                                            {
 
    fp88 g0(gauss[0]),
         g1(gauss[1]),
         g2(gauss[2]),
         g3(gauss[3]),
         g4(gauss[4]);
 
    // Blur *ALL* the rows.
    for (int y = 0; y < dstH; y++) {
        blur_row(blur, g0, g1, g2, g3, g4, src, srcW, dst, dstW);
        src += srcStride;
        dst += dstStride;
    }
}

blur_y_radius_1()

static fp88 blur_y_radius_1 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  , const fp88 &  , const fp88 &  , fp88 *  d01, fp88 *  d12, fp88 *  , fp88 *  , fp88 *  , fp88 *  , fp88 *  , fp88 *    )

static

Definition at line 687 of file SkMaskBlurFilter.cpp.

                                                                        {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
 
    fp88 answer = *d01 + v1;
           *d01 = *d12 + v0;
           *d12 =        v1 + kHalf;
 
    return answer;
}

blur_y_radius_2()

static fp88 blur_y_radius_2 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  , const fp88 &  , fp88 *  d01, fp88 *  d12, fp88 *  d23, fp88 *  d34, fp88 *  , fp88 *  , fp88 *  , fp88 *    )

static

Definition at line 701 of file SkMaskBlurFilter.cpp.

                                                                                {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
 
    fp88 answer = *d01 + v2;
           *d01 = *d12 + v1;
           *d12 = *d23 + v0;
           *d23 = *d34 + v1;
           *d34 =        v2 + kHalf;
 
    return answer;
}

blur_y_radius_3()

static fp88 blur_y_radius_3 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  , fp88 *  d01, fp88 *  d12, fp88 *  d23, fp88 *  d34, fp88 *  d45, fp88 *  d56, fp88 *  , fp88 *    )

static

Definition at line 718 of file SkMaskBlurFilter.cpp.

                                                                                        {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
    auto v3 = mulhi(s0, g3);
 
    fp88 answer = *d01 + v3;
           *d01 = *d12 + v2;
           *d12 = *d23 + v1;
           *d23 = *d34 + v0;
           *d34 = *d45 + v1;
           *d45 = *d56 + v2;
           *d56 =        v3 + kHalf;
 
    return answer;
}

blur_y_radius_4()

static fp88 blur_y_radius_4 ( const fp88 &  s0, const fp88 &  g0, const fp88 &  g1, const fp88 &  g2, const fp88 &  g3, const fp88 &  g4, fp88 *  d01, fp88 *  d12, fp88 *  d23, fp88 *  d34, fp88 *  d45, fp88 *  d56, fp88 *  d67, fp88 *  d78  )

static

Definition at line 738 of file SkMaskBlurFilter.cpp.

                                                                                            {
    auto v0 = mulhi(s0, g0);
    auto v1 = mulhi(s0, g1);
    auto v2 = mulhi(s0, g2);
    auto v3 = mulhi(s0, g3);
    auto v4 = mulhi(s0, g4);
 
    fp88 answer = *d01 + v4;
           *d01 = *d12 + v3;
           *d12 = *d23 + v2;
           *d23 = *d34 + v1;
           *d34 = *d45 + v0;
           *d45 = *d56 + v1;
           *d56 = *d67 + v2;
           *d67 = *d78 + v3;
           *d78 =        v4 + kHalf;
 
    return answer;
}

blur_y_rect()

static void blur_y_rect ( ToA8  toA8, const int  strideOf8, BlurY  blur, int  radius, uint16_t *  gauss, const uint8_t *  src, size_t  srcRB, int  srcW, int  srcH, uint8_t *  dst, size_t  dstRB  )

static

Definition at line 805 of file SkMaskBlurFilter.cpp.

                                                    {
 
    fp88 g0(gauss[0]),
         g1(gauss[1]),
         g2(gauss[2]),
         g3(gauss[3]),
         g4(gauss[4]);
 
    int x = 0;
    for (; x <= srcW - 8; x += 8) {
        blur_column(toA8, blur, radius, 8,
                    g0, g1, g2, g3, g4,
                    src, srcRB, srcH,
                    dst, dstRB);
        src += strideOf8;
        dst += 8;
    }
 
    int xTail = srcW - x;
    if (xTail > 0) {
        blur_column(toA8, blur, radius, xTail,
                    g0, g1, g2, g3, g4,
                    src, srcRB, srcH,
                    dst, dstRB);
    }
}

bw_to_a8()

static void bw_to_a8 ( uint8_t *  a8, const uint8_t *  from, int  width  )

static

Definition at line 268 of file SkMaskBlurFilter.cpp.

                                                                  {
    SkASSERT(0 < width && width <= 8);
 
    uint8_t masks = *from;
    for (int i = 0; i < width; ++i) {
        a8[i] = (masks >> (7 - i)) & 1 ? 0xFF
                                       : 0x00;
    }
}

direct_blur_x()

static void direct_blur_x ( int  radius, uint16_t *  gauss, const uint8_t *  src, size_t  srcStride, int  srcW, uint8_t *  dst, size_t  dstStride, int  dstW, int  dstH  )

static

Definition at line 611 of file SkMaskBlurFilter.cpp.

                                                                              {
 
    switch (radius) {
        case 1:
            blur_x_rect(blur_x_radius_1, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH);
            break;
 
        case 2:
            blur_x_rect(blur_x_radius_2, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH);
            break;
 
        case 3:
            blur_x_rect(blur_x_radius_3, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH);
            break;
 
        case 4:
            blur_x_rect(blur_x_radius_4, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH);
            break;
 
        default:
            SkASSERTF(false, "The radius %d is not handled\n", radius);
    }
}

direct_blur_y()

static void direct_blur_y ( ToA8  toA8, const int  strideOf8, int  radius, uint16_t *  gauss, const uint8_t *  src, size_t  srcRB, int  srcW, int  srcH, uint8_t *  dst, size_t  dstRB  )

static

Definition at line 835 of file SkMaskBlurFilter.cpp.

                                                      {
 
    switch (radius) {
        case 1:
            blur_y_rect(toA8, strideOf8, blur_y_radius_1, 1, gauss,
                        src, srcRB, srcW, srcH,
                        dst, dstRB);
            break;
 
        case 2:
            blur_y_rect(toA8, strideOf8, blur_y_radius_2, 2, gauss,
                        src, srcRB, srcW, srcH,
                        dst, dstRB);
            break;
 
        case 3:
            blur_y_rect(toA8, strideOf8, blur_y_radius_3, 3, gauss,
                        src, srcRB, srcW, srcH,
                        dst, dstRB);
            break;
 
        case 4:
            blur_y_rect(toA8, strideOf8, blur_y_radius_4, 4, gauss,
                        src, srcRB, srcW, srcH,
                        dst, dstRB);
            break;
 
        default:
            SkASSERTF(false, "The radius %d is not handled\n", radius);
    }
}

lcd_to_a8()

static void lcd_to_a8 ( uint8_t *  a8, const uint8_t *  from, int  width  )

static

Definition at line 277 of file SkMaskBlurFilter.cpp.

                                                                   {
    SkASSERT(0 < width && width <= 8);
 
    for (int i = 0; i < width; ++i) {
        unsigned rgb = reinterpret_cast<const uint16_t*>(from)[i],
                   r = SkPacked16ToR32(rgb),
                   g = SkPacked16ToG32(rgb),
                   b = SkPacked16ToB32(rgb);
        a8[i] = (r + g + b) / 3;
    }
}

load()

static fp88 load ( const uint8_t *  from, int  width, ToA8 *  toA8  )

static

Definition at line 299 of file SkMaskBlurFilter.cpp.

                                                             {
    // Our fast path is a full 8-byte load of A8.
    // So we'll conditionally handle the two slow paths using tmp:
    //    - if we have a function to convert another mask to A8, use it;
    //    - if not but we have less than 8 bytes to load, load them one at a time.
    uint8_t tmp[8] = {0,0,0,0, 0,0,0,0};
    if (toA8) {
        toA8(tmp, from, width);
        from = tmp;
    } else if (width < 8) {
        for (int i = 0; i < width; ++i) {
            tmp[i] = from[i];
        }
        from = tmp;
    }
 
    // Load A8 and convert to 8.8 fixed-point.
    return skvx::cast<uint16_t>(skvx::byte8::Load(from)) << 8;
}

small_blur()

static SkIPoint small_blur ( double  sigmaX, double  sigmaY, const SkMask &  src, SkMaskBuilder *  dst  )

static

Definition at line 870 of file SkMaskBlurFilter.cpp.

                                                                                                {
    SkASSERT(sigmaX == sigmaY); // TODO
    SkASSERT(0.01 <= sigmaX && sigmaX < 2);
    SkASSERT(0.01 <= sigmaY && sigmaY < 2);
 
    SkGaussFilter filterX{sigmaX},
                  filterY{sigmaY};
 
    int radiusX = filterX.radius(),
        radiusY = filterY.radius();
 
    SkASSERT(radiusX <= 4 && radiusY <= 4);
 
    auto prepareGauss = [](const SkGaussFilter& filter, uint16_t* factors) {
        int i = 0;
        for (double d : filter) {
            factors[i++] = static_cast<uint16_t>(round(d * (1 << 16)));
        }
    };
 
    uint16_t gaussFactorsX[SkGaussFilter::kGaussArrayMax],
             gaussFactorsY[SkGaussFilter::kGaussArrayMax];
 
    prepareGauss(filterX, gaussFactorsX);
    prepareGauss(filterY, gaussFactorsY);
 
    *dst = SkMaskBuilder::PrepareDestination(radiusX, radiusY, src);
    if (src.fImage == nullptr) {
        return {SkTo<int32_t>(radiusX), SkTo<int32_t>(radiusY)};
    }
    if (dst->fImage == nullptr) {
        dst->bounds().setEmpty();
        return {0, 0};
    }
 
    int srcW = src.fBounds.width(),
        srcH = src.fBounds.height();
 
    int dstW = dst->fBounds.width(),
        dstH = dst->fBounds.height();
 
    size_t srcRB = src.fRowBytes,
           dstRB = dst->fRowBytes;
 
    //TODO: handle bluring in only one direction.
 
    // Blur vertically and copy to destination.
    switch (src.fFormat) {
        case SkMask::kBW_Format:
            direct_blur_y(bw_to_a8, 1,
                          radiusY, gaussFactorsY,
                          src.fImage, srcRB, srcW, srcH,
                          dst->image() + radiusX, dstRB);
            break;
        case SkMask::kA8_Format:
            direct_blur_y(nullptr, 8,
                          radiusY, gaussFactorsY,
                          src.fImage, srcRB, srcW, srcH,
                          dst->image() + radiusX, dstRB);
            break;
        case SkMask::kARGB32_Format:
            direct_blur_y(argb32_to_a8, 32,
                          radiusY, gaussFactorsY,
                          src.fImage, srcRB, srcW, srcH,
                          dst->image() + radiusX, dstRB);
            break;
        case SkMask::kLCD16_Format:
            direct_blur_y(lcd_to_a8, 16, radiusY, gaussFactorsY,
                          src.fImage, srcRB, srcW, srcH,
                          dst->image() + radiusX, dstRB);
            break;
        default:
            SK_ABORT("Unhandled format.");
    }
 
    // Blur horizontally in place.
    direct_blur_x(radiusX, gaussFactorsX,
                  dst->fImage + radiusX,  dstRB, srcW,
                  dst->image(),           dstRB, dstW, dstH);
 
    return {radiusX, radiusY};
}

store()

static void store ( uint8_t *  to, const fp88 &  v, int  width  )

static

Definition at line 319 of file SkMaskBlurFilter.cpp.

                                                         {
    skvx::byte8 b = skvx::cast<uint8_t>(v >> 8);
    if (width == 8) {
        b.store(to);
    } else {
        uint8_t buffer[8];
        b.store(buffer);
        for (int i = 0; i < width; i++) {
            to[i] = buffer[i];
        }
    }
}

Variable Documentation

_____

constexpr uint16_t _____ = 0u

staticconstexpr

Definition at line 332 of file SkMaskBlurFilter.cpp.

kHalf

constexpr uint16_t kHalf = 0x80u

staticconstexpr

Definition at line 333 of file SkMaskBlurFilter.cpp.