aboutsummaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/SkBlitRow_D32.cpp105
-rw-r--r--src/core/SkBlitter_ARGB32.cpp13
-rw-r--r--src/core/SkCoreBlitters.h1
-rw-r--r--src/effects/SkColorFilters.cpp12
-rw-r--r--src/opts/SkBlitRow_opts_SSE2.cpp65
-rw-r--r--src/opts/SkBlitRow_opts_SSE2.h2
-rw-r--r--src/opts/SkBlitRow_opts_arm.cpp6
-rw-r--r--src/opts/SkBlitRow_opts_arm_neon.cpp63
-rw-r--r--src/opts/SkBlitRow_opts_arm_neon.h3
-rw-r--r--src/opts/SkBlitRow_opts_mips_dsp.cpp4
-rw-r--r--src/opts/SkBlitRow_opts_none.cpp5
-rw-r--r--src/opts/opts_check_x86.cpp8
12 files changed, 194 insertions, 93 deletions
diff --git a/src/core/SkBlitRow_D32.cpp b/src/core/SkBlitRow_D32.cpp
index 0b9e916e6e..ac01e427bf 100644
--- a/src/core/SkBlitRow_D32.cpp
+++ b/src/core/SkBlitRow_D32.cpp
@@ -131,99 +131,37 @@ SkBlitRow::Proc32 SkBlitRow::Factory32(unsigned flags) {
return proc;
}
-// Color32 uses the blend_256_round_alt algorithm from tests/BlendTest.cpp.
-// It's not quite perfect, but it's never wrong in the interesting edge cases,
-// and it's quite a bit faster than blend_perfect.
+SkBlitRow::Proc32 SkBlitRow::ColorProcFactory() {
+ SkBlitRow::ColorProc proc = PlatformColorProc();
+ if (NULL == proc) {
+ proc = Color32;
+ }
+ SkASSERT(proc);
+ return proc;
+}
+
+#define SK_SUPPORT_LEGACY_COLOR32_MATHx
+
+// Color32 and its SIMD specializations use the blend_256_round_alt algorithm
+// from tests/BlendTest.cpp. It's not quite perfect, but it's never wrong in the
+// interesting edge cases, and it's quite a bit faster than blend_perfect.
//
// blend_256_round_alt is our currently blessed algorithm. Please use it or an analogous one.
-void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[], int count, SkPMColor color) {
+void SkBlitRow::Color32(SkPMColor* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, SkPMColor color) {
switch (SkGetPackedA32(color)) {
case 0: memmove(dst, src, count * sizeof(SkPMColor)); return;
case 255: sk_memset32(dst, color, count); return;
}
unsigned invA = 255 - SkGetPackedA32(color);
+#ifdef SK_SUPPORT_LEGACY_COLOR32_MATH // blend_256_plus1_trunc, busted
+ unsigned round = 0;
+#else // blend_256_round_alt, good
invA += invA >> 7;
- SkASSERT(invA < 256); // We've already handled alpha == 0 above.
-
-#if defined(SK_ARM_HAS_NEON)
- uint16x8_t colorHigh = vshll_n_u8((uint8x8_t)vdup_n_u32(color), 8);
- uint16x8_t colorAndRound = vaddq_u16(colorHigh, vdupq_n_u16(128));
- uint8x8_t invA8 = vdup_n_u8(invA);
-
- // Does the core work of blending color onto 4 pixels, returning the resulting 4 pixels.
- auto kernel = [&](const uint32x4_t& src4) -> uint32x4_t {
- uint16x8_t lo = vmull_u8(vget_low_u8( (uint8x16_t)src4), invA8),
- hi = vmull_u8(vget_high_u8((uint8x16_t)src4), invA8);
- return (uint32x4_t)
- vcombine_u8(vaddhn_u16(colorAndRound, lo), vaddhn_u16(colorAndRound, hi));
- };
-
- while (count >= 8) {
- uint32x4_t dst0 = kernel(vld1q_u32(src+0)),
- dst4 = kernel(vld1q_u32(src+4));
- vst1q_u32(dst+0, dst0);
- vst1q_u32(dst+4, dst4);
- src += 8;
- dst += 8;
- count -= 8;
- }
- if (count >= 4) {
- vst1q_u32(dst, kernel(vld1q_u32(src)));
- src += 4;
- dst += 4;
- count -= 4;
- }
- if (count >= 2) {
- uint32x2_t src2 = vld1_u32(src);
- vst1_u32(dst, vget_low_u32(kernel(vcombine_u32(src2, src2))));
- src += 2;
- dst += 2;
- count -= 2;
- }
- if (count >= 1) {
- vst1q_lane_u32(dst, kernel(vdupq_n_u32(*src)), 0);
- }
-
-#elif SK_CPU_SSE_LEVEL >= SK_CPU_LEVEL_SSE2
- __m128i colorHigh = _mm_unpacklo_epi8(_mm_setzero_si128(), _mm_set1_epi32(color));
- __m128i colorAndRound = _mm_add_epi16(colorHigh, _mm_set1_epi16(128));
- __m128i invA16 = _mm_set1_epi16(invA);
-
- // Does the core work of blending color onto 4 pixels, returning the resulting 4 pixels.
- auto kernel = [&](const __m128i& src4) -> __m128i {
- __m128i lo = _mm_mullo_epi16(invA16, _mm_unpacklo_epi8(src4, _mm_setzero_si128())),
- hi = _mm_mullo_epi16(invA16, _mm_unpackhi_epi8(src4, _mm_setzero_si128()));
- return _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(colorAndRound, lo), 8),
- _mm_srli_epi16(_mm_add_epi16(colorAndRound, hi), 8));
- };
-
- while (count >= 8) {
- __m128i dst0 = kernel(_mm_loadu_si128((const __m128i*)(src+0))),
- dst4 = kernel(_mm_loadu_si128((const __m128i*)(src+4)));
- _mm_storeu_si128((__m128i*)(dst+0), dst0);
- _mm_storeu_si128((__m128i*)(dst+4), dst4);
- src += 8;
- dst += 8;
- count -= 8;
- }
- if (count >= 4) {
- _mm_storeu_si128((__m128i*)dst, kernel(_mm_loadu_si128((const __m128i*)src)));
- src += 4;
- dst += 4;
- count -= 4;
- }
- if (count >= 2) {
- _mm_storel_epi64((__m128i*)dst, kernel(_mm_loadl_epi64((const __m128i*)src)));
- src += 2;
- dst += 2;
- count -= 2;
- }
- if (count >= 1) {
- *dst = _mm_cvtsi128_si32(kernel(_mm_cvtsi32_si128(*src)));
- }
-#else // Neither NEON nor SSE2.
unsigned round = (128 << 16) + (128 << 0);
+#endif
while (count --> 0) {
// Our math is 16-bit, so we can do a little bit of SIMD in 32-bit registers.
@@ -234,6 +172,5 @@ void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[], int count, SkPMC
src++;
dst++;
}
-#endif
}
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index f2de82a2e9..96280b7baa 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -52,6 +52,7 @@ SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
fSrcB = SkAlphaMul(SkColorGetB(color), scale);
fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
+ fColor32Proc = SkBlitRow::ColorProcFactory();
}
const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
@@ -71,7 +72,7 @@ void SkARGB32_Blitter::blitH(int x, int y, int width) {
SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
uint32_t* device = fDevice.getAddr32(x, y);
- SkBlitRow::Color32(device, device, width, fPMColor);
+ fColor32Proc(device, device, width, fPMColor);
}
void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
@@ -96,7 +97,7 @@ void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
sk_memset32(device, color, count);
} else {
uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa));
- SkBlitRow::Color32(device, device, count, sc);
+ fColor32Proc(device, device, count, sc);
}
}
runs += count;
@@ -108,7 +109,7 @@ void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
uint32_t* device = fDevice.getAddr32(x, y);
SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
-
+
device[0] = SkBlendARGB32(fPMColor, device[0], a0);
device[1] = SkBlendARGB32(fPMColor, device[1], a1);
}
@@ -116,7 +117,7 @@ void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
uint32_t* device = fDevice.getAddr32(x, y);
SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
-
+
device[0] = SkBlendARGB32(fPMColor, device[0], a0);
device = (uint32_t*)((char*)device + fDevice.rowBytes());
device[0] = SkBlendARGB32(fPMColor, device[0], a1);
@@ -247,7 +248,7 @@ void SkARGB32_Blitter::blitRect(int x, int y, int width, int height) {
size_t rowBytes = fDevice.rowBytes();
while (--height >= 0) {
- SkBlitRow::Color32(device, device, width, color);
+ fColor32Proc(device, device, width, color);
device = (uint32_t*)((char*)device + rowBytes);
}
}
@@ -300,7 +301,7 @@ void SkARGB32_Black_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
void SkARGB32_Black_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
uint32_t* device = fDevice.getAddr32(x, y);
SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
-
+
device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
device = (uint32_t*)((char*)device + fDevice.rowBytes());
device[0] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a1);
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 18821dc0d1..805ca92d15 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -126,6 +126,7 @@ public:
protected:
SkColor fColor;
SkPMColor fPMColor;
+ SkBlitRow::ColorProc fColor32Proc;
private:
unsigned fSrcA, fSrcR, fSrcG, fSrcB;
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index cdbae98bb0..87a5a20821 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -40,7 +40,7 @@ uint32_t SkModeColorFilter::getFlags() const {
void SkModeColorFilter::filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const {
SkPMColor color = fPMColor;
SkXfermodeProc proc = fProc;
-
+
for (int i = 0; i < count; i++) {
result[i] = proc(color, shader[i]);
}
@@ -394,13 +394,19 @@ private:
class SrcOver_SkModeColorFilter : public SkModeColorFilter {
public:
- SrcOver_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrcOver_Mode) { }
+ SrcOver_SkModeColorFilter(SkColor color)
+ : INHERITED(color, SkXfermode::kSrcOver_Mode) {
+ fColor32Proc = SkBlitRow::ColorProcFactory();
+ }
void filterSpan(const SkPMColor shader[], int count, SkPMColor result[]) const override {
- SkBlitRow::Color32(result, shader, count, this->getPMColor());
+ fColor32Proc(result, shader, count, this->getPMColor());
}
private:
+
+ SkBlitRow::ColorProc fColor32Proc;
+
typedef SkModeColorFilter INHERITED;
};
diff --git a/src/opts/SkBlitRow_opts_SSE2.cpp b/src/opts/SkBlitRow_opts_SSE2.cpp
index 7f5b6779cf..59375f1831 100644
--- a/src/opts/SkBlitRow_opts_SSE2.cpp
+++ b/src/opts/SkBlitRow_opts_SSE2.cpp
@@ -232,6 +232,71 @@ void S32A_Blend_BlitRow32_SSE2(SkPMColor* SK_RESTRICT dst,
}
}
+#define SK_SUPPORT_LEGACY_COLOR32_MATHx
+
+/* SSE2 version of Color32()
+ * portable version is in core/SkBlitRow_D32.cpp
+ */
+// Color32 and its SIMD specializations use the blend_256_round_alt algorithm
+// from tests/BlendTest.cpp. It's not quite perfect, but it's never wrong in the
+// interesting edge cases, and it's quite a bit faster than blend_perfect.
+//
+// blend_256_round_alt is our currently blessed algorithm. Please use it or an analogous one.
+void Color32_SSE2(SkPMColor dst[], const SkPMColor src[], int count, SkPMColor color) {
+ switch (SkGetPackedA32(color)) {
+ case 0: memmove(dst, src, count * sizeof(SkPMColor)); return;
+ case 255: sk_memset32(dst, color, count); return;
+ }
+
+ __m128i colorHigh = _mm_unpacklo_epi8(_mm_setzero_si128(), _mm_set1_epi32(color));
+#ifdef SK_SUPPORT_LEGACY_COLOR32_MATH // blend_256_plus1_trunc, busted
+ __m128i colorAndRound = colorHigh;
+#else // blend_256_round_alt, good
+ __m128i colorAndRound = _mm_add_epi16(colorHigh, _mm_set1_epi16(128));
+#endif
+
+ unsigned invA = 255 - SkGetPackedA32(color);
+#ifdef SK_SUPPORT_LEGACY_COLOR32_MATH // blend_256_plus1_trunc, busted
+ __m128i invA16 = _mm_set1_epi16(invA);
+#else // blend_256_round_alt, good
+ SkASSERT(invA + (invA >> 7) < 256); // We should still fit in the low byte here.
+ __m128i invA16 = _mm_set1_epi16(invA + (invA >> 7));
+#endif
+
+ // Does the core work of blending color onto 4 pixels, returning the resulting 4 pixels.
+ auto kernel = [&](const __m128i& src4) -> __m128i {
+ __m128i lo = _mm_mullo_epi16(invA16, _mm_unpacklo_epi8(src4, _mm_setzero_si128())),
+ hi = _mm_mullo_epi16(invA16, _mm_unpackhi_epi8(src4, _mm_setzero_si128()));
+ return _mm_packus_epi16(_mm_srli_epi16(_mm_add_epi16(colorAndRound, lo), 8),
+ _mm_srli_epi16(_mm_add_epi16(colorAndRound, hi), 8));
+ };
+
+ while (count >= 8) {
+ __m128i dst0 = kernel(_mm_loadu_si128((const __m128i*)(src+0))),
+ dst4 = kernel(_mm_loadu_si128((const __m128i*)(src+4)));
+ _mm_storeu_si128((__m128i*)(dst+0), dst0);
+ _mm_storeu_si128((__m128i*)(dst+4), dst4);
+ src += 8;
+ dst += 8;
+ count -= 8;
+ }
+ if (count >= 4) {
+ _mm_storeu_si128((__m128i*)dst, kernel(_mm_loadu_si128((const __m128i*)src)));
+ src += 4;
+ dst += 4;
+ count -= 4;
+ }
+ if (count >= 2) {
+ _mm_storel_epi64((__m128i*)dst, kernel(_mm_loadl_epi64((const __m128i*)src)));
+ src += 2;
+ dst += 2;
+ count -= 2;
+ }
+ if (count >= 1) {
+ *dst = _mm_cvtsi128_si32(kernel(_mm_cvtsi32_si128(*src)));
+ }
+}
+
void Color32A_D565_SSE2(uint16_t dst[], SkPMColor src, int count, int x, int y) {
SkASSERT(count > 0);
diff --git a/src/opts/SkBlitRow_opts_SSE2.h b/src/opts/SkBlitRow_opts_SSE2.h
index 6c0611f49f..bb6cece478 100644
--- a/src/opts/SkBlitRow_opts_SSE2.h
+++ b/src/opts/SkBlitRow_opts_SSE2.h
@@ -22,6 +22,8 @@ void S32A_Blend_BlitRow32_SSE2(SkPMColor* SK_RESTRICT dst,
const SkPMColor* SK_RESTRICT src,
int count, U8CPU alpha);
+void Color32_SSE2(SkPMColor dst[], const SkPMColor src[], int count,
+ SkPMColor color);
void Color32A_D565_SSE2(uint16_t dst[], SkPMColor src, int count, int x,
int y);
diff --git a/src/opts/SkBlitRow_opts_arm.cpp b/src/opts/SkBlitRow_opts_arm.cpp
index 9dd4b3b43d..a8ab8ce114 100644
--- a/src/opts/SkBlitRow_opts_arm.cpp
+++ b/src/opts/SkBlitRow_opts_arm.cpp
@@ -390,3 +390,9 @@ SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
return SK_ARM_NEON_WRAP(sk_blitrow_platform_32_procs_arm)[flags];
}
+///////////////////////////////////////////////////////////////////////////////
+#define Color32_arm NULL
+SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
+ return SK_ARM_NEON_WRAP(Color32_arm);
+}
+
diff --git a/src/opts/SkBlitRow_opts_arm_neon.cpp b/src/opts/SkBlitRow_opts_arm_neon.cpp
index 4a6514af7f..bd0c45f4c0 100644
--- a/src/opts/SkBlitRow_opts_arm_neon.cpp
+++ b/src/opts/SkBlitRow_opts_arm_neon.cpp
@@ -1679,6 +1679,69 @@ void S32_D565_Opaque_Dither_neon(uint16_t* SK_RESTRICT dst,
}
}
+#define SK_SUPPORT_LEGACY_COLOR32_MATHx
+
+// Color32 and its SIMD specializations use the blend_256_round_alt algorithm
+// from tests/BlendTest.cpp. It's not quite perfect, but it's never wrong in the
+// interesting edge cases, and it's quite a bit faster than blend_perfect.
+//
+// blend_256_round_alt is our currently blessed algorithm. Please use it or an analogous one.
+void Color32_arm_neon(SkPMColor* dst, const SkPMColor* src, int count, SkPMColor color) {
+ switch (SkGetPackedA32(color)) {
+ case 0: memmove(dst, src, count * sizeof(SkPMColor)); return;
+ case 255: sk_memset32(dst, color, count); return;
+ }
+
+ uint16x8_t colorHigh = vshll_n_u8((uint8x8_t)vdup_n_u32(color), 8);
+#ifdef SK_SUPPORT_LEGACY_COLOR32_MATH // blend_256_plus1_trunc, busted
+ uint16x8_t colorAndRound = colorHigh;
+#else // blend_256_round_alt, good
+ uint16x8_t colorAndRound = vaddq_u16(colorHigh, vdupq_n_u16(128));
+#endif
+
+ unsigned invA = 255 - SkGetPackedA32(color);
+#ifdef SK_SUPPORT_LEGACY_COLOR32_MATH // blend_256_plus1_trunc, busted
+ uint8x8_t invA8 = vdup_n_u8(invA);
+#else // blend_256_round_alt, good
+ SkASSERT(invA + (invA >> 7) < 256); // This next part only works if alpha is not 0.
+ uint8x8_t invA8 = vdup_n_u8(invA + (invA >> 7));
+#endif
+
+ // Does the core work of blending color onto 4 pixels, returning the resulting 4 pixels.
+ auto kernel = [&](const uint32x4_t& src4) -> uint32x4_t {
+ uint16x8_t lo = vmull_u8(vget_low_u8( (uint8x16_t)src4), invA8),
+ hi = vmull_u8(vget_high_u8((uint8x16_t)src4), invA8);
+ return (uint32x4_t)
+ vcombine_u8(vaddhn_u16(colorAndRound, lo), vaddhn_u16(colorAndRound, hi));
+ };
+
+ while (count >= 8) {
+ uint32x4_t dst0 = kernel(vld1q_u32(src+0)),
+ dst4 = kernel(vld1q_u32(src+4));
+ vst1q_u32(dst+0, dst0);
+ vst1q_u32(dst+4, dst4);
+ src += 8;
+ dst += 8;
+ count -= 8;
+ }
+ if (count >= 4) {
+ vst1q_u32(dst, kernel(vld1q_u32(src)));
+ src += 4;
+ dst += 4;
+ count -= 4;
+ }
+ if (count >= 2) {
+ uint32x2_t src2 = vld1_u32(src);
+ vst1_u32(dst, vget_low_u32(kernel(vcombine_u32(src2, src2))));
+ src += 2;
+ dst += 2;
+ count -= 2;
+ }
+ if (count >= 1) {
+ vst1q_lane_u32(dst, kernel(vdupq_n_u32(*src)), 0);
+ }
+}
+
///////////////////////////////////////////////////////////////////////////////
const SkBlitRow::Proc16 sk_blitrow_platform_565_procs_arm_neon[] = {
diff --git a/src/opts/SkBlitRow_opts_arm_neon.h b/src/opts/SkBlitRow_opts_arm_neon.h
index 159a466c98..92d58ce3c4 100644
--- a/src/opts/SkBlitRow_opts_arm_neon.h
+++ b/src/opts/SkBlitRow_opts_arm_neon.h
@@ -13,4 +13,7 @@ extern const SkBlitRow::Proc16 sk_blitrow_platform_565_procs_arm_neon[];
extern const SkBlitRow::ColorProc16 sk_blitrow_platform_565_colorprocs_arm_neon[];
extern const SkBlitRow::Proc32 sk_blitrow_platform_32_procs_arm_neon[];
+extern void Color32_arm_neon(SkPMColor* dst, const SkPMColor* src, int count,
+ SkPMColor color);
+
#endif
diff --git a/src/opts/SkBlitRow_opts_mips_dsp.cpp b/src/opts/SkBlitRow_opts_mips_dsp.cpp
index 7ef75c4ec4..528eb07eb5 100644
--- a/src/opts/SkBlitRow_opts_mips_dsp.cpp
+++ b/src/opts/SkBlitRow_opts_mips_dsp.cpp
@@ -953,3 +953,7 @@ SkBlitRow::ColorProc16 SkBlitRow::PlatformColorFactory565(unsigned flags) {
SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
return platform_32_procs_mips_dsp[flags];
}
+
+SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
+ return NULL;
+}
diff --git a/src/opts/SkBlitRow_opts_none.cpp b/src/opts/SkBlitRow_opts_none.cpp
index 10b3b43772..87ceb69760 100644
--- a/src/opts/SkBlitRow_opts_none.cpp
+++ b/src/opts/SkBlitRow_opts_none.cpp
@@ -20,3 +20,8 @@ SkBlitRow::ColorProc16 SkBlitRow::PlatformColorFactory565(unsigned flags) {
SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
return NULL;
}
+
+SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
+ return NULL;
+}
+
diff --git a/src/opts/opts_check_x86.cpp b/src/opts/opts_check_x86.cpp
index cdefec2eac..7314f7dcf8 100644
--- a/src/opts/opts_check_x86.cpp
+++ b/src/opts/opts_check_x86.cpp
@@ -258,6 +258,14 @@ SkBlitRow::Proc32 SkBlitRow::PlatformProcs32(unsigned flags) {
}
}
+SkBlitRow::ColorProc SkBlitRow::PlatformColorProc() {
+ if (supports_simd(SK_CPU_SSE_LEVEL_SSE2)) {
+ return Color32_SSE2;
+ } else {
+ return NULL;
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
SkBlitMask::ColorProc SkBlitMask::PlatformColorProcs(SkColorType dstCT,
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-09 21:52:32 +0000