| /* | |
| * Copyright 2008 Google Inc. | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| // The copyright below was added in 2009, but I see no record of moto contributions...? | |
| /* NEON optimized code (C) COPYRIGHT 2009 Motorola | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #include "SkBitmapProcState.h" | |
| #include "SkShader.h" | |
| #include "SkTo.h" | |
| #include "SkUtils.h" | |
| /* | |
| * The decal_ functions require that | |
| * 1. dx > 0 | |
| * 2. [fx, fx+dx, fx+2dx, fx+3dx, ... fx+(count-1)dx] are all <= maxX | |
| * | |
| * In addition, we use SkFractionalInt to keep more fractional precision than | |
| * just SkFixed, so we will abort the decal_ call if dx is very small, since | |
| * the decal_ function just operates on SkFixed. If that were changed, we could | |
| * skip the very_small test here. | |
| */ | |
| static inline bool can_truncate_to_fixed_for_decal(SkFixed fx, | |
| SkFixed dx, | |
| int count, unsigned max) { | |
| 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; | |
| } | |
| // When not filtering, we store 32-bit y, 16-bit x, 16-bit x, 16-bit x, ... | |
| // When filtering we write out 32-bit encodings, pairing 14.4 x0 with 14-bit x1. | |
| // The clamp routines may try to fall into one of these unclamped decal fast-paths. | |
| // (Only clamp works in the right coordinate space to check for decal.) | |
| static void decal_nofilter_scale(uint32_t dst[], SkFixed fx, SkFixed dx, int count) { | |
| for (; count >= 2; count -= 2) { | |
| *dst++ = pack_two_shorts( (fx + 0) >> 16, | |
| (fx + dx) >> 16); | |
| fx += dx+dx; | |
| } | |
| auto xx = (uint16_t*)dst; | |
| while (count --> 0) { | |
| *xx++ = SkToU16(fx >> 16); | |
| fx += dx; | |
| } | |
| } | |
| // A generic implementation for unfiltered scale+translate, templated on tiling method. | |
| template <unsigned (*tile)(SkFixed, int), bool tryDecal> | |
| static void nofilter_scale(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | | |
| SkMatrix::kScale_Mask)) == 0); | |
| // Write out our 32-bit y, and get our intial fx. | |
| SkFractionalInt fx; | |
| { | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| *xy++ = tile(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(tile(SkFractionalIntToFixed(fx ), maxX), | |
| tile(SkFractionalIntToFixed(fx + dx), maxX)); | |
| fx += dx+dx; | |
| } | |
| auto xx = (uint16_t*)xy; | |
| while (count --> 0) { | |
| *xx++ = tile(SkFractionalIntToFixed(fx), maxX); | |
| fx += dx; | |
| } | |
| } | |
| // Extract the high four fractional bits from fx, the lerp parameter when filtering. | |
| static unsigned extract_low_bits_clamp(SkFixed fx, int /*max*/) { | |
| // If we're already scaled up to by max like clamp/decal, | |
| // just grab the high four fractional bits. | |
| return (fx >> 12) & 0xf; | |
| } | |
| static unsigned extract_low_bits_repeat_mirror(SkFixed fx, int max) { | |
| // 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((fx & 0xffff) * (max+1), max); | |
| } | |
| template <unsigned (*tile)(SkFixed, int), unsigned (*extract_low_bits)(SkFixed, int), bool tryDecal> | |
| static void filter_scale(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | | |
| SkMatrix::kScale_Mask)) == 0); | |
| SkASSERT(s.fInvKy == 0); | |
| auto pack = [](SkFixed f, unsigned max, SkFixed one) { | |
| unsigned i = tile(f, max); | |
| i = (i << 4) | extract_low_bits(f, max); | |
| return (i << 14) | (tile((f + one), max)); | |
| }; | |
| const unsigned maxX = s.fPixmap.width() - 1; | |
| const SkFractionalInt dx = s.fInvSxFractionalInt; | |
| SkFractionalInt fx; | |
| { | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| const SkFixed fy = mapper.fixedY(); | |
| const unsigned maxY = s.fPixmap.height() - 1; | |
| // compute our two Y values up front | |
| *xy++ = pack(fy, 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) { | |
| SkFixed fixedFx = SkFractionalIntToFixed(fx); | |
| *xy++ = pack(fixedFx, maxX, s.fFilterOneX); | |
| fx += dx; | |
| } | |
| } | |
| // Helper to ensure that when we shift down, we do it w/o sign-extension | |
| // so the caller doesn't have to manually mask off the top 16 bits. | |
| static inline unsigned SK_USHIFT16(unsigned x) { | |
| return x >> 16; | |
| } | |
| static unsigned clamp(SkFixed fx, int max) { | |
| return SkClampMax(fx >> 16, max); | |
| } | |
| static unsigned repeat(SkFixed fx, int max) { | |
| SkASSERT(max < 65535); | |
| return SK_USHIFT16((unsigned)(fx & 0xFFFF) * (max + 1)); | |
| } | |
| static unsigned mirror(SkFixed fx, int max) { | |
| 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) ); | |
| } | |
| // Mirror/Mirror's always just portable code. | |
| static const SkBitmapProcState::MatrixProc MirrorX_MirrorY_Procs[] = { | |
| nofilter_scale<mirror, false>, | |
| filter_scale<mirror, extract_low_bits_repeat_mirror, false>, | |
| }; | |
| // Clamp/Clamp and Repeat/Repeat have NEON or portable implementations. | |
| #if defined(SK_ARM_HAS_NEON) | |
| #include <arm_neon.h> | |
| // TODO: this is a fine drop-in for decal_nofilter_scale() generally. | |
| static void decal_nofilter_scale_neon(uint32_t dst[], SkFixed fx, SkFixed dx, int count) { | |
| if (count >= 8) { | |
| // SkFixed is 16.16 fixed point | |
| SkFixed dx8 = dx * 8; | |
| int32x4_t vdx8 = vdupq_n_s32(dx8); | |
| // setup lbase and hbase | |
| int32x4_t lbase, hbase; | |
| lbase = vdupq_n_s32(fx); | |
| lbase = vsetq_lane_s32(fx + dx, lbase, 1); | |
| lbase = vsetq_lane_s32(fx + dx + dx, lbase, 2); | |
| lbase = vsetq_lane_s32(fx + dx + dx + dx, lbase, 3); | |
| hbase = lbase + vdupq_n_s32(4 * dx); | |
| do { | |
| // store the upper 16 bits | |
| vst1q_u32(dst, vreinterpretq_u32_s16( | |
| vuzpq_s16(vreinterpretq_s16_s32(lbase), vreinterpretq_s16_s32(hbase)).val[1] | |
| )); | |
| // on to the next group of 8 | |
| lbase += vdx8; | |
| hbase += vdx8; | |
| dst += 4; // we did 8 elements but the result is twice smaller | |
| count -= 8; | |
| fx += dx8; | |
| } while (count >= 8); | |
| } | |
| uint16_t* xx = (uint16_t*)dst; | |
| for (int i = count; i > 0; --i) { | |
| *xx++ = SkToU16(fx >> 16); fx += dx; | |
| } | |
| } | |
| static void decal_filter_scale_neon(uint32_t dst[], SkFixed fx, SkFixed dx, int count) { | |
| if (count >= 8) { | |
| SkFixed dx8 = dx * 8; | |
| int32x4_t vdx8 = vdupq_n_s32(dx8); | |
| int32x4_t wide_fx, wide_fx2; | |
| wide_fx = vdupq_n_s32(fx); | |
| wide_fx = vsetq_lane_s32(fx + dx, wide_fx, 1); | |
| wide_fx = vsetq_lane_s32(fx + dx + dx, wide_fx, 2); | |
| wide_fx = vsetq_lane_s32(fx + dx + dx + dx, wide_fx, 3); | |
| wide_fx2 = vaddq_s32(wide_fx, vdupq_n_s32(4 * dx)); | |
| while (count >= 8) { | |
| int32x4_t wide_out; | |
| int32x4_t wide_out2; | |
| wide_out = vshlq_n_s32(vshrq_n_s32(wide_fx, 12), 14); | |
| wide_out = wide_out | (vshrq_n_s32(wide_fx,16) + vdupq_n_s32(1)); | |
| wide_out2 = vshlq_n_s32(vshrq_n_s32(wide_fx2, 12), 14); | |
| wide_out2 = wide_out2 | (vshrq_n_s32(wide_fx2,16) + vdupq_n_s32(1)); | |
| vst1q_u32(dst, vreinterpretq_u32_s32(wide_out)); | |
| vst1q_u32(dst+4, vreinterpretq_u32_s32(wide_out2)); | |
| dst += 8; | |
| fx += dx8; | |
| wide_fx += vdx8; | |
| wide_fx2 += vdx8; | |
| count -= 8; | |
| } | |
| } | |
| if (count & 1) | |
| { | |
| SkASSERT((fx >> (16 + 14)) == 0); | |
| *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1); | |
| fx += dx; | |
| } | |
| while ((count -= 2) >= 0) | |
| { | |
| SkASSERT((fx >> (16 + 14)) == 0); | |
| *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1); | |
| fx += dx; | |
| *dst++ = (fx >> 12 << 14) | ((fx >> 16) + 1); | |
| fx += dx; | |
| } | |
| } | |
| static inline int16x8_t clamp8(int32x4_t low, int32x4_t high, unsigned max) { | |
| int16x8_t res; | |
| // get the hi 16s of all those 32s | |
| res = vuzpq_s16(vreinterpretq_s16_s32(low), vreinterpretq_s16_s32(high)).val[1]; | |
| // clamp | |
| res = vmaxq_s16(res, vdupq_n_s16(0)); | |
| res = vminq_s16(res, vdupq_n_s16(max)); | |
| return res; | |
| } | |
| static inline int32x4_t clamp4(int32x4_t f, unsigned max) { | |
| int32x4_t res; | |
| // get the hi 16s of all those 32s | |
| res = vshrq_n_s32(f, 16); | |
| // clamp | |
| res = vmaxq_s32(res, vdupq_n_s32(0)); | |
| res = vminq_s32(res, vdupq_n_s32(max)); | |
| return res; | |
| } | |
| static inline int32x4_t extract_low_bits_clamp4(int32x4_t fx, unsigned) { | |
| int32x4_t ret; | |
| ret = vshrq_n_s32(fx, 12); | |
| /* We don't need the mask below because the caller will | |
| * overwrite the non-masked bits | |
| */ | |
| //ret = vandq_s32(ret, vdupq_n_s32(0xF)); | |
| return ret; | |
| } | |
| static inline int16x8_t repeat8(int32x4_t low, int32x4_t high, unsigned max) { | |
| uint16x8_t res; | |
| uint32x4_t tmpl, tmph; | |
| // get the lower 16 bits | |
| res = vuzpq_u16(vreinterpretq_u16_s32(low), vreinterpretq_u16_s32(high)).val[0]; | |
| // bare multiplication, not SkFixedMul | |
| tmpl = vmull_u16(vget_low_u16(res), vdup_n_u16(max+1)); | |
| tmph = vmull_u16(vget_high_u16(res), vdup_n_u16(max+1)); | |
| // extraction of the 16 upper bits | |
| res = vuzpq_u16(vreinterpretq_u16_u32(tmpl), vreinterpretq_u16_u32(tmph)).val[1]; | |
| return vreinterpretq_s16_u16(res); | |
| } | |
| static inline int32x4_t repeat4(int32x4_t f, unsigned max) { | |
| uint16x4_t res; | |
| uint32x4_t tmp; | |
| // get the lower 16 bits | |
| res = vmovn_u32(vreinterpretq_u32_s32(f)); | |
| // bare multiplication, not SkFixedMul | |
| tmp = vmull_u16(res, vdup_n_u16(max+1)); | |
| // extraction of the 16 upper bits | |
| tmp = vshrq_n_u32(tmp, 16); | |
| return vreinterpretq_s32_u32(tmp); | |
| } | |
| static inline int32x4_t extract_low_bits_repeat_mirror4(int32x4_t fx, unsigned max) { | |
| uint16x4_t res; | |
| uint32x4_t tmp; | |
| int32x4_t ret; | |
| // get the lower 16 bits | |
| res = vmovn_u32(vreinterpretq_u32_s32(fx)); | |
| // bare multiplication, not SkFixedMul | |
| tmp = vmull_u16(res, vdup_n_u16(max + 1)); | |
| // shift and mask | |
| ret = vshrq_n_s32(vreinterpretq_s32_u32(tmp), 12); | |
| /* We don't need the mask below because the caller will | |
| * overwrite the non-masked bits | |
| */ | |
| //ret = vandq_s32(ret, vdupq_n_s32(0xF)); | |
| return ret; | |
| } | |
| template <unsigned (*tile)(SkFixed, int), | |
| int16x8_t (*tile8)(int32x4_t, int32x4_t, unsigned), | |
| bool tryDecal> | |
| static void nofilter_scale_neon(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | | |
| SkMatrix::kScale_Mask)) == 0); | |
| // we store y, x, x, x, x, x | |
| const unsigned maxX = s.fPixmap.width() - 1; | |
| SkFractionalInt fx; | |
| { | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| const unsigned maxY = s.fPixmap.height() - 1; | |
| *xy++ = tile(mapper.fixedY(), maxY); | |
| fx = mapper.fractionalIntX(); | |
| } | |
| if (0 == maxX) { | |
| // all of the following X values must be 0 | |
| memset(xy, 0, count * sizeof(uint16_t)); | |
| return; | |
| } | |
| const SkFractionalInt dx = s.fInvSxFractionalInt; | |
| // test if we don't need to apply the tile proc | |
| const SkFixed fixedFx = SkFractionalIntToFixed(fx); | |
| const SkFixed fixedDx = SkFractionalIntToFixed(dx); | |
| if (tryDecal && can_truncate_to_fixed_for_decal(fixedFx, fixedDx, count, maxX)) { | |
| decal_nofilter_scale_neon(xy, fixedFx, fixedDx, count); | |
| return; | |
| } | |
| if (count >= 8) { | |
| SkFractionalInt dx2 = dx+dx; | |
| SkFractionalInt dx4 = dx2+dx2; | |
| SkFractionalInt dx8 = dx4+dx4; | |
| // now build fx/fx+dx/fx+2dx/fx+3dx | |
| SkFractionalInt fx1, fx2, fx3; | |
| int32x4_t lbase, hbase; | |
| int16_t *dst16 = (int16_t *)xy; | |
| fx1 = fx+dx; | |
| fx2 = fx1+dx; | |
| fx3 = fx2+dx; | |
| lbase = vdupq_n_s32(SkFractionalIntToFixed(fx)); | |
| lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx1), lbase, 1); | |
| lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx2), lbase, 2); | |
| lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx3), lbase, 3); | |
| hbase = vaddq_s32(lbase, vdupq_n_s32(SkFractionalIntToFixed(dx4))); | |
| // store & bump | |
| while (count >= 8) { | |
| int16x8_t fx8; | |
| fx8 = tile8(lbase, hbase, maxX); | |
| vst1q_s16(dst16, fx8); | |
| // but preserving base & on to the next | |
| lbase = vaddq_s32 (lbase, vdupq_n_s32(SkFractionalIntToFixed(dx8))); | |
| hbase = vaddq_s32 (hbase, vdupq_n_s32(SkFractionalIntToFixed(dx8))); | |
| dst16 += 8; | |
| count -= 8; | |
| fx += dx8; | |
| }; | |
| xy = (uint32_t *) dst16; | |
| } | |
| uint16_t* xx = (uint16_t*)xy; | |
| for (int i = count; i > 0; --i) { | |
| *xx++ = tile(SkFractionalIntToFixed(fx), maxX); | |
| fx += dx; | |
| } | |
| } | |
| template <unsigned (*tile )(SkFixed, int), | |
| int32x4_t (*tile4)(int32x4_t, unsigned), | |
| unsigned (*extract_low_bits )(SkFixed, int), | |
| int32x4_t (*extract_low_bits4)(int32x4_t, unsigned), | |
| bool tryDecal> | |
| static void filter_scale_neon(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask | | |
| SkMatrix::kScale_Mask)) == 0); | |
| SkASSERT(s.fInvKy == 0); | |
| auto pack = [&](SkFixed f, unsigned max, SkFixed one) { | |
| unsigned i = tile(f, max); | |
| i = (i << 4) | extract_low_bits(f, max); | |
| return (i << 14) | (tile((f + one), max)); | |
| }; | |
| auto pack4 = [&](int32x4_t f, unsigned max, SkFixed one) { | |
| int32x4_t ret, res; | |
| res = tile4(f, max); | |
| ret = extract_low_bits4(f, max); | |
| ret = vsliq_n_s32(ret, res, 4); | |
| res = tile4(f + vdupq_n_s32(one), max); | |
| ret = vorrq_s32(vshlq_n_s32(ret, 14), res); | |
| return ret; | |
| }; | |
| const unsigned maxX = s.fPixmap.width() - 1; | |
| const SkFixed one = s.fFilterOneX; | |
| const SkFractionalInt dx = s.fInvSxFractionalInt; | |
| SkFractionalInt fx; | |
| { | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| const SkFixed fy = mapper.fixedY(); | |
| const unsigned maxY = s.fPixmap.height() - 1; | |
| // compute our two Y values up front | |
| *xy++ = pack(fy, maxY, s.fFilterOneY); | |
| // now initialize fx | |
| fx = mapper.fractionalIntX(); | |
| } | |
| // test if we don't need to apply the tile proc | |
| const SkFixed fixedFx = SkFractionalIntToFixed(fx); | |
| const SkFixed fixedDx = SkFractionalIntToFixed(dx); | |
| if (tryDecal && can_truncate_to_fixed_for_decal(fixedFx, fixedDx, count, maxX)) { | |
| decal_filter_scale_neon(xy, fixedFx, fixedDx, count); | |
| return; | |
| } | |
| if (count >= 4) { | |
| int32x4_t wide_fx; | |
| wide_fx = vdupq_n_s32(SkFractionalIntToFixed(fx)); | |
| wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx), wide_fx, 1); | |
| wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx), wide_fx, 2); | |
| wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx+dx), wide_fx, 3); | |
| while (count >= 4) { | |
| int32x4_t res; | |
| res = pack4(wide_fx, maxX, one); | |
| vst1q_u32(xy, vreinterpretq_u32_s32(res)); | |
| wide_fx += vdupq_n_s32(SkFractionalIntToFixed(dx+dx+dx+dx)); | |
| fx += dx+dx+dx+dx; | |
| xy += 4; | |
| count -= 4; | |
| } | |
| } | |
| while (--count >= 0) { | |
| *xy++ = pack(SkFractionalIntToFixed(fx), maxX, one); | |
| fx += dx; | |
| } | |
| } | |
| static const SkBitmapProcState::MatrixProc ClampX_ClampY_Procs[] = { | |
| nofilter_scale_neon<clamp, clamp8, true>, | |
| filter_scale_neon<clamp, | |
| clamp4, | |
| extract_low_bits_clamp, | |
| extract_low_bits_clamp4, | |
| true>, | |
| }; | |
| static const SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs[] = { | |
| nofilter_scale_neon<repeat, repeat8, false>, | |
| filter_scale_neon<repeat, | |
| repeat4, | |
| extract_low_bits_repeat_mirror, | |
| extract_low_bits_repeat_mirror4, | |
| false>, | |
| }; | |
| #else | |
| static const SkBitmapProcState::MatrixProc ClampX_ClampY_Procs[] = { | |
| nofilter_scale<clamp, true>, | |
| filter_scale<clamp, extract_low_bits_clamp, true>, | |
| }; | |
| static const SkBitmapProcState::MatrixProc RepeatX_RepeatY_Procs[] = { | |
| nofilter_scale<repeat, false>, | |
| filter_scale<repeat, extract_low_bits_repeat_mirror, false>, | |
| }; | |
| #endif | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // This next chunk has some specializations for unfiltered translate-only matrices. | |
| static inline U16CPU int_clamp(int x, int n) { | |
| if (x < 0) { x = 0; } | |
| if (x >= n) { x = n - 1; } | |
| return x; | |
| } | |
| /* returns 0...(n-1) given any x (positive or negative). | |
| As an example, if n (which is always positive) is 5... | |
| x: -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 | |
| returns: 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 | |
| */ | |
| static inline int sk_int_mod(int x, int n) { | |
| SkASSERT(n > 0); | |
| if ((unsigned)x >= (unsigned)n) { | |
| if (x < 0) { | |
| x = n + ~(~x % n); | |
| } else { | |
| x = x % n; | |
| } | |
| } | |
| return x; | |
| } | |
| static inline U16CPU int_repeat(int x, int n) { | |
| return sk_int_mod(x, n); | |
| } | |
| static inline U16CPU int_mirror(int x, int n) { | |
| x = sk_int_mod(x, 2 * n); | |
| if (x >= n) { | |
| x = n + ~(x - n); | |
| } | |
| return x; | |
| } | |
| static void fill_sequential(uint16_t xptr[], int pos, int count) { | |
| while (count --> 0) { | |
| *xptr++ = pos++; | |
| } | |
| } | |
| static void fill_backwards(uint16_t xptr[], int pos, int count) { | |
| while (count --> 0) { | |
| SkASSERT(pos >= 0); | |
| *xptr++ = pos--; | |
| } | |
| } | |
| static void clampx_nofilter_trans(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0); | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| *xy++ = int_clamp(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 | |
| sk_memset16(xptr, width - 1, count); | |
| } | |
| static void repeatx_nofilter_trans(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0); | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| *xy++ = int_repeat(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); | |
| } | |
| } | |
| static void mirrorx_nofilter_trans(const SkBitmapProcState& s, | |
| uint32_t xy[], int count, int x, int y) { | |
| SkASSERT((s.fInvType & ~SkMatrix::kTranslate_Mask) == 0); | |
| const SkBitmapProcStateAutoMapper mapper(s, x, y); | |
| *xy++ = int_mirror(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); | |
| } | |
| } | |
| } | |
| /////////////////////////////////////////////////////////////////////////////// | |
| // The main entry point to the file, choosing between everything above. | |
| SkBitmapProcState::MatrixProc SkBitmapProcState::chooseMatrixProc(bool translate_only_matrix) { | |
| SkASSERT(fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)); | |
| SkASSERT(fTileModeX == fTileModeY); | |
| SkASSERT(fTileModeX != SkShader::kDecal_TileMode); | |
| // Check for our special case translate methods when there is no scale/affine/perspective. | |
| if (translate_only_matrix && kNone_SkFilterQuality == fFilterQuality) { | |
| switch (fTileModeX) { | |
| default: SkASSERT(false); | |
| case SkShader::kClamp_TileMode: return clampx_nofilter_trans; | |
| case SkShader::kRepeat_TileMode: return repeatx_nofilter_trans; | |
| case SkShader::kMirror_TileMode: return mirrorx_nofilter_trans; | |
| } | |
| } | |
| // The arrays are all [ nofilter, filter ]. | |
| int index = fFilterQuality > kNone_SkFilterQuality ? 1 : 0; | |
| if (fTileModeX == SkShader::kClamp_TileMode) { | |
| // clamp gets special version of filterOne, working in non-normalized space (allowing decal) | |
| fFilterOneX = SK_Fixed1; | |
| fFilterOneY = SK_Fixed1; | |
| return ClampX_ClampY_Procs[index]; | |
| } | |
| // all remaining procs use this form for filterOne, putting them into normalized space. | |
| fFilterOneX = SK_Fixed1 / fPixmap.width(); | |
| fFilterOneY = SK_Fixed1 / fPixmap.height(); | |
| if (fTileModeX == SkShader::kRepeat_TileMode) { | |
| return RepeatX_RepeatY_Procs[index]; | |
| } | |
| return MirrorX_MirrorY_Procs[index]; | |
| } |