refresh from skia, with blitrow_d32 bottlenecks for neon optimizations
diff --git a/Android.mk b/Android.mk
index de09fd4..5d27c91 100644
--- a/Android.mk
+++ b/Android.mk
@@ -90,6 +90,7 @@
src/core/SkBitmapProcState_matrixProcs.cpp \
src/core/SkBitmapSampler.cpp \
src/core/SkBlitRow_D16.cpp \
+ src/core/SkBlitRow_D32.cpp \
src/core/SkBlitRow_D4444.cpp \
src/core/SkBlitter.cpp \
src/core/SkBlitter_4444.cpp \
diff --git a/include/views/SkOSWindow_Mac.h b/include/views/SkOSWindow_Mac.h
index 4741151..98e76b0 100644
--- a/include/views/SkOSWindow_Mac.h
+++ b/include/views/SkOSWindow_Mac.h
@@ -30,8 +30,8 @@
static bool PostEvent(SkEvent* evt, SkEventSinkID, SkMSec delay);
- static OSStatus SkOSWindow::EventHandler(EventHandlerCallRef inHandler,
- EventRef inEvent, void* userData);
+ static OSStatus EventHandler(EventHandlerCallRef inHandler,
+ EventRef inEvent, void* userData);
void doPaint(void* ctx);
diff --git a/src/core/SkBlitRow.h b/src/core/SkBlitRow.h
index ec31ff5..dbbd84d 100644
--- a/src/core/SkBlitRow.h
+++ b/src/core/SkBlitRow.h
@@ -6,7 +6,7 @@
class SkBlitRow {
public:
- enum {
+ enum Flags16 {
//! If set, the alpha parameter will be != 255
kGlobalAlpha_Flag = 0x01,
//! If set, the src colors may have alpha != 255
@@ -32,13 +32,51 @@
//! Public entry-point to return a blit function ptr
static Proc Factory(unsigned flags, SkBitmap::Config);
+ ///////////// D32 version
+
+ enum Flags32 {
+ kGlobalAlpha_Flag32 = 1 << 0,
+ kSrcPixelAlpha_Flag32 = 1 << 1,
+ };
+
+ /** Function pointer that blends 32bit colors onto a 32bit destination.
+ @param dst array of dst 32bit colors
+ @param src array of src 32bit colors (w/ or w/o alpha)
+ @param count number of colors to blend
+ @param alpha global alpha to be applied to all src colors
+ */
+ typedef void (*Proc32)(uint32_t* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, U8CPU alpha);
+
+ static Proc32 Factory32(unsigned flags32);
+
+ /** Blend a single color onto a row of S32 pixels, writing the result
+ into a row of D32 pixels. src and dst may be the same memory, but
+ if they are not, they may not overlap.
+ */
+ static void Color32(SkPMColor dst[], const SkPMColor src[], int count,
+ SkPMColor color);
+
+ /** Blend a single color onto a row of 32bit pixels, writing the result
+ into the same row.
+ */
+ static void Color32(SkPMColor row[], int count, SkPMColor color) {
+ Color32(row, row, count, color);
+ }
+
private:
+ enum {
+ kFlags16_Mask = 7,
+ kFlags32_Mask = 3
+ };
/** These global arrays are indexed using the flags parameter to Factory,
and contain either NULL, or a platform-specific function-ptr to be used
in place of the system default.
*/
static const Proc gPlatform_565_Procs[];
static const Proc gPlatform_4444_Procs[];
+ static const Proc32 gPlatform_Procs32[];
};
#endif
diff --git a/src/core/SkBlitRow_D16.cpp b/src/core/SkBlitRow_D16.cpp
index 1860d3b..66ac90e 100644
--- a/src/core/SkBlitRow_D16.cpp
+++ b/src/core/SkBlitRow_D16.cpp
@@ -235,6 +235,8 @@
SkBlitRow::Proc SkBlitRow::Factory(unsigned flags, SkBitmap::Config config) {
SkASSERT(flags < SK_ARRAY_COUNT(gDefault_565_Procs));
+ // just so we don't crash
+ flags &= kFlags16_Mask;
SkBlitRow::Proc proc = NULL;
diff --git a/src/core/SkBlitRow_D32.cpp b/src/core/SkBlitRow_D32.cpp
new file mode 100644
index 0000000..f67bb9a
--- /dev/null
+++ b/src/core/SkBlitRow_D32.cpp
@@ -0,0 +1,112 @@
+#include "SkBlitRow.h"
+#include "SkColorPriv.h"
+#include "SkUtils.h"
+
+static void S32_Opaque_BlitRow32(SkPMColor* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, U8CPU alpha) {
+ SkASSERT(255 == alpha);
+ memcpy(dst, src, count * sizeof(SkPMColor));
+}
+
+static void S32_Blend_BlitRow32(SkPMColor* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, U8CPU alpha) {
+ SkASSERT(alpha <= 255);
+ if (count > 0) {
+ unsigned src_scale = SkAlpha255To256(alpha);
+ unsigned dst_scale = 256 - src_scale;
+ do {
+ *dst = SkAlphaMulQ(*src, src_scale) + SkAlphaMulQ(*dst, dst_scale);
+ src += 1;
+ dst += 1;
+ } while (--count > 0);
+ }
+}
+
+//#define TEST_SRC_ALPHA
+
+static void S32A_Opaque_BlitRow32(SkPMColor* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, U8CPU alpha) {
+ SkASSERT(255 == alpha);
+ if (count > 0) {
+ do {
+#ifdef TEST_SRC_ALPHA
+ SkPMColor sc = *src;
+ if (sc) {
+ unsigned srcA = SkGetPackedA32(sc);
+ SkPMColor result = sc;
+ if (srcA != 255) {
+ result = SkPMSrcOver(sc, *dst);
+ }
+ *dst = result;
+ }
+#else
+ *dst = SkPMSrcOver(*src, *dst);
+#endif
+ src += 1;
+ dst += 1;
+ } while (--count > 0);
+ }
+}
+
+static void S32A_Blend_BlitRow32(SkPMColor* SK_RESTRICT dst,
+ const SkPMColor* SK_RESTRICT src,
+ int count, U8CPU alpha) {
+ SkASSERT(alpha <= 255);
+ if (count > 0) {
+ do {
+ *dst = SkBlendARGB32(*src, *dst, alpha);
+ src += 1;
+ dst += 1;
+ } while (--count > 0);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const SkBlitRow::Proc32 gDefault_Procs32[] = {
+ S32_Opaque_BlitRow32,
+ S32_Blend_BlitRow32,
+ S32A_Opaque_BlitRow32,
+ S32A_Blend_BlitRow32
+};
+
+SkBlitRow::Proc32 SkBlitRow::Factory32(unsigned flags) {
+ SkASSERT(flags < SK_ARRAY_COUNT(gDefault_Procs32));
+ // just so we don't crash
+ flags &= kFlags32_Mask;
+
+ SkBlitRow::Proc32 proc = gPlatform_Procs32[flags];
+ if (NULL == proc) {
+ proc = gDefault_Procs32[flags];
+ }
+ SkASSERT(proc);
+ return proc;
+}
+
+void SkBlitRow::Color32(SkPMColor dst[], const SkPMColor src[], int count,
+ SkPMColor color) {
+ if (count > 0) {
+ if (0 == color) {
+ if (src != dst) {
+ memcpy(dst, src, count * sizeof(SkPMColor));
+ }
+ }
+ unsigned colorA = SkGetPackedA32(color);
+ if (255 == colorA) {
+ sk_memset32(dst, color, count);
+ } else {
+ unsigned scale = 256 - SkAlpha255To256(colorA);
+ do {
+ *dst = color + SkAlphaMulQ(*src, scale);
+ src += 1;
+ dst += 1;
+ } while (--count);
+ }
+ }
+}
+
+
+
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index d3e5714..37bd0da 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -69,29 +69,7 @@
void SkARGB32_Blitter::blitH(int x, int y, int width) {
SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
- if (fSrcA == 0) {
- return;
- }
-
- uint32_t* device = fDevice.getAddr32(x, y);
-
- if (fSrcA == 255) {
- sk_memset32(device, fPMColor, width);
- } else {
- uint32_t color = fPMColor;
- unsigned dst_scale = SkAlpha255To256(255 - fSrcA);
- uint32_t prevDst = ~device[0]; // so we always fail the test the first time
- uint32_t result SK_INIT_TO_AVOID_WARNING;
-
- for (int i = 0; i < width; i++) {
- uint32_t currDst = device[i];
- if (currDst != prevDst) {
- result = color + SkAlphaMulQ(currDst, dst_scale);
- prevDst = currDst;
- }
- device[i] = result;
- }
- }
+ SkBlitRow::Color32(fDevice.getAddr32(x, y), width, fPMColor);
}
void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
@@ -115,13 +93,8 @@
if ((opaqueMask & aa) == 255) {
sk_memset32(device, color, count);
} else {
- uint32_t sc = SkAlphaMulQ(color, aa);
- unsigned dst_scale = 255 - SkGetPackedA32(sc);
- int n = count;
- do {
- --n;
- device[n] = sc + SkAlphaMulQ(device[n], dst_scale);
- } while (n > 0);
+ uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa));
+ SkBlitRow::Color32(device, count, sc);
}
}
runs += count;
@@ -310,29 +283,11 @@
uint32_t* device = fDevice.getAddr32(x, y);
uint32_t color = fPMColor;
+ size_t rowBytes = fDevice.rowBytes();
- if (fSrcA == 255) {
- while (--height >= 0) {
- sk_memset32(device, color, width);
- device = (uint32_t*)((char*)device + fDevice.rowBytes());
- }
- } else {
- unsigned dst_scale = SkAlpha255To256(255 - fSrcA);
-
- while (--height >= 0) {
- uint32_t prevDst = ~device[0];
- uint32_t result SK_INIT_TO_AVOID_WARNING;
-
- for (int i = 0; i < width; i++) {
- uint32_t dst = device[i];
- if (dst != prevDst) {
- result = color + SkAlphaMulQ(dst, dst_scale);
- prevDst = dst;
- }
- device[i] = result;
- }
- device = (uint32_t*)((char*)device + fDevice.rowBytes());
- }
+ while (--height >= 0) {
+ SkBlitRow::Color32(device, width, color);
+ device = (uint32_t*)((char*)device + rowBytes);
}
}
@@ -440,11 +395,20 @@
//////////////////////////////////////////////////////////////////////////////////////////
SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkBitmap& device,
- const SkPaint& paint)
- : INHERITED(device, paint) {
+ const SkPaint& paint) : INHERITED(device, paint) {
fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * (sizeof(SkPMColor)));
- (fXfermode = paint.getXfermode())->safeRef();
+ fXfermode = paint.getXfermode();
+ SkSafeRef(fXfermode);
+
+ int flags = 0;
+ if (!(fShader->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
+ flags |= SkBlitRow::kSrcPixelAlpha_Flag32;
+ }
+ // we call this on the output from the shader
+ fProc32 = SkBlitRow::Factory32(flags);
+ // we call this on the output from the shader + alpha from the aa buffer
+ fProc32Blend = SkBlitRow::Factory32(flags | SkBlitRow::kGlobalAlpha_Flag32);
}
SkARGB32_Shader_Blitter::~SkARGB32_Shader_Blitter() {
@@ -465,16 +429,7 @@
if (fXfermode) {
fXfermode->xfer32(device, span, width, NULL);
} else {
- for (int i = 0; i < width; i++) {
- uint32_t src = span[i];
- if (src) {
- unsigned srcA = SkGetPackedA32(src);
- if (srcA != 0xFF) {
- src += SkAlphaMulQ(device[i], SkAlpha255To256(255 - srcA));
- }
- device[i] = src;
- }
- }
+ fProc32(device, span, width, 255);
}
}
}
@@ -519,15 +474,12 @@
}
int aa = *antialias;
if (aa) {
- if (aa == 255) { // cool, have the shader draw right into the device
+ if (aa == 255) {
+ // cool, have the shader draw right into the device
shader->shadeSpan(x, y, device, count);
} else {
shader->shadeSpan(x, y, span, count);
- for (int i = count - 1; i >= 0; --i) {
- if (span[i]) {
- device[i] = SkBlendARGB32(span[i], device[i], aa);
- }
- }
+ fProc32Blend(device, span, count, aa);
}
}
device += count;
@@ -535,7 +487,7 @@
antialias += count;
x += count;
}
- } else { // no xfermode but we are not opaque
+ } else { // no xfermode but the shader not opaque
for (;;) {
int count = *runs;
if (count <= 0) {
@@ -545,17 +497,9 @@
if (aa) {
fShader->shadeSpan(x, y, span, count);
if (aa == 255) {
- for (int i = count - 1; i >= 0; --i) {
- if (span[i]) {
- device[i] = SkPMSrcOver(span[i], device[i]);
- }
- }
+ fProc32(device, span, count, 255);
} else {
- for (int i = count - 1; i >= 0; --i) {
- if (span[i]) {
- device[i] = SkBlendARGB32(span[i], device[i], aa);
- }
- }
+ fProc32Blend(device, span, count, aa);
}
}
device += count;
diff --git a/src/core/SkComposeShader.cpp b/src/core/SkComposeShader.cpp
index 1e5e202..7e566a3 100644
--- a/src/core/SkComposeShader.cpp
+++ b/src/core/SkComposeShader.cpp
@@ -124,6 +124,8 @@
if (NULL == mode) // implied SRC_OVER
{
+ // TODO: when we have a good test-case, should use SkBlitRow::Proc32
+ // for these loops
do {
int n = count;
if (n > TMP_COLOR_COUNT)
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 5e34685..84f8fa6 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -141,8 +141,10 @@
virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
private:
- SkXfermode* fXfermode;
- SkPMColor* fBuffer;
+ SkXfermode* fXfermode;
+ SkPMColor* fBuffer;
+ SkBlitRow::Proc32 fProc32;
+ SkBlitRow::Proc32 fProc32Blend;
// illegal
SkARGB32_Shader_Blitter& operator=(const SkARGB32_Shader_Blitter&);
diff --git a/src/core/SkSpriteBlitter_ARGB32.cpp b/src/core/SkSpriteBlitter_ARGB32.cpp
index 6addde7..01ee9f1 100644
--- a/src/core/SkSpriteBlitter_ARGB32.cpp
+++ b/src/core/SkSpriteBlitter_ARGB32.cpp
@@ -16,64 +16,58 @@
*/
#include "SkSpriteBlitter.h"
+#include "SkBlitRow.h"
+#include "SkColorFilter.h"
+#include "SkColorPriv.h"
#include "SkTemplates.h"
#include "SkUtils.h"
-#include "SkColorPriv.h"
-
-#define D32_S32A_Opaque_Pixel(dst, sc) \
-do { \
- if (sc) { \
- unsigned srcA = SkGetPackedA32(sc); \
- uint32_t result = sc; \
- if (srcA != 0xFF) { \
- result += SkAlphaMulQ(*dst, SkAlpha255To256(255 - srcA)); \
- } \
- *dst = result; \
- } \
-} while (0)
-
-#define SkSPRITE_CLASSNAME Sprite_D32_S32A_Opaque
-#define SkSPRITE_ARGS
-#define SkSPRITE_FIELDS
-#define SkSPRITE_INIT
-#define SkSPRITE_DST_TYPE uint32_t
-#define SkSPRITE_SRC_TYPE uint32_t
-#define SkSPRITE_DST_GETADDR getAddr32
-#define SkSPRITE_SRC_GETADDR getAddr32
-#define SkSPRITE_PREAMBLE(srcBM, x, y)
-#define SkSPRITE_BLIT_PIXEL(dst, src) D32_S32A_Opaque_Pixel(dst, src)
-#define SkSPRITE_NEXT_ROW
-#define SkSPRITE_POSTAMBLE(srcBM)
-#include "SkSpriteBlitterTemplate.h"
+#include "SkXfermode.h"
///////////////////////////////////////////////////////////////////////////////
-class Sprite_D32_S32_Opaque : public SkSpriteBlitter {
+class Sprite_D32_S32 : public SkSpriteBlitter {
public:
- Sprite_D32_S32_Opaque(const SkBitmap& source) : SkSpriteBlitter(source) {}
+ Sprite_D32_S32(const SkBitmap& src, U8CPU alpha) : INHERITED(src) {
+ SkASSERT(src.config() == SkBitmap::kARGB_8888_Config);
+ unsigned flags32 = 0;
+ if (255 != alpha) {
+ flags32 |= SkBlitRow::kGlobalAlpha_Flag32;
+ }
+ if (!src.isOpaque()) {
+ flags32 |= SkBlitRow::kSrcPixelAlpha_Flag32;
+ }
+
+ fProc32 = SkBlitRow::Factory32(flags32);
+ fAlpha = alpha;
+ }
+
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(width > 0 && height > 0);
SK_RESTRICT uint32_t* dst = fDevice->getAddr32(x, y);
const SK_RESTRICT uint32_t* src = fSource->getAddr32(x - fLeft,
y - fTop);
- unsigned dstRB = fDevice->rowBytes();
- unsigned srcRB = fSource->rowBytes();
- size_t size = width * sizeof(uint32_t);
+ size_t dstRB = fDevice->rowBytes();
+ size_t srcRB = fSource->rowBytes();
+ SkBlitRow::Proc32 proc = fProc32;
+ U8CPU alpha = fAlpha;
do {
- memcpy(dst, src, size);
+ proc(dst, src, width, alpha);
dst = (SK_RESTRICT uint32_t*)((char*)dst + dstRB);
src = (const SK_RESTRICT uint32_t*)((const char*)src + srcRB);
} while (--height != 0);
}
+
+private:
+ SkBlitRow::Proc32 fProc32;
+ U8CPU fAlpha;
+
+ typedef SkSpriteBlitter INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
-#include "SkColorFilter.h"
-#include "SkXfermode.h"
-
class Sprite_D32_XferFilter : public SkSpriteBlitter {
public:
Sprite_D32_XferFilter(const SkBitmap& source, const SkPaint& paint)
@@ -86,6 +80,17 @@
fBufferSize = 0;
fBuffer = NULL;
+
+ unsigned flags32 = 0;
+ if (255 != paint.getAlpha()) {
+ flags32 |= SkBlitRow::kGlobalAlpha_Flag32;
+ }
+ if (!source.isOpaque()) {
+ flags32 |= SkBlitRow::kSrcPixelAlpha_Flag32;
+ }
+
+ fProc32 = SkBlitRow::Factory32(flags32);
+ fAlpha = paint.getAlpha();
}
virtual ~Sprite_D32_XferFilter() {
@@ -107,11 +112,13 @@
}
protected:
- SkColorFilter* fColorFilter;
- SkXfermode* fXfermode;
- int fBufferSize;
- SkPMColor* fBuffer;
-
+ SkColorFilter* fColorFilter;
+ SkXfermode* fXfermode;
+ int fBufferSize;
+ SkPMColor* fBuffer;
+ SkBlitRow::Proc32 fProc32;
+ U8CPU fAlpha;
+
private:
typedef SkSpriteBlitter INHERITED;
};
@@ -144,9 +151,7 @@
if (NULL != xfermode) {
xfermode->xfer32(dst, tmp, width, NULL);
} else {
- for (int i = 0; i < width; i++) {
- dst[i] = SkPMSrcOver(tmp[i], dst[i]);
- }
+ fProc32(dst, tmp, width, fAlpha);
}
dst = (SK_RESTRICT uint32_t*)((char*)dst + dstRB);
@@ -192,9 +197,7 @@
if (NULL != xfermode) {
xfermode->xfer32(dst, buffer, width, NULL);
} else {
- for (int i = 0; i < width; i++) {
- dst[i] = SkPMSrcOver(buffer[i], dst[i]);
- }
+ fProc32(dst, buffer, width, fAlpha);
}
dst = (SK_RESTRICT SkPMColor*)((char*)dst + dstRB);
@@ -273,16 +276,20 @@
SkSpriteBlitter* SkSpriteBlitter::ChooseD32(const SkBitmap& source,
const SkPaint& paint,
void* storage, size_t storageSize) {
- if (paint.getMaskFilter() != NULL || paint.getAlpha() != 0xFF) {
+ if (paint.getMaskFilter() != NULL) {
return NULL;
}
+ U8CPU alpha = paint.getAlpha();
SkXfermode* xfermode = paint.getXfermode();
SkColorFilter* filter = paint.getColorFilter();
SkSpriteBlitter* blitter = NULL;
switch (source.getConfig()) {
case SkBitmap::kARGB_4444_Config:
+ if (alpha != 0xFF) {
+ return NULL; // we only have opaque sprites
+ }
if (xfermode || filter) {
SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S4444_XferFilter,
storage, storageSize, (source, paint));
@@ -296,14 +303,15 @@
break;
case SkBitmap::kARGB_8888_Config:
if (xfermode || filter) {
- SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S32A_XferFilter,
+ if (255 == alpha) {
+ // this can handle xfermode or filter, but not alpha
+ SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S32A_XferFilter,
storage, storageSize, (source, paint));
- } else if (source.isOpaque()) {
- SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S32_Opaque,
- storage, storageSize, (source));
+ }
} else {
- SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S32A_Opaque,
- storage, storageSize, (source));
+ // this can handle alpha, but not xfermode or filter
+ SK_PLACEMENT_NEW_ARGS(blitter, Sprite_D32_S32,
+ storage, storageSize, (source, alpha));
}
break;
default:
diff --git a/src/effects/SkColorFilters.cpp b/src/effects/SkColorFilters.cpp
index 0bb3ae5..733e1ae 100644
--- a/src/effects/SkColorFilters.cpp
+++ b/src/effects/SkColorFilters.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include "SkBlitRow.h"
#include "SkColorFilter.h"
#include "SkColorPriv.h"
#include "SkUtils.h"
@@ -86,12 +87,7 @@
virtual void filterSpan(const SkPMColor shader[], int count,
SkPMColor result[]) {
- SkPMColor src = fPMColor;
- unsigned scale = SkAlpha255To256(255 - SkGetPackedA32(src));
-
- for (int i = 0; i < count; i++) {
- result[i] = src + SkAlphaMulQ(shader[i], scale);
- }
+ SkBlitRow::Color32(result, shader, count, fPMColor);
}
virtual void filterSpan16(const uint16_t shader[], int count,
diff --git a/src/opts/SkBlitRow_opts_arm.cpp b/src/opts/SkBlitRow_opts_arm.cpp
index 9ed6ef5..0c38113 100644
--- a/src/opts/SkBlitRow_opts_arm.cpp
+++ b/src/opts/SkBlitRow_opts_arm.cpp
@@ -443,3 +443,10 @@
NULL, // S32A_D4444_Blend_Dither
};
+const SkBlitRow::Proc32 SkBlitRow::gPlatform_Procs32[] = {
+ NULL, // S32_Opaque,
+ NULL, // S32_Blend,
+ NULL, // S32A_Opaque,
+ NULL, // S32A_Blend,
+};
+
diff --git a/src/opts/SkBlitRow_opts_none.cpp b/src/opts/SkBlitRow_opts_none.cpp
index 88ab7c4..7a77759 100644
--- a/src/opts/SkBlitRow_opts_none.cpp
+++ b/src/opts/SkBlitRow_opts_none.cpp
@@ -30,3 +30,10 @@
NULL, // S32A_D4444_Blend_Dither
};
+const SkBlitRow::Proc32 SkBlitRow::gPlatform_Procs32[] = {
+ NULL, // S32_Opaque,
+ NULL, // S32_Blend,
+ NULL, // S32A_Opaque,
+ NULL, // S32A_Blend,
+};
+
