diff --git a/cpu_ref/Android.mk b/cpu_ref/Android.mk
new file mode 100644
index 0000000..062a916
--- /dev/null
+++ b/cpu_ref/Android.mk
@@ -0,0 +1,51 @@
+
+LOCAL_PATH:=$(call my-dir)
+
+rs_base_CFLAGS := -Werror -Wall -Wno-unused-parameter -Wno-unused-variable
+ifeq ($(TARGET_BUILD_PDK), true)
+  rs_base_CFLAGS += -D__RS_PDK__
+endif
+
+ifneq ($(OVERRIDE_RS_DRIVER),)
+  rs_base_CFLAGS += -DOVERRIDE_RS_DRIVER=$(OVERRIDE_RS_DRIVER)
+endif
+
+include $(CLEAR_VARS)
+LOCAL_CLANG := true
+LOCAL_MODULE := libRSCpuRef
+
+LOCAL_SRC_FILES:= \
+	rsCpuCore.cpp \
+	rsCpuScript.cpp \
+	rsCpuRuntimeMath.cpp \
+	rsCpuRuntimeStubs.cpp \
+	rsCpuScriptGroup.cpp \
+	rsCpuIntrinsic.cpp \
+	rsCpuIntrinsicBlend.cpp \
+	rsCpuIntrinsicBlur.cpp \
+	rsCpuIntrinsicColorMatrix.cpp \
+	rsCpuIntrinsicConvolve3x3.cpp \
+	rsCpuIntrinsicConvolve5x5.cpp \
+	rsCpuIntrinsicLUT.cpp \
+	rsCpuIntrinsicYuvToRGB.cpp
+
+ifeq ($(ARCH_ARM_HAVE_NEON),true)
+    LOCAL_CFLAGS += -DARCH_ARM_HAVE_NEON
+    LOCAL_SRC_FILES+= \
+        rsCpuIntrinsics_neon.S
+endif
+
+LOCAL_SHARED_LIBRARIES += libRS libcutils libutils libsync
+LOCAL_SHARED_LIBRARIES += libbcc libbcinfo
+
+LOCAL_C_INCLUDES += frameworks/compile/libbcc/include
+LOCAL_C_INCLUDES += frameworks/rs
+
+LOCAL_CFLAGS += $(rs_base_CFLAGS)
+
+LOCAL_LDLIBS := -lpthread -ldl
+LOCAL_MODULE_TAGS := optional
+
+include $(BUILD_SHARED_LIBRARY)
+
+
diff --git a/cpu_ref/rsCpuCore.cpp b/cpu_ref/rsCpuCore.cpp
new file mode 100644
index 0000000..29539da
--- /dev/null
+++ b/cpu_ref/rsCpuCore.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsCpuCore.h"
+#include "rsCpuScript.h"
+#include "rsCpuScriptGroup.h"
+
+#include <malloc.h>
+#include "rsContext.h"
+
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sched.h>
+#include <cutils/properties.h>
+#include <sys/syscall.h>
+#include <string.h>
+#include "utils/StopWatch.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+typedef void (*outer_foreach_t)(
+    const android::renderscript::RsForEachStubParamStruct *,
+    uint32_t x1, uint32_t x2,
+    uint32_t instep, uint32_t outstep);
+
+
+static pthread_key_t gThreadTLSKey = 0;
+static uint32_t gThreadTLSKeyCount = 0;
+static pthread_mutex_t gInitMutex = PTHREAD_MUTEX_INITIALIZER;
+
+RsdCpuReference::~RsdCpuReference() {
+}
+
+RsdCpuReference * RsdCpuReference::create(Context *rsc, uint32_t version_major,
+                                          uint32_t version_minor, sym_lookup_t lfn,
+                                          script_lookup_t slfn) {
+
+    RsdCpuReferenceImpl *cpu = new RsdCpuReferenceImpl(rsc);
+    if (!cpu) {
+        return NULL;
+    }
+    if (!cpu->init(version_major, version_minor, lfn, slfn)) {
+        delete cpu;
+        return NULL;
+    }
+    return cpu;
+}
+
+
+Context * RsdCpuReference::getTlsContext() {
+    ScriptTLSStruct * tls = (ScriptTLSStruct *)pthread_getspecific(gThreadTLSKey);
+    return tls->mContext;
+}
+
+const Script * RsdCpuReference::getTlsScript() {
+    ScriptTLSStruct * tls = (ScriptTLSStruct *)pthread_getspecific(gThreadTLSKey);
+    return tls->mScript;
+}
+
+
+////////////////////////////////////////////////////////////
+///
+
+RsdCpuReferenceImpl::RsdCpuReferenceImpl(Context *rsc) {
+    mRSC = rsc;
+
+    version_major = 0;
+    version_minor = 0;
+    mInForEach = false;
+    memset(&mWorkers, 0, sizeof(mWorkers));
+    memset(&mTlsStruct, 0, sizeof(mTlsStruct));
+    mExit = false;
+
+}
+
+
+void * RsdCpuReferenceImpl::helperThreadProc(void *vrsc) {
+    RsdCpuReferenceImpl *dc = (RsdCpuReferenceImpl *)vrsc;
+
+
+    uint32_t idx = (uint32_t)android_atomic_inc(&dc->mWorkers.mLaunchCount);
+
+    //ALOGV("RS helperThread starting %p idx=%i", dc, idx);
+
+    dc->mWorkers.mLaunchSignals[idx].init();
+    dc->mWorkers.mNativeThreadId[idx] = gettid();
+
+    memset(&dc->mTlsStruct, 0, sizeof(dc->mTlsStruct));
+    int status = pthread_setspecific(gThreadTLSKey, &dc->mTlsStruct);
+    if (status) {
+        ALOGE("pthread_setspecific %i", status);
+    }
+
+#if 0
+    typedef struct {uint64_t bits[1024 / 64]; } cpu_set_t;
+    cpu_set_t cpuset;
+    memset(&cpuset, 0, sizeof(cpuset));
+    cpuset.bits[idx / 64] |= 1ULL << (idx % 64);
+    int ret = syscall(241, rsc->mWorkers.mNativeThreadId[idx],
+              sizeof(cpuset), &cpuset);
+    ALOGE("SETAFFINITY ret = %i %s", ret, EGLUtils::strerror(ret));
+#endif
+
+    while (!dc->mExit) {
+        dc->mWorkers.mLaunchSignals[idx].wait();
+        if (dc->mWorkers.mLaunchCallback) {
+           // idx +1 is used because the calling thread is always worker 0.
+           dc->mWorkers.mLaunchCallback(dc->mWorkers.mLaunchData, idx+1);
+        }
+        android_atomic_dec(&dc->mWorkers.mRunningCount);
+        dc->mWorkers.mCompleteSignal.set();
+    }
+
+    //ALOGV("RS helperThread exited %p idx=%i", dc, idx);
+    return NULL;
+}
+
+void RsdCpuReferenceImpl::launchThreads(WorkerCallback_t cbk, void *data) {
+    mWorkers.mLaunchData = data;
+    mWorkers.mLaunchCallback = cbk;
+    android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
+    for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
+        mWorkers.mLaunchSignals[ct].set();
+    }
+
+    // We use the calling thread as one of the workers so we can start without
+    // the delay of the thread wakeup.
+    if (mWorkers.mLaunchCallback) {
+       mWorkers.mLaunchCallback(mWorkers.mLaunchData, 0);
+    }
+
+    while (android_atomic_acquire_load(&mWorkers.mRunningCount) != 0) {
+        mWorkers.mCompleteSignal.wait();
+    }
+}
+
+
+void RsdCpuReferenceImpl::lockMutex() {
+    pthread_mutex_lock(&gInitMutex);
+}
+
+void RsdCpuReferenceImpl::unlockMutex() {
+    pthread_mutex_unlock(&gInitMutex);
+}
+
+bool RsdCpuReferenceImpl::init(uint32_t version_major, uint32_t version_minor,
+                               sym_lookup_t lfn, script_lookup_t slfn) {
+
+    mSymLookupFn = lfn;
+    mScriptLookupFn = slfn;
+
+    lockMutex();
+    if (!gThreadTLSKeyCount) {
+        int status = pthread_key_create(&gThreadTLSKey, NULL);
+        if (status) {
+            ALOGE("Failed to init thread tls key.");
+            unlockMutex();
+            return false;
+        }
+    }
+    gThreadTLSKeyCount++;
+    unlockMutex();
+
+    mTlsStruct.mContext = mRSC;
+    mTlsStruct.mScript = NULL;
+    int status = pthread_setspecific(gThreadTLSKey, &mTlsStruct);
+    if (status) {
+        ALOGE("pthread_setspecific %i", status);
+    }
+
+    int cpu = sysconf(_SC_NPROCESSORS_ONLN);
+    if(mRSC->props.mDebugMaxThreads) {
+        cpu = mRSC->props.mDebugMaxThreads;
+    }
+    if (cpu < 2) {
+        mWorkers.mCount = 0;
+        return true;
+    }
+
+    // Subtract one from the cpu count because we also use the command thread as a worker.
+    mWorkers.mCount = (uint32_t)(cpu - 1);
+
+    ALOGV("%p Launching thread(s), CPUs %i", mRSC, mWorkers.mCount);
+
+    mWorkers.mThreadId = (pthread_t *) calloc(mWorkers.mCount, sizeof(pthread_t));
+    mWorkers.mNativeThreadId = (pid_t *) calloc(mWorkers.mCount, sizeof(pid_t));
+    mWorkers.mLaunchSignals = new Signal[mWorkers.mCount];
+    mWorkers.mLaunchCallback = NULL;
+
+    mWorkers.mCompleteSignal.init();
+
+    android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
+    android_atomic_release_store(0, &mWorkers.mLaunchCount);
+
+    pthread_attr_t threadAttr;
+    status = pthread_attr_init(&threadAttr);
+    if (status) {
+        ALOGE("Failed to init thread attribute.");
+        return false;
+    }
+
+    for (uint32_t ct=0; ct < mWorkers.mCount; ct++) {
+        status = pthread_create(&mWorkers.mThreadId[ct], &threadAttr, helperThreadProc, this);
+        if (status) {
+            mWorkers.mCount = ct;
+            ALOGE("Created fewer than expected number of RS threads.");
+            break;
+        }
+    }
+    while (android_atomic_acquire_load(&mWorkers.mRunningCount) != 0) {
+        usleep(100);
+    }
+
+    pthread_attr_destroy(&threadAttr);
+    return true;
+}
+
+
+void RsdCpuReferenceImpl::setPriority(int32_t priority) {
+    for (uint32_t ct=0; ct < mWorkers.mCount; ct++) {
+        setpriority(PRIO_PROCESS, mWorkers.mNativeThreadId[ct], priority);
+    }
+}
+
+RsdCpuReferenceImpl::~RsdCpuReferenceImpl() {
+    mExit = true;
+    mWorkers.mLaunchData = NULL;
+    mWorkers.mLaunchCallback = NULL;
+    android_atomic_release_store(mWorkers.mCount, &mWorkers.mRunningCount);
+    for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
+        mWorkers.mLaunchSignals[ct].set();
+    }
+    void *res;
+    for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
+        pthread_join(mWorkers.mThreadId[ct], &res);
+    }
+    rsAssert(android_atomic_acquire_load(&mWorkers.mRunningCount) == 0);
+
+    // Global structure cleanup.
+    lockMutex();
+    --gThreadTLSKeyCount;
+    if (!gThreadTLSKeyCount) {
+        pthread_key_delete(gThreadTLSKey);
+    }
+    unlockMutex();
+
+}
+
+typedef void (*rs_t)(const void *, void *, const void *, uint32_t, uint32_t, uint32_t, uint32_t);
+
+static void wc_xy(void *usr, uint32_t idx) {
+    MTLaunchStruct *mtls = (MTLaunchStruct *)usr;
+    RsForEachStubParamStruct p;
+    memcpy(&p, &mtls->fep, sizeof(p));
+    p.lid = idx;
+    uint32_t sig = mtls->sig;
+
+    outer_foreach_t fn = (outer_foreach_t) mtls->kernel;
+    while (1) {
+        uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum);
+        uint32_t yStart = mtls->yStart + slice * mtls->mSliceSize;
+        uint32_t yEnd = yStart + mtls->mSliceSize;
+        yEnd = rsMin(yEnd, mtls->yEnd);
+        if (yEnd <= yStart) {
+            return;
+        }
+
+        //ALOGE("usr idx %i, x %i,%i  y %i,%i", idx, mtls->xStart, mtls->xEnd, yStart, yEnd);
+        //ALOGE("usr ptr in %p,  out %p", mtls->fep.ptrIn, mtls->fep.ptrOut);
+
+        for (p.y = yStart; p.y < yEnd; p.y++) {
+            p.out = mtls->fep.ptrOut + (mtls->fep.yStrideOut * p.y) +
+                    (mtls->fep.eStrideOut * mtls->xStart);
+            p.in = mtls->fep.ptrIn + (mtls->fep.yStrideIn * p.y) +
+                   (mtls->fep.eStrideIn * mtls->xStart);
+            fn(&p, mtls->xStart, mtls->xEnd, mtls->fep.eStrideIn, mtls->fep.eStrideOut);
+        }
+    }
+}
+
+static void wc_x(void *usr, uint32_t idx) {
+    MTLaunchStruct *mtls = (MTLaunchStruct *)usr;
+    RsForEachStubParamStruct p;
+    memcpy(&p, &mtls->fep, sizeof(p));
+    p.lid = idx;
+    uint32_t sig = mtls->sig;
+
+    outer_foreach_t fn = (outer_foreach_t) mtls->kernel;
+    while (1) {
+        uint32_t slice = (uint32_t)android_atomic_inc(&mtls->mSliceNum);
+        uint32_t xStart = mtls->xStart + slice * mtls->mSliceSize;
+        uint32_t xEnd = xStart + mtls->mSliceSize;
+        xEnd = rsMin(xEnd, mtls->xEnd);
+        if (xEnd <= xStart) {
+            return;
+        }
+
+        //ALOGE("usr slice %i idx %i, x %i,%i", slice, idx, xStart, xEnd);
+        //ALOGE("usr ptr in %p,  out %p", mtls->fep.ptrIn, mtls->fep.ptrOut);
+
+        p.out = mtls->fep.ptrOut + (mtls->fep.eStrideOut * xStart);
+        p.in = mtls->fep.ptrIn + (mtls->fep.eStrideIn * xStart);
+        fn(&p, xStart, xEnd, mtls->fep.eStrideIn, mtls->fep.eStrideOut);
+    }
+}
+
+void RsdCpuReferenceImpl::launchThreads(const Allocation * ain, Allocation * aout,
+                                     const RsScriptCall *sc, MTLaunchStruct *mtls) {
+
+    //android::StopWatch kernel_time("kernel time");
+
+    if ((mWorkers.mCount >= 1) && mtls->isThreadable && !mInForEach) {
+        const size_t targetByteChunk = 16 * 1024;
+        mInForEach = true;
+        if (mtls->fep.dimY > 1) {
+            uint32_t s1 = mtls->fep.dimY / ((mWorkers.mCount + 1) * 4);
+            uint32_t s2 = 0;
+
+            // This chooses our slice size to rate limit atomic ops to
+            // one per 16k bytes of reads/writes.
+            if (mtls->fep.yStrideOut) {
+                s2 = targetByteChunk / mtls->fep.yStrideOut;
+            } else {
+                s2 = targetByteChunk / mtls->fep.yStrideIn;
+            }
+            mtls->mSliceSize = rsMin(s1, s2);
+
+            if(mtls->mSliceSize < 1) {
+                mtls->mSliceSize = 1;
+            }
+
+         //   mtls->mSliceSize = 2;
+            launchThreads(wc_xy, mtls);
+        } else {
+            uint32_t s1 = mtls->fep.dimX / ((mWorkers.mCount + 1) * 4);
+            uint32_t s2 = 0;
+
+            // This chooses our slice size to rate limit atomic ops to
+            // one per 16k bytes of reads/writes.
+            if (mtls->fep.eStrideOut) {
+                s2 = targetByteChunk / mtls->fep.eStrideOut;
+            } else {
+                s2 = targetByteChunk / mtls->fep.eStrideIn;
+            }
+            mtls->mSliceSize = rsMin(s1, s2);
+
+            if(mtls->mSliceSize < 1) {
+                mtls->mSliceSize = 1;
+            }
+
+            launchThreads(wc_x, mtls);
+        }
+        mInForEach = false;
+
+        //ALOGE("launch 1");
+    } else {
+        RsForEachStubParamStruct p;
+        memcpy(&p, &mtls->fep, sizeof(p));
+        uint32_t sig = mtls->sig;
+
+        //ALOGE("launch 3");
+        outer_foreach_t fn = (outer_foreach_t) mtls->kernel;
+        for (p.ar[0] = mtls->arrayStart; p.ar[0] < mtls->arrayEnd; p.ar[0]++) {
+            for (p.z = mtls->zStart; p.z < mtls->zEnd; p.z++) {
+                for (p.y = mtls->yStart; p.y < mtls->yEnd; p.y++) {
+                    uint32_t offset = mtls->fep.dimY * mtls->fep.dimZ * p.ar[0] +
+                                      mtls->fep.dimY * p.z + p.y;
+                    p.out = mtls->fep.ptrOut + (mtls->fep.yStrideOut * offset) +
+                            (mtls->fep.eStrideOut * mtls->xStart);
+                    p.in = mtls->fep.ptrIn + (mtls->fep.yStrideIn * offset) +
+                           (mtls->fep.eStrideIn * mtls->xStart);
+                    fn(&p, mtls->xStart, mtls->xEnd, mtls->fep.eStrideIn, mtls->fep.eStrideOut);
+                }
+            }
+        }
+    }
+}
+
+RsdCpuScriptImpl * RsdCpuReferenceImpl::setTLS(RsdCpuScriptImpl *sc) {
+    //ALOGE("setTls %p", sc);
+    ScriptTLSStruct * tls = (ScriptTLSStruct *)pthread_getspecific(gThreadTLSKey);
+    rsAssert(tls);
+    RsdCpuScriptImpl *old = tls->mImpl;
+    tls->mImpl = sc;
+    tls->mContext = mRSC;
+    if (sc) {
+        tls->mScript = sc->getScript();
+    } else {
+        tls->mScript = NULL;
+    }
+    return old;
+}
+
+const RsdCpuReference::CpuSymbol * RsdCpuReferenceImpl::symLookup(const char *name) {
+    return mSymLookupFn(mRSC, name);
+}
+
+
+RsdCpuReference::CpuScript * RsdCpuReferenceImpl::createScript(const ScriptC *s,
+                                    char const *resName, char const *cacheDir,
+                                    uint8_t const *bitcode, size_t bitcodeSize,
+                                    uint32_t flags) {
+
+    RsdCpuScriptImpl *i = new RsdCpuScriptImpl(this, s);
+    if (!i->init(resName, cacheDir, bitcode, bitcodeSize, flags)) {
+        delete i;
+        return NULL;
+    }
+    return i;
+}
+
+extern RsdCpuScriptImpl * rsdIntrinsic_Convolve3x3(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_ColorMatrix(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_LUT(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_Convolve5x5(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_Blur(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_YuvToRGB(RsdCpuReferenceImpl *ctx, const Script *s);
+extern RsdCpuScriptImpl * rsdIntrinsic_Blend(RsdCpuReferenceImpl *ctx, const Script *s);
+
+RsdCpuReference::CpuScript * RsdCpuReferenceImpl::createIntrinsic(const Script *s,
+                                    RsScriptIntrinsicID iid, Element *e) {
+
+    RsdCpuScriptImpl *i = NULL;
+    switch (iid) {
+    case RS_SCRIPT_INTRINSIC_ID_CONVOLVE_3x3:
+        i = rsdIntrinsic_Convolve3x3(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_COLOR_MATRIX:
+        i = rsdIntrinsic_ColorMatrix(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_LUT:
+        i = rsdIntrinsic_LUT(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_CONVOLVE_5x5:
+        i = rsdIntrinsic_Convolve5x5(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_BLUR:
+        i = rsdIntrinsic_Blur(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_YUV_TO_RGB:
+        i = rsdIntrinsic_YuvToRGB(this, s);
+        break;
+    case RS_SCRIPT_INTRINSIC_ID_BLEND:
+        i = rsdIntrinsic_Blend(this, s);
+        break;
+
+    default:
+        rsAssert(0);
+    }
+
+    return i;
+}
+
+RsdCpuReference::CpuScriptGroup * RsdCpuReferenceImpl::createScriptGroup(const ScriptGroup *sg) {
+    CpuScriptGroupImpl *sgi = new CpuScriptGroupImpl(this, sg);
+    if (!sgi->init()) {
+        delete sgi;
+        return NULL;
+    }
+    return sgi;
+}
+
+
diff --git a/cpu_ref/rsCpuCore.h b/cpu_ref/rsCpuCore.h
new file mode 100644
index 0000000..4883591
--- /dev/null
+++ b/cpu_ref/rsCpuCore.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSD_CPU_CORE_H
+#define RSD_CPU_CORE_H
+
+#include "rsd_cpu.h"
+#include "rsSignal.h"
+#include "rsContext.h"
+#include "rsElement.h"
+#include "rsScriptC.h"
+
+namespace bcc {
+    class BCCContext;
+    class RSCompilerDriver;
+    class RSExecutable;
+}
+
+namespace android {
+namespace renderscript {
+
+
+typedef void (* InvokeFunc_t)(void);
+typedef void (* ForEachFunc_t)(void);
+typedef void (*WorkerCallback_t)(void *usr, uint32_t idx);
+
+class RsdCpuScriptImpl;
+class RsdCpuReferenceImpl;
+
+typedef struct ScriptTLSStructRec {
+    android::renderscript::Context * mContext;
+    const android::renderscript::Script * mScript;
+    RsdCpuScriptImpl *mImpl;
+} ScriptTLSStruct;
+
+typedef struct {
+    RsForEachStubParamStruct fep;
+
+    RsdCpuReferenceImpl *rsc;
+    RsdCpuScriptImpl *script;
+
+    ForEachFunc_t kernel;
+    uint32_t sig;
+    const Allocation * ain;
+    Allocation * aout;
+
+    uint32_t mSliceSize;
+    volatile int mSliceNum;
+    bool isThreadable;
+
+    uint32_t xStart;
+    uint32_t xEnd;
+    uint32_t yStart;
+    uint32_t yEnd;
+    uint32_t zStart;
+    uint32_t zEnd;
+    uint32_t arrayStart;
+    uint32_t arrayEnd;
+} MTLaunchStruct;
+
+
+
+
+class RsdCpuReferenceImpl : public RsdCpuReference {
+public:
+    virtual ~RsdCpuReferenceImpl();
+    RsdCpuReferenceImpl(Context *);
+
+    void lockMutex();
+    void unlockMutex();
+
+    bool init(uint32_t version_major, uint32_t version_minor, sym_lookup_t, script_lookup_t);
+    virtual void setPriority(int32_t priority);
+    virtual void launchThreads(WorkerCallback_t cbk, void *data);
+    static void * helperThreadProc(void *vrsc);
+    RsdCpuScriptImpl * setTLS(RsdCpuScriptImpl *sc);
+
+    Context * getContext() {return mRSC;}
+
+    void launchThreads(const Allocation * ain, Allocation * aout,
+                       const RsScriptCall *sc, MTLaunchStruct *mtls);
+
+    virtual CpuScript * createScript(const ScriptC *s,
+                                     char const *resName, char const *cacheDir,
+                                     uint8_t const *bitcode, size_t bitcodeSize,
+                                     uint32_t flags);
+    virtual CpuScript * createIntrinsic(const Script *s,
+                                        RsScriptIntrinsicID iid, Element *e);
+    virtual CpuScriptGroup * createScriptGroup(const ScriptGroup *sg);
+
+    const RsdCpuReference::CpuSymbol *symLookup(const char *);
+
+    RsdCpuReference::CpuScript * lookupScript(const Script *s) {
+        return mScriptLookupFn(mRSC, s);
+    }
+
+
+protected:
+    Context *mRSC;
+    uint32_t version_major;
+    uint32_t version_minor;
+    //bool mHasGraphics;
+    bool mInForEach;
+
+    struct Workers {
+        volatile int mRunningCount;
+        volatile int mLaunchCount;
+        uint32_t mCount;
+        pthread_t *mThreadId;
+        pid_t *mNativeThreadId;
+        Signal mCompleteSignal;
+        Signal *mLaunchSignals;
+        WorkerCallback_t mLaunchCallback;
+        void *mLaunchData;
+    };
+    Workers mWorkers;
+    bool mExit;
+    sym_lookup_t mSymLookupFn;
+    script_lookup_t mScriptLookupFn;
+
+    ScriptTLSStruct mTlsStruct;
+};
+
+
+}
+}
+
+#endif
diff --git a/cpu_ref/rsCpuIntrinsic.cpp b/cpu_ref/rsCpuIntrinsic.cpp
new file mode 100644
index 0000000..a4eef21
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsic.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+RsdCpuScriptIntrinsic::RsdCpuScriptIntrinsic(RsdCpuReferenceImpl *ctx, const Script *s,
+                                             RsScriptIntrinsicID iid)
+        : RsdCpuScriptImpl(ctx, s) {
+
+    mID = iid;
+}
+
+RsdCpuScriptIntrinsic::~RsdCpuScriptIntrinsic() {
+}
+
+void RsdCpuScriptIntrinsic::invokeFunction(uint32_t slot, const void *params, size_t paramLength) {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::invokeFunction");
+}
+
+int RsdCpuScriptIntrinsic::invokeRoot() {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::invokeRoot");
+    return 0;
+}
+
+void RsdCpuScriptIntrinsic::invokeInit() {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::invokeInit");
+}
+
+void RsdCpuScriptIntrinsic::setGlobalVar(uint32_t slot, const void *data, size_t dataLength) {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::setGlobalVar");
+}
+
+void RsdCpuScriptIntrinsic::setGlobalVarWithElemDims(uint32_t slot, const void *data,
+                                                     size_t dataLength, const Element *e,
+                                                     const size_t *dims, size_t dimLength) {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::setGlobalVarWithElemDims");
+}
+
+void RsdCpuScriptIntrinsic::setGlobalBind(uint32_t slot, Allocation *data) {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::setGlobalBind");
+}
+
+void RsdCpuScriptIntrinsic::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    mCtx->getContext()->setError(RS_ERROR_FATAL_DRIVER,
+                                 "Unexpected RsdCpuScriptIntrinsic::setGlobalObj");
+}
+
+void RsdCpuScriptIntrinsic::invokeFreeChildren() {
+}
+
+
+void RsdCpuScriptIntrinsic::invokeForEach(uint32_t slot,
+                                          const Allocation * ain,
+                                          Allocation * aout,
+                                          const void * usr,
+                                          uint32_t usrLen,
+                                          const RsScriptCall *sc) {
+
+    MTLaunchStruct mtls;
+    forEachMtlsSetup(ain, aout, usr, usrLen, sc, &mtls);
+    mtls.script = this;
+    mtls.fep.slot = slot;
+
+    mtls.kernel = (void (*)())mRootPtr;
+    mtls.fep.usr = this;
+
+    RsdCpuScriptImpl * oldTLS = mCtx->setTLS(this);
+    mCtx->launchThreads(ain, aout, sc, &mtls);
+    mCtx->setTLS(oldTLS);
+}
+
+void RsdCpuScriptIntrinsic::forEachKernelSetup(uint32_t slot, MTLaunchStruct *mtls) {
+
+    mtls->script = this;
+    mtls->fep.slot = slot;
+    mtls->kernel = (void (*)())mRootPtr;
+    mtls->fep.usr = this;
+}
+
+
+
diff --git a/cpu_ref/rsCpuIntrinsic.h b/cpu_ref/rsCpuIntrinsic.h
new file mode 100644
index 0000000..1756115
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsic.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSD_CPU_SCRIPT_INTRINSIC_H
+#define RSD_CPU_SCRIPT_INTRINSIC_H
+
+#include "rsCpuScript.h"
+
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsic : public RsdCpuScriptImpl {
+public:
+    virtual void populateScript(Script *) = 0;
+
+    virtual void invokeFunction(uint32_t slot, const void *params, size_t paramLength);
+    virtual int invokeRoot();
+    virtual void invokeForEach(uint32_t slot,
+                       const Allocation * ain,
+                       Allocation * aout,
+                       const void * usr,
+                       uint32_t usrLen,
+                       const RsScriptCall *sc);
+    virtual void forEachKernelSetup(uint32_t slot, MTLaunchStruct *mtls);
+    virtual void invokeInit();
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+    virtual void setGlobalVarWithElemDims(uint32_t slot, const void *data, size_t dataLength,
+                                  const Element *e, const size_t *dims, size_t dimLength);
+    virtual void setGlobalBind(uint32_t slot, Allocation *data);
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsic();
+    RsdCpuScriptIntrinsic(RsdCpuReferenceImpl *ctx, const Script *s, RsScriptIntrinsicID iid);
+
+protected:
+    RsScriptIntrinsicID mID;
+    outer_foreach_t mRootPtr;
+
+};
+
+
+
+}
+}
+
+#endif
diff --git a/cpu_ref/rsCpuIntrinsicBlend.cpp b/cpu_ref/rsCpuIntrinsicBlend.cpp
new file mode 100644
index 0000000..57286d5
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicBlend.cpp
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicBlend : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+
+    virtual ~RsdCpuScriptIntrinsicBlend();
+    RsdCpuScriptIntrinsicBlend(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    static void kernel(const RsForEachStubParamStruct *p,
+                          uint32_t xstart, uint32_t xend,
+                          uint32_t instep, uint32_t outstep);
+};
+
+}
+}
+
+
+enum {
+    BLEND_CLEAR = 0,
+    BLEND_SRC = 1,
+    BLEND_DST = 2,
+    BLEND_SRC_OVER = 3,
+    BLEND_DST_OVER = 4,
+    BLEND_SRC_IN = 5,
+    BLEND_DST_IN = 6,
+    BLEND_SRC_OUT = 7,
+    BLEND_DST_OUT = 8,
+    BLEND_SRC_ATOP = 9,
+    BLEND_DST_ATOP = 10,
+    BLEND_XOR = 11,
+
+    BLEND_NORMAL = 12,
+    BLEND_AVERAGE = 13,
+    BLEND_MULTIPLY = 14,
+    BLEND_SCREEN = 15,
+    BLEND_DARKEN = 16,
+    BLEND_LIGHTEN = 17,
+    BLEND_OVERLAY = 18,
+    BLEND_HARDLIGHT = 19,
+    BLEND_SOFTLIGHT = 20,
+    BLEND_DIFFERENCE = 21,
+    BLEND_NEGATION = 22,
+    BLEND_EXCLUSION = 23,
+    BLEND_COLOR_DODGE = 24,
+    BLEND_INVERSE_COLOR_DODGE = 25,
+    BLEND_SOFT_DODGE = 26,
+    BLEND_COLOR_BURN = 27,
+    BLEND_INVERSE_COLOR_BURN = 28,
+    BLEND_SOFT_BURN = 29,
+    BLEND_REFLECT = 30,
+    BLEND_GLOW = 31,
+    BLEND_FREEZE = 32,
+    BLEND_HEAT = 33,
+    BLEND_ADD = 34,
+    BLEND_SUBTRACT = 35,
+    BLEND_STAMP = 36,
+    BLEND_RED = 37,
+    BLEND_GREEN = 38,
+    BLEND_BLUE = 39,
+    BLEND_HUE = 40,
+    BLEND_SATURATION = 41,
+    BLEND_COLOR = 42,
+    BLEND_LUMINOSITY = 43
+};
+
+extern "C" void rsdIntrinsicBlendSrcOver_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendDstOver_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendSrcIn_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendDstIn_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendSrcOut_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendDstOut_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendSrcAtop_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendDstAtop_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendXor_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendMultiply_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendAdd_K(void *dst, const void *src, uint32_t count8);
+extern "C" void rsdIntrinsicBlendSub_K(void *dst, const void *src, uint32_t count8);
+
+//#undef ARCH_ARM_HAVE_NEON
+
+void RsdCpuScriptIntrinsicBlend::kernel(const RsForEachStubParamStruct *p,
+                                        uint32_t xstart, uint32_t xend,
+                                        uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicBlend *cp = (RsdCpuScriptIntrinsicBlend *)p->usr;
+
+    // instep/outstep can be ignored--sizeof(uchar4) known at compile time
+    uchar4 *out = (uchar4 *)p->out;
+    uchar4 *in = (uchar4 *)p->in;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    switch (p->slot) {
+    case BLEND_CLEAR:
+        for (;x1 < x2; x1++, out++) {
+            *out = 0;
+        }
+        break;
+    case BLEND_SRC:
+        for (;x1 < x2; x1++, out++, in++) {
+          *out = *in;
+        }
+        break;
+    //BLEND_DST is a NOP
+    case BLEND_DST:
+        break;
+    case BLEND_SRC_OVER:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendSrcOver_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            short4 out_s = convert_short4(*out);
+            in_s = in_s + ((out_s * (short4)(255 - in_s.a)) >> (short4)8);
+            *out = convert_uchar4(in_s);
+        }
+        break;
+    case BLEND_DST_OVER:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendDstOver_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            short4 out_s = convert_short4(*out);
+            in_s = out_s + ((in_s * (short4)(255 - out_s.a)) >> (short4)8);
+            *out = convert_uchar4(in_s);
+        }
+        break;
+    case BLEND_SRC_IN:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendSrcIn_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            in_s = (in_s * out->a) >> (short4)8;
+            *out = convert_uchar4(in_s);
+        }
+        break;
+    case BLEND_DST_IN:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendDstIn_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 out_s = convert_short4(*out);
+            out_s = (out_s * in->a) >> (short4)8;
+            *out = convert_uchar4(out_s);
+        }
+        break;
+    case BLEND_SRC_OUT:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendSrcOut_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            in_s = (in_s * (short4)(255 - out->a)) >> (short4)8;
+            *out = convert_uchar4(in_s);
+        }
+        break;
+    case BLEND_DST_OUT:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendDstOut_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 out_s = convert_short4(*out);
+            out_s = (out_s * (short4)(255 - in->a)) >> (short4)8;
+            *out = convert_uchar4(out_s);
+        }
+        break;
+    case BLEND_SRC_ATOP:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendSrcAtop_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            short4 out_s = convert_short4(*out);
+            out_s.rgb = ((in_s.rgb * out_s.a) +
+              (out_s.rgb * ((short3)255 - (short3)in_s.a))) >> (short3)8;
+            *out = convert_uchar4(out_s);
+        }
+        break;
+    case BLEND_DST_ATOP:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendDstAtop_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            short4 in_s = convert_short4(*in);
+            short4 out_s = convert_short4(*out);
+            out_s.rgb = ((out_s.rgb * in_s.a) +
+              (in_s.rgb * ((short3)255 - (short3)out_s.a))) >> (short3)8;
+            *out = convert_uchar4(out_s);
+        }
+        break;
+    case BLEND_XOR:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendXor_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            *out = *in ^ *out;
+        }
+        break;
+    case BLEND_NORMAL:
+        ALOGE("Called unimplemented blend intrinsic BLEND_NORMAL");
+        rsAssert(false);
+        break;
+    case BLEND_AVERAGE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_AVERAGE");
+        rsAssert(false);
+        break;
+    case BLEND_MULTIPLY:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendMultiply_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+          *out = convert_uchar4((convert_short4(*in) * convert_short4(*out))
+                                >> (short4)8);
+        }
+        break;
+    case BLEND_SCREEN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_SCREEN");
+        rsAssert(false);
+        break;
+    case BLEND_DARKEN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_DARKEN");
+        rsAssert(false);
+        break;
+    case BLEND_LIGHTEN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_LIGHTEN");
+        rsAssert(false);
+        break;
+    case BLEND_OVERLAY:
+        ALOGE("Called unimplemented blend intrinsic BLEND_OVERLAY");
+        rsAssert(false);
+        break;
+    case BLEND_HARDLIGHT:
+        ALOGE("Called unimplemented blend intrinsic BLEND_HARDLIGHT");
+        rsAssert(false);
+        break;
+    case BLEND_SOFTLIGHT:
+        ALOGE("Called unimplemented blend intrinsic BLEND_SOFTLIGHT");
+        rsAssert(false);
+        break;
+    case BLEND_DIFFERENCE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_DIFFERENCE");
+        rsAssert(false);
+        break;
+    case BLEND_NEGATION:
+        ALOGE("Called unimplemented blend intrinsic BLEND_NEGATION");
+        rsAssert(false);
+        break;
+    case BLEND_EXCLUSION:
+        ALOGE("Called unimplemented blend intrinsic BLEND_EXCLUSION");
+        rsAssert(false);
+        break;
+    case BLEND_COLOR_DODGE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_COLOR_DODGE");
+        rsAssert(false);
+        break;
+    case BLEND_INVERSE_COLOR_DODGE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_INVERSE_COLOR_DODGE");
+        rsAssert(false);
+        break;
+    case BLEND_SOFT_DODGE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_SOFT_DODGE");
+        rsAssert(false);
+        break;
+    case BLEND_COLOR_BURN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_COLOR_BURN");
+        rsAssert(false);
+        break;
+    case BLEND_INVERSE_COLOR_BURN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_INVERSE_COLOR_BURN");
+        rsAssert(false);
+        break;
+    case BLEND_SOFT_BURN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_SOFT_BURN");
+        rsAssert(false);
+        break;
+    case BLEND_REFLECT:
+        ALOGE("Called unimplemented blend intrinsic BLEND_REFLECT");
+        rsAssert(false);
+        break;
+    case BLEND_GLOW:
+        ALOGE("Called unimplemented blend intrinsic BLEND_GLOW");
+        rsAssert(false);
+        break;
+    case BLEND_FREEZE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_FREEZE");
+        rsAssert(false);
+        break;
+    case BLEND_HEAT:
+        ALOGE("Called unimplemented blend intrinsic BLEND_HEAT");
+        rsAssert(false);
+        break;
+    case BLEND_ADD:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendAdd_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            uint32_t iR = in->r, iG = in->g, iB = in->b, iA = in->a,
+                oR = out->r, oG = out->g, oB = out->b, oA = out->a;
+            out->r = (oR + iR) > 255 ? 255 : oR + iR;
+            out->g = (oG + iG) > 255 ? 255 : oG + iG;
+            out->b = (oB + iB) > 255 ? 255 : oB + iB;
+            out->a = (oA + iA) > 255 ? 255 : oA + iA;
+        }
+        break;
+    case BLEND_SUBTRACT:
+#if defined(ARCH_ARM_HAVE_NEON)
+        if((x1 + 8) < x2) {
+            uint32_t len = (x2 - x1) >> 3;
+            rsdIntrinsicBlendSub_K(out, in, len);
+            x1 += len << 3;
+            out += len << 3;
+            in += len << 3;
+        }
+#endif
+        for (;x1 < x2; x1++, out++, in++) {
+            int32_t iR = in->r, iG = in->g, iB = in->b, iA = in->a,
+                oR = out->r, oG = out->g, oB = out->b, oA = out->a;
+            out->r = (oR - iR) < 0 ? 0 : oR - iR;
+            out->g = (oG - iG) < 0 ? 0 : oG - iG;
+            out->b = (oB - iB) < 0 ? 0 : oB - iB;
+            out->a = (oA - iA) < 0 ? 0 : oA - iA;
+        }
+        break;
+    case BLEND_STAMP:
+        ALOGE("Called unimplemented blend intrinsic BLEND_STAMP");
+        rsAssert(false);
+        break;
+    case BLEND_RED:
+        ALOGE("Called unimplemented blend intrinsic BLEND_RED");
+        rsAssert(false);
+        break;
+    case BLEND_GREEN:
+        ALOGE("Called unimplemented blend intrinsic BLEND_GREEN");
+        rsAssert(false);
+        break;
+    case BLEND_BLUE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_BLUE");
+        rsAssert(false);
+        break;
+    case BLEND_HUE:
+        ALOGE("Called unimplemented blend intrinsic BLEND_HUE");
+        rsAssert(false);
+        break;
+    case BLEND_SATURATION:
+        ALOGE("Called unimplemented blend intrinsic BLEND_SATURATION");
+        rsAssert(false);
+        break;
+    case BLEND_COLOR:
+        ALOGE("Called unimplemented blend intrinsic BLEND_COLOR");
+        rsAssert(false);
+        break;
+    case BLEND_LUMINOSITY:
+        ALOGE("Called unimplemented blend intrinsic BLEND_LUMINOSITY");
+        rsAssert(false);
+        break;
+
+    default:
+        ALOGE("Called unimplemented value %d", p->slot);
+        rsAssert(false);
+
+    }
+}
+
+
+RsdCpuScriptIntrinsicBlend::RsdCpuScriptIntrinsicBlend(RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_BLEND) {
+
+    mRootPtr = &kernel;
+}
+
+RsdCpuScriptIntrinsicBlend::~RsdCpuScriptIntrinsicBlend() {
+}
+
+void RsdCpuScriptIntrinsicBlend::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 0;
+}
+
+RsdCpuScriptImpl * rsdIntrinsic_Blend(RsdCpuReferenceImpl *ctx, const Script *s) {
+    return new RsdCpuScriptIntrinsicBlend(ctx, s);
+}
+
+
+
diff --git a/cpu_ref/rsCpuIntrinsicBlur.cpp b/cpu_ref/rsCpuIntrinsicBlur.cpp
new file mode 100644
index 0000000..48363d1
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicBlur.cpp
@@ -0,0 +1,251 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicBlur : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsicBlur();
+    RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    float fp[104];
+    short ip[104];
+    float radius;
+    int iradius;
+    ObjectBaseRef<Allocation> alloc;
+
+    static void kernel(const RsForEachStubParamStruct *p,
+                       uint32_t xstart, uint32_t xend,
+                       uint32_t instep, uint32_t outstep);
+    void ComputeGaussianWeights();
+};
+
+}
+}
+
+
+void RsdCpuScriptIntrinsicBlur::ComputeGaussianWeights() {
+    // Compute gaussian weights for the blur
+    // e is the euler's number
+    float e = 2.718281828459045f;
+    float pi = 3.1415926535897932f;
+    // g(x) = ( 1 / sqrt( 2 * pi ) * sigma) * e ^ ( -x^2 / 2 * sigma^2 )
+    // x is of the form [-radius .. 0 .. radius]
+    // and sigma varies with radius.
+    // Based on some experimental radius values and sigma's
+    // we approximately fit sigma = f(radius) as
+    // sigma = radius * 0.4  + 0.6
+    // The larger the radius gets, the more our gaussian blur
+    // will resemble a box blur since with large sigma
+    // the gaussian curve begins to lose its shape
+    float sigma = 0.4f * radius + 0.6f;
+
+    // Now compute the coefficients. We will store some redundant values to save
+    // some math during the blur calculations precompute some values
+    float coeff1 = 1.0f / (sqrtf(2.0f * pi) * sigma);
+    float coeff2 = - 1.0f / (2.0f * sigma * sigma);
+
+    float normalizeFactor = 0.0f;
+    float floatR = 0.0f;
+    int r;
+    iradius = (float)ceil(radius) + 0.5f;
+    for (r = -iradius; r <= iradius; r ++) {
+        floatR = (float)r;
+        fp[r + iradius] = coeff1 * powf(e, floatR * floatR * coeff2);
+        normalizeFactor += fp[r + iradius];
+    }
+
+    //Now we need to normalize the weights because all our coefficients need to add up to one
+    normalizeFactor = 1.0f / normalizeFactor;
+    for (r = -iradius; r <= iradius; r ++) {
+        fp[r + iradius] *= normalizeFactor;
+        ip[r + iradius] = (short)(ip[r + iradius] * 32768);
+    }
+}
+
+void RsdCpuScriptIntrinsicBlur::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    rsAssert(slot == 1);
+    alloc.set(static_cast<Allocation *>(data));
+}
+
+void RsdCpuScriptIntrinsicBlur::setGlobalVar(uint32_t slot, const void *data, size_t dataLength) {
+    rsAssert(slot == 0);
+    radius = ((const float *)data)[0];
+    ComputeGaussianWeights();
+}
+
+
+
+static void OneV(const RsForEachStubParamStruct *p, float4 *out, int32_t x, int32_t y,
+                 const uchar *ptrIn, int iStride, const float* gPtr, int iradius) {
+
+    const uchar *pi = ptrIn + x*4;
+
+    float4 blurredPixel = 0;
+    for (int r = -iradius; r <= iradius; r ++) {
+        int validY = rsMax((y + r), 0);
+        validY = rsMin(validY, (int)(p->dimY - 1));
+        const uchar4 *pvy = (const uchar4 *)&pi[validY * iStride];
+        float4 pf = convert_float4(pvy[0]);
+        blurredPixel += pf * gPtr[0];
+        gPtr++;
+    }
+
+    out->xyzw = blurredPixel;
+}
+
+extern "C" void rsdIntrinsicBlurVF_K(void *dst, const void *pin, int stride, const void *gptr, int rct, int x1, int x2);
+extern "C" void rsdIntrinsicBlurHF_K(void *dst, const void *pin, const void *gptr, int rct, int x1, int x2);
+
+static void OneVF(float4 *out,
+                  const uchar *ptrIn, int iStride, const float* gPtr, int ct,
+                  int x1, int x2) {
+
+#if defined(ARCH_ARM_HAVE_NEON)
+    {
+        int t = (x2 - x1);
+        t &= ~1;
+        if(t) {
+            rsdIntrinsicBlurVF_K(out, ptrIn, iStride, gPtr, ct, x1, x1 + t);
+        }
+        x1 += t;
+    }
+#endif
+
+    while(x2 > x1) {
+        const uchar *pi = ptrIn;
+        float4 blurredPixel = 0;
+        const float* gp = gPtr;
+
+        for (int r = 0; r < ct; r++) {
+            float4 pf = convert_float4(((const uchar4 *)pi)[0]);
+            blurredPixel += pf * gp[0];
+            pi += iStride;
+            gp++;
+        }
+        out->xyzw = blurredPixel;
+        x1++;
+        out++;
+    }
+}
+
+static void OneH(const RsForEachStubParamStruct *p, uchar4 *out, int32_t x,
+                const float4 *ptrIn, const float* gPtr, int iradius) {
+
+    float4 blurredPixel = 0;
+    for (int r = -iradius; r <= iradius; r ++) {
+        int validX = rsMax((x + r), 0);
+        validX = rsMin(validX, (int)(p->dimX - 1));
+        float4 pf = ptrIn[validX];
+        blurredPixel += pf * gPtr[0];
+        gPtr++;
+    }
+
+    out->xyzw = convert_uchar4(blurredPixel);
+}
+
+
+void RsdCpuScriptIntrinsicBlur::kernel(const RsForEachStubParamStruct *p,
+                                       uint32_t xstart, uint32_t xend,
+                                       uint32_t instep, uint32_t outstep) {
+    float buf[4 * 2048];
+    RsdCpuScriptIntrinsicBlur *cp = (RsdCpuScriptIntrinsicBlur *)p->usr;
+    if (!cp->alloc.get()) {
+        ALOGE("Blur executed without input, skipping");
+        return;
+    }
+    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
+    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
+
+    uchar4 *out = (uchar4 *)p->out;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    float4 *fout = (float4 *)buf;
+    int y = p->y;
+    if ((y > cp->iradius) && (y < ((int)p->dimY - cp->iradius))) {
+        const uchar *pi = pin + (y - cp->iradius) * stride;
+        OneVF(fout, pi, stride, cp->fp, cp->iradius * 2 + 1, x1, x2);
+    } else {
+        while(x2 > x1) {
+            OneV(p, fout, x1, y, pin, stride, cp->fp, cp->iradius);
+            fout++;
+            x1++;
+        }
+    }
+
+    x1 = xstart;
+    while ((x1 < (uint32_t)cp->iradius) && (x1 < x2)) {
+        OneH(p, out, x1, (float4 *)buf, cp->fp, cp->iradius);
+        out++;
+        x1++;
+    }
+#if defined(ARCH_ARM_HAVE_NEON)
+    if ((x1 + cp->iradius) < x2) {
+        rsdIntrinsicBlurHF_K(out, ((float4 *)buf) - cp->iradius, cp->fp, cp->iradius * 2 + 1, x1, x2 - cp->iradius);
+        out += (x2 - cp->iradius) - x1;
+        x1 = x2 - cp->iradius;
+    }
+#endif
+    while(x2 > x1) {
+        OneH(p, out, x1, (float4 *)buf, cp->fp, cp->iradius);
+        out++;
+        x1++;
+    }
+
+}
+
+RsdCpuScriptIntrinsicBlur::RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_BLUR) {
+
+    mRootPtr = &kernel;
+    radius = 5;
+    ComputeGaussianWeights();
+}
+
+RsdCpuScriptIntrinsicBlur::~RsdCpuScriptIntrinsicBlur() {
+}
+
+void RsdCpuScriptIntrinsicBlur::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 2;
+}
+
+void RsdCpuScriptIntrinsicBlur::invokeFreeChildren() {
+    alloc.clear();
+}
+
+
+RsdCpuScriptImpl * rsdIntrinsic_Blur(RsdCpuReferenceImpl *ctx, const Script *s) {
+
+    return new RsdCpuScriptIntrinsicBlur(ctx, s);
+}
+
+
diff --git a/cpu_ref/rsCpuIntrinsicColorMatrix.cpp b/cpu_ref/rsCpuIntrinsicColorMatrix.cpp
new file mode 100644
index 0000000..8f3196d
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicColorMatrix.cpp
@@ -0,0 +1,219 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicColorMatrix : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+
+    virtual ~RsdCpuScriptIntrinsicColorMatrix();
+    RsdCpuScriptIntrinsicColorMatrix(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    float fp[16];
+    short ip[16];
+
+    static void kernel4x4(const RsForEachStubParamStruct *p,
+                          uint32_t xstart, uint32_t xend,
+                          uint32_t instep, uint32_t outstep);
+    static void kernel3x3(const RsForEachStubParamStruct *p,
+                          uint32_t xstart, uint32_t xend,
+                          uint32_t instep, uint32_t outstep);
+    static void kernelDot(const RsForEachStubParamStruct *p,
+                          uint32_t xstart, uint32_t xend,
+                          uint32_t instep, uint32_t outstep);
+};
+
+}
+}
+
+
+void RsdCpuScriptIntrinsicColorMatrix::setGlobalVar(uint32_t slot, const void *data,
+                                                    size_t dataLength) {
+    rsAssert(slot == 0);
+    memcpy (fp, data, dataLength);
+    for(int ct=0; ct < 16; ct++) {
+        ip[ct] = (short)(fp[ct] * 255.f + 0.5f);
+    }
+
+    mRootPtr = &kernel4x4;
+    if ((ip[3] == 0) && (ip[7] == 0) && (ip[11] == 0) &&
+        (ip[12] == 0) && (ip[13] == 0) && (ip[14] == 0) && (ip[15] == 255)) {
+        mRootPtr = &kernel3x3;
+
+        if ((ip[0] == ip[1]) && (ip[0] == ip[2]) &&
+            (ip[4] == ip[5]) && (ip[4] == ip[6]) &&
+            (ip[8] == ip[9]) && (ip[8] == ip[10])) {
+            mRootPtr = &kernelDot;
+        }
+    }
+}
+
+extern "C" void rsdIntrinsicColorMatrix4x4_K(void *dst, const void *src, const short *coef, uint32_t count);
+extern "C" void rsdIntrinsicColorMatrix3x3_K(void *dst, const void *src, const short *coef, uint32_t count);
+extern "C" void rsdIntrinsicColorMatrixDot_K(void *dst, const void *src, const short *coef, uint32_t count);
+
+static void One(const RsForEachStubParamStruct *p, uchar4 *out,
+                const uchar4 *py, const float* coeff) {
+    float4 i = convert_float4(py[0]);
+
+    float4 sum;
+    sum.x = i.x * coeff[0] +
+            i.y * coeff[4] +
+            i.z * coeff[8] +
+            i.w * coeff[12];
+    sum.y = i.x * coeff[1] +
+            i.y * coeff[5] +
+            i.z * coeff[9] +
+            i.w * coeff[13];
+    sum.z = i.x * coeff[2] +
+            i.y * coeff[6] +
+            i.z * coeff[10] +
+            i.w * coeff[14];
+    sum.w = i.x * coeff[3] +
+            i.y * coeff[7] +
+            i.z * coeff[11] +
+            i.w * coeff[15];
+
+    sum.x = sum.x < 0 ? 0 : (sum.x > 255 ? 255 : sum.x);
+    sum.y = sum.y < 0 ? 0 : (sum.y > 255 ? 255 : sum.y);
+    sum.z = sum.z < 0 ? 0 : (sum.z > 255 ? 255 : sum.z);
+    sum.w = sum.w < 0 ? 0 : (sum.w > 255 ? 255 : sum.w);
+
+    *out = convert_uchar4(sum);
+}
+
+void RsdCpuScriptIntrinsicColorMatrix::kernel4x4(const RsForEachStubParamStruct *p,
+                                                 uint32_t xstart, uint32_t xend,
+                                                 uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicColorMatrix *cp = (RsdCpuScriptIntrinsicColorMatrix *)p->usr;
+    uchar4 *out = (uchar4 *)p->out;
+    uchar4 *in = (uchar4 *)p->in;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    if(x2 > x1) {
+#if defined(ARCH_ARM_HAVE_NEON)
+        int32_t len = (x2 - x1) >> 2;
+        if(len > 0) {
+            rsdIntrinsicColorMatrix4x4_K(out, in, cp->ip, len);
+            x1 += len << 2;
+            out += len << 2;
+            in += len << 2;
+        }
+#endif
+
+        while(x1 != x2) {
+            One(p, out++, in++, cp->fp);
+            x1++;
+        }
+    }
+}
+
+void RsdCpuScriptIntrinsicColorMatrix::kernel3x3(const RsForEachStubParamStruct *p,
+                                                 uint32_t xstart, uint32_t xend,
+                                                 uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicColorMatrix *cp = (RsdCpuScriptIntrinsicColorMatrix *)p->usr;
+    uchar4 *out = (uchar4 *)p->out;
+    uchar4 *in = (uchar4 *)p->in;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    if(x2 > x1) {
+#if defined(ARCH_ARM_HAVE_NEON)
+        int32_t len = (x2 - x1) >> 2;
+        if(len > 0) {
+            rsdIntrinsicColorMatrix3x3_K(out, in, cp->ip, len);
+            x1 += len << 2;
+            out += len << 2;
+            in += len << 2;
+        }
+#endif
+
+        while(x1 != x2) {
+            One(p, out++, in++, cp->fp);
+            x1++;
+        }
+    }
+}
+
+void RsdCpuScriptIntrinsicColorMatrix::kernelDot(const RsForEachStubParamStruct *p,
+                                                 uint32_t xstart, uint32_t xend,
+                                                 uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicColorMatrix *cp = (RsdCpuScriptIntrinsicColorMatrix *)p->usr;
+    uchar4 *out = (uchar4 *)p->out;
+    uchar4 *in = (uchar4 *)p->in;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    if(x2 > x1) {
+#if defined(ARCH_ARM_HAVE_NEON)
+        int32_t len = (x2 - x1) >> 2;
+        if(len > 0) {
+            rsdIntrinsicColorMatrixDot_K(out, in, cp->ip, len);
+            x1 += len << 2;
+            out += len << 2;
+            in += len << 2;
+        }
+#endif
+
+        while(x1 != x2) {
+            One(p, out++, in++, cp->fp);
+            x1++;
+        }
+    }
+}
+
+
+RsdCpuScriptIntrinsicColorMatrix::RsdCpuScriptIntrinsicColorMatrix(
+            RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_COLOR_MATRIX) {
+
+    const static float defaultMatrix[] = {
+        1.f, 0.f, 0.f, 0.f,
+        0.f, 1.f, 0.f, 0.f,
+        0.f, 0.f, 1.f, 0.f,
+        0.f, 0.f, 0.f, 1.f
+    };
+    setGlobalVar(0, defaultMatrix, sizeof(defaultMatrix));
+}
+
+RsdCpuScriptIntrinsicColorMatrix::~RsdCpuScriptIntrinsicColorMatrix() {
+}
+
+void RsdCpuScriptIntrinsicColorMatrix::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 1;
+}
+
+RsdCpuScriptImpl * rsdIntrinsic_ColorMatrix(RsdCpuReferenceImpl *ctx, const Script *s) {
+
+    return new RsdCpuScriptIntrinsicColorMatrix(ctx, s);
+}
+
+
+
diff --git a/cpu_ref/rsCpuIntrinsicConvolve3x3.cpp b/cpu_ref/rsCpuIntrinsicConvolve3x3.cpp
new file mode 100644
index 0000000..18a5311
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicConvolve3x3.cpp
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicConvolve3x3 : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsicConvolve3x3();
+    RsdCpuScriptIntrinsicConvolve3x3(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    float fp[16];
+    short ip[16];
+    ObjectBaseRef<Allocation> alloc;
+
+    static void kernel(const RsForEachStubParamStruct *p,
+                       uint32_t xstart, uint32_t xend,
+                       uint32_t instep, uint32_t outstep);
+};
+
+}
+}
+
+
+void RsdCpuScriptIntrinsicConvolve3x3::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    rsAssert(slot == 1);
+    alloc.set(static_cast<Allocation *>(data));
+}
+
+void RsdCpuScriptIntrinsicConvolve3x3::setGlobalVar(uint32_t slot, const void *data,
+                                                    size_t dataLength) {
+    rsAssert(slot == 0);
+    memcpy (&fp, data, dataLength);
+    for(int ct=0; ct < 9; ct++) {
+        ip[ct] = (short)(fp[ct] * 255.f + 0.5f);
+    }
+}
+
+extern "C" void rsdIntrinsicConvolve3x3_K(void *dst, const void *y0, const void *y1,
+                                          const void *y2, const short *coef, uint32_t count);
+
+
+static void ConvolveOne(const RsForEachStubParamStruct *p, uint32_t x, uchar4 *out,
+                        const uchar4 *py0, const uchar4 *py1, const uchar4 *py2,
+                        const float* coeff) {
+
+    uint32_t x1 = rsMax((int32_t)x-1, 0);
+    uint32_t x2 = rsMin((int32_t)x+1, (int32_t)p->dimX);
+
+    float4 px = convert_float4(py0[x1]) * coeff[0] +
+                convert_float4(py0[x]) * coeff[1] +
+                convert_float4(py0[x2]) * coeff[2] +
+                convert_float4(py1[x1]) * coeff[3] +
+                convert_float4(py1[x]) * coeff[4] +
+                convert_float4(py1[x2]) * coeff[5] +
+                convert_float4(py2[x1]) * coeff[6] +
+                convert_float4(py2[x]) * coeff[7] +
+                convert_float4(py2[x2]) * coeff[8];
+
+    px = clamp(px, 0.f, 255.f);
+    uchar4 o = {(uchar)px.x, (uchar)px.y, (uchar)px.z, (uchar)px.w};
+    *out = o;
+}
+
+void RsdCpuScriptIntrinsicConvolve3x3::kernel(const RsForEachStubParamStruct *p,
+                                              uint32_t xstart, uint32_t xend,
+                                              uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicConvolve3x3 *cp = (RsdCpuScriptIntrinsicConvolve3x3 *)p->usr;
+
+    if (!cp->alloc.get()) {
+        ALOGE("Convolve3x3 executed without input, skipping");
+        return;
+    }
+    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
+    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
+
+    uint32_t y1 = rsMin((int32_t)p->y + 1, (int32_t)(p->dimY-1));
+    uint32_t y2 = rsMax((int32_t)p->y - 1, 0);
+    const uchar4 *py0 = (const uchar4 *)(pin + stride * y2);
+    const uchar4 *py1 = (const uchar4 *)(pin + stride * p->y);
+    const uchar4 *py2 = (const uchar4 *)(pin + stride * y1);
+
+    uchar4 *out = (uchar4 *)p->out;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+    if(x1 == 0) {
+        ConvolveOne(p, 0, out, py0, py1, py2, cp->fp);
+        x1 ++;
+        out++;
+    }
+
+    if(x2 > x1) {
+#if defined(ARCH_ARM_HAVE_NEON)
+        int32_t len = (x2 - x1 - 1) >> 1;
+        if(len > 0) {
+            rsdIntrinsicConvolve3x3_K(out, &py0[x1-1], &py1[x1-1], &py2[x1-1], cp->ip, len);
+            x1 += len << 1;
+            out += len << 1;
+        }
+#endif
+
+        while(x1 != x2) {
+            ConvolveOne(p, x1, out, py0, py1, py2, cp->fp);
+            out++;
+            x1++;
+        }
+    }
+}
+
+RsdCpuScriptIntrinsicConvolve3x3::RsdCpuScriptIntrinsicConvolve3x3(
+            RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_CONVOLVE_3x3) {
+
+    mRootPtr = &kernel;
+    for(int ct=0; ct < 9; ct++) {
+        fp[ct] = 1.f / 9.f;
+        ip[ct] = (short)(fp[ct] * 255.f + 0.5f);
+    }
+}
+
+RsdCpuScriptIntrinsicConvolve3x3::~RsdCpuScriptIntrinsicConvolve3x3() {
+}
+
+void RsdCpuScriptIntrinsicConvolve3x3::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 2;
+}
+
+void RsdCpuScriptIntrinsicConvolve3x3::invokeFreeChildren() {
+    alloc.clear();
+}
+
+
+RsdCpuScriptImpl * rsdIntrinsic_Convolve3x3(RsdCpuReferenceImpl *ctx, const Script *s) {
+
+    return new RsdCpuScriptIntrinsicConvolve3x3(ctx, s);
+}
+
+
diff --git a/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp b/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp
new file mode 100644
index 0000000..2cae2c0
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicConvolve5x5.cpp
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicConvolve5x5 : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsicConvolve5x5();
+    RsdCpuScriptIntrinsicConvolve5x5(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    float fp[28];
+    short ip[28];
+    ObjectBaseRef<Allocation> alloc;
+
+
+    static void kernel(const RsForEachStubParamStruct *p,
+                       uint32_t xstart, uint32_t xend,
+                       uint32_t instep, uint32_t outstep);
+
+
+};
+
+}
+}
+
+void RsdCpuScriptIntrinsicConvolve5x5::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    rsAssert(slot == 1);
+    alloc.set(static_cast<Allocation *>(data));
+}
+
+void RsdCpuScriptIntrinsicConvolve5x5::setGlobalVar(uint32_t slot,
+                                                    const void *data, size_t dataLength) {
+    rsAssert(slot == 0);
+    memcpy (&fp, data, dataLength);
+    for(int ct=0; ct < 25; ct++) {
+        ip[ct] = (short)(fp[ct] * 255.f + 0.5f);
+    }
+}
+
+
+static void One(const RsForEachStubParamStruct *p, uint32_t x, uchar4 *out,
+                const uchar4 *py0, const uchar4 *py1, const uchar4 *py2, const uchar4 *py3, const uchar4 *py4,
+                const float* coeff) {
+
+    uint32_t x0 = rsMax((int32_t)x-2, 0);
+    uint32_t x1 = rsMax((int32_t)x-1, 0);
+    uint32_t x2 = x;
+    uint32_t x3 = rsMin((int32_t)x+1, (int32_t)(p->dimX-1));
+    uint32_t x4 = rsMin((int32_t)x+2, (int32_t)(p->dimX-1));
+
+    float4 px = convert_float4(py0[x0]) * coeff[0] +
+                convert_float4(py0[x1]) * coeff[1] +
+                convert_float4(py0[x2]) * coeff[2] +
+                convert_float4(py0[x3]) * coeff[3] +
+                convert_float4(py0[x4]) * coeff[4] +
+
+                convert_float4(py1[x0]) * coeff[5] +
+                convert_float4(py1[x1]) * coeff[6] +
+                convert_float4(py1[x2]) * coeff[7] +
+                convert_float4(py1[x3]) * coeff[8] +
+                convert_float4(py1[x4]) * coeff[9] +
+
+                convert_float4(py2[x0]) * coeff[10] +
+                convert_float4(py2[x1]) * coeff[11] +
+                convert_float4(py2[x2]) * coeff[12] +
+                convert_float4(py2[x3]) * coeff[13] +
+                convert_float4(py2[x4]) * coeff[14] +
+
+                convert_float4(py3[x0]) * coeff[15] +
+                convert_float4(py3[x1]) * coeff[16] +
+                convert_float4(py3[x2]) * coeff[17] +
+                convert_float4(py3[x3]) * coeff[18] +
+                convert_float4(py3[x4]) * coeff[19] +
+
+                convert_float4(py4[x0]) * coeff[20] +
+                convert_float4(py4[x1]) * coeff[21] +
+                convert_float4(py4[x2]) * coeff[22] +
+                convert_float4(py4[x3]) * coeff[23] +
+                convert_float4(py4[x4]) * coeff[24];
+
+    px = clamp(px, 0.f, 255.f);
+    uchar4 o = {(uchar)px.x, (uchar)px.y, (uchar)px.z, (uchar)px.w};
+    *out = o;
+}
+
+extern "C" void rsdIntrinsicConvolve5x5_K(void *dst, const void *y0, const void *y1,
+                                          const void *y2, const void *y3, const void *y4,
+                                          const short *coef, uint32_t count);
+
+void RsdCpuScriptIntrinsicConvolve5x5::kernel(const RsForEachStubParamStruct *p,
+                                              uint32_t xstart, uint32_t xend,
+                                              uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicConvolve5x5 *cp = (RsdCpuScriptIntrinsicConvolve5x5 *)p->usr;
+    if (!cp->alloc.get()) {
+        ALOGE("Convolve5x5 executed without input, skipping");
+        return;
+    }
+    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
+    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
+
+    uint32_t y0 = rsMax((int32_t)p->y-2, 0);
+    uint32_t y1 = rsMax((int32_t)p->y-1, 0);
+    uint32_t y2 = p->y;
+    uint32_t y3 = rsMin((int32_t)p->y+1, (int32_t)(p->dimY-1));
+    uint32_t y4 = rsMin((int32_t)p->y+2, (int32_t)(p->dimY-1));
+
+    const uchar4 *py0 = (const uchar4 *)(pin + stride * y0);
+    const uchar4 *py1 = (const uchar4 *)(pin + stride * y1);
+    const uchar4 *py2 = (const uchar4 *)(pin + stride * y2);
+    const uchar4 *py3 = (const uchar4 *)(pin + stride * y3);
+    const uchar4 *py4 = (const uchar4 *)(pin + stride * y4);
+
+    uchar4 *out = (uchar4 *)p->out;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    while((x1 < x2) && (x1 < 2)) {
+        One(p, x1, out, py0, py1, py2, py3, py4, cp->fp);
+        out++;
+        x1++;
+    }
+
+#if defined(ARCH_ARM_HAVE_NEON)
+    if((x1 + 3) < x2) {
+        uint32_t len = (x2 - x1 - 3) >> 1;
+        rsdIntrinsicConvolve5x5_K(out, py0, py1, py2, py3, py4, cp->ip, len);
+        out += len << 1;
+        x1 += len << 1;
+    }
+#endif
+
+    while(x1 < x2) {
+        One(p, x1, out, py0, py1, py2, py3, py4, cp->fp);
+        out++;
+        x1++;
+    }
+}
+
+
+RsdCpuScriptIntrinsicConvolve5x5::RsdCpuScriptIntrinsicConvolve5x5(
+            RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_CONVOLVE_5x5) {
+
+    mRootPtr = &kernel;
+    for(int ct=0; ct < 9; ct++) {
+        fp[ct] = 1.f / 25.f;
+        ip[ct] = (short)(fp[ct] * 255.f + 0.5f);
+    }
+}
+
+RsdCpuScriptIntrinsicConvolve5x5::~RsdCpuScriptIntrinsicConvolve5x5() {
+}
+
+void RsdCpuScriptIntrinsicConvolve5x5::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 2;
+}
+
+void RsdCpuScriptIntrinsicConvolve5x5::invokeFreeChildren() {
+    alloc.clear();
+}
+
+
+RsdCpuScriptImpl * rsdIntrinsic_Convolve5x5(RsdCpuReferenceImpl *ctx, const Script *s) {
+
+    return new RsdCpuScriptIntrinsicConvolve5x5(ctx, s);
+}
+
+
+
diff --git a/cpu_ref/rsCpuIntrinsicInlines.h b/cpu_ref/rsCpuIntrinsicInlines.h
new file mode 100644
index 0000000..ab11b4f
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicInlines.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+typedef uint8_t uchar;
+typedef uint16_t ushort;
+typedef uint32_t uint;
+
+typedef float float2 __attribute__((ext_vector_type(2)));
+typedef float float3 __attribute__((ext_vector_type(3)));
+typedef float float4 __attribute__((ext_vector_type(4)));
+typedef uchar uchar2 __attribute__((ext_vector_type(2)));
+typedef uchar uchar3 __attribute__((ext_vector_type(3)));
+typedef uchar uchar4 __attribute__((ext_vector_type(4)));
+typedef ushort ushort2 __attribute__((ext_vector_type(2)));
+typedef ushort ushort3 __attribute__((ext_vector_type(3)));
+typedef ushort ushort4 __attribute__((ext_vector_type(4)));
+typedef uint uint2 __attribute__((ext_vector_type(2)));
+typedef uint uint3 __attribute__((ext_vector_type(3)));
+typedef uint uint4 __attribute__((ext_vector_type(4)));
+typedef char char2 __attribute__((ext_vector_type(2)));
+typedef char char3 __attribute__((ext_vector_type(3)));
+typedef char char4 __attribute__((ext_vector_type(4)));
+typedef short short2 __attribute__((ext_vector_type(2)));
+typedef short short3 __attribute__((ext_vector_type(3)));
+typedef short short4 __attribute__((ext_vector_type(4)));
+typedef int int2 __attribute__((ext_vector_type(2)));
+typedef int int3 __attribute__((ext_vector_type(3)));
+typedef int int4 __attribute__((ext_vector_type(4)));
+typedef long long2 __attribute__((ext_vector_type(2)));
+typedef long long3 __attribute__((ext_vector_type(3)));
+typedef long long4 __attribute__((ext_vector_type(4)));
+
+enum IntrinsicEnums {
+    INTRINSIC_UNDEFINED,
+    INTRINSIC_CONVOLVE_3x3,
+    INTRINXIC_COLORMATRIX
+
+};
+
+static inline int4 convert_int4(uchar4 i) {
+    int4 f4 = {i.x, i.y, i.z, i.w};
+    return f4;
+}
+
+static inline short4 convert_short4(uchar4 i) {
+    short4 f4 = {i.x, i.y, i.z, i.w};
+    return f4;
+}
+
+static inline float4 convert_float4(uchar4 i) {
+    float4 f4 = {i.x, i.y, i.z, i.w};
+    return f4;
+}
+
+static inline uchar4 convert_uchar4(short4 i) {
+    uchar4 f4 = {(uchar)i.x, (uchar)i.y, (uchar)i.z, (uchar)i.w};
+    return f4;
+}
+
+static inline uchar4 convert_uchar4(int4 i) {
+    uchar4 f4 = {(uchar)i.x, (uchar)i.y, (uchar)i.z, (uchar)i.w};
+    return f4;
+}
+
+static inline uchar4 convert_uchar4(float4 i) {
+    uchar4 f4 = {(uchar)i.x, (uchar)i.y, (uchar)i.z, (uchar)i.w};
+    return f4;
+}
+
+
+static inline int4 clamp(int4 amount, int low, int high) {
+    int4 r;
+    r.x = amount.x < low ? low : (amount.x > high ? high : amount.x);
+    r.y = amount.y < low ? low : (amount.y > high ? high : amount.y);
+    r.z = amount.z < low ? low : (amount.z > high ? high : amount.z);
+    r.w = amount.w < low ? low : (amount.w > high ? high : amount.w);
+    return r;
+}
+
+static inline float4 clamp(float4 amount, float low, float high) {
+    float4 r;
+    r.x = amount.x < low ? low : (amount.x > high ? high : amount.x);
+    r.y = amount.y < low ? low : (amount.y > high ? high : amount.y);
+    r.z = amount.z < low ? low : (amount.z > high ? high : amount.z);
+    r.w = amount.w < low ? low : (amount.w > high ? high : amount.w);
+    return r;
+}
+
+
diff --git a/cpu_ref/rsCpuIntrinsicLUT.cpp b/cpu_ref/rsCpuIntrinsicLUT.cpp
new file mode 100644
index 0000000..188ed2b
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicLUT.cpp
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicLUT : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsicLUT();
+    RsdCpuScriptIntrinsicLUT(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    ObjectBaseRef<Allocation> lut;
+
+    static void kernel(const RsForEachStubParamStruct *p,
+                       uint32_t xstart, uint32_t xend,
+                       uint32_t instep, uint32_t outstep);
+};
+
+}
+}
+
+
+void RsdCpuScriptIntrinsicLUT::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    rsAssert(slot == 0);
+    lut.set(static_cast<Allocation *>(data));
+}
+
+
+void RsdCpuScriptIntrinsicLUT::kernel(const RsForEachStubParamStruct *p,
+                                      uint32_t xstart, uint32_t xend,
+                                      uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicLUT *cp = (RsdCpuScriptIntrinsicLUT *)p->usr;
+
+    uchar4 *out = (uchar4 *)p->out;
+    uchar4 *in = (uchar4 *)p->in;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    const uchar *tr = (const uchar *)cp->lut->mHal.drvState.lod[0].mallocPtr;
+    const uchar *tg = &tr[256];
+    const uchar *tb = &tg[256];
+    const uchar *ta = &tb[256];
+
+    while (x1 < x2) {
+        uchar4 p = *in;
+        uchar4 o = {tr[p.x], tg[p.y], tb[p.z], ta[p.w]};
+        *out = o;
+        in++;
+        out++;
+        x1++;
+    }
+}
+
+RsdCpuScriptIntrinsicLUT::RsdCpuScriptIntrinsicLUT(RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_LUT) {
+
+    mRootPtr = &kernel;
+}
+
+RsdCpuScriptIntrinsicLUT::~RsdCpuScriptIntrinsicLUT() {
+}
+
+void RsdCpuScriptIntrinsicLUT::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 1;
+}
+
+void RsdCpuScriptIntrinsicLUT::invokeFreeChildren() {
+    lut.clear();
+}
+
+
+RsdCpuScriptImpl * rsdIntrinsic_LUT(RsdCpuReferenceImpl *ctx, const Script *s) {
+
+    return new RsdCpuScriptIntrinsicLUT(ctx, s);
+}
+
+
diff --git a/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp b/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp
new file mode 100644
index 0000000..7b8f768
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsicYuvToRGB.cpp
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "rsCpuIntrinsic.h"
+#include "rsCpuIntrinsicInlines.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+namespace android {
+namespace renderscript {
+
+
+class RsdCpuScriptIntrinsicYuvToRGB : public RsdCpuScriptIntrinsic {
+public:
+    virtual void populateScript(Script *);
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+    virtual ~RsdCpuScriptIntrinsicYuvToRGB();
+    RsdCpuScriptIntrinsicYuvToRGB(RsdCpuReferenceImpl *ctx, const Script *s);
+
+protected:
+    ObjectBaseRef<Allocation> alloc;
+
+    static void kernel(const RsForEachStubParamStruct *p,
+                       uint32_t xstart, uint32_t xend,
+                       uint32_t instep, uint32_t outstep);
+};
+
+}
+}
+
+
+void RsdCpuScriptIntrinsicYuvToRGB::setGlobalObj(uint32_t slot, ObjectBase *data) {
+    rsAssert(slot == 0);
+    alloc.set(static_cast<Allocation *>(data));
+}
+
+
+
+
+static uchar4 rsYuvToRGBA_uchar4(uchar y, uchar u, uchar v) {
+    short Y = ((short)y) - 16;
+    short U = ((short)u) - 128;
+    short V = ((short)v) - 128;
+
+    short4 p;
+    p.r = (Y * 298 + V * 409 + 128) >> 8;
+    p.g = (Y * 298 - U * 100 - V * 208 + 128) >> 8;
+    p.b = (Y * 298 + U * 516 + 128) >> 8;
+    p.a = 255;
+    if(p.r < 0) {
+        p.r = 0;
+    }
+    if(p.r > 255) {
+        p.r = 255;
+    }
+    if(p.g < 0) {
+        p.g = 0;
+    }
+    if(p.g > 255) {
+        p.g = 255;
+    }
+    if(p.b < 0) {
+        p.b = 0;
+    }
+    if(p.b > 255) {
+        p.b = 255;
+    }
+
+    return (uchar4){p.r, p.g, p.b, p.a};
+}
+
+
+static short YuvCoeff[] = {
+    298, 409, -100, 516,   -208, 255, 0, 0,
+    16, 16, 16, 16,        16, 16, 16, 16,
+    128, 128, 128, 128, 128, 128, 128, 128,
+    298, 298, 298, 298, 298, 298, 298, 298,
+    255, 255, 255, 255, 255, 255, 255, 255
+
+
+};
+
+extern "C" void rsdIntrinsicYuv_K(void *dst, const uchar *Y, const uchar *uv, uint32_t count, const short *param);
+
+void RsdCpuScriptIntrinsicYuvToRGB::kernel(const RsForEachStubParamStruct *p,
+                                           uint32_t xstart, uint32_t xend,
+                                           uint32_t instep, uint32_t outstep) {
+    RsdCpuScriptIntrinsicYuvToRGB *cp = (RsdCpuScriptIntrinsicYuvToRGB *)p->usr;
+    if (!cp->alloc.get()) {
+        ALOGE("YuvToRGB executed without input, skipping");
+        return;
+    }
+    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
+    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
+
+    const uchar *Y = pin + (p->y * p->dimX);
+    const uchar *uv = pin + (p->dimX * p->dimY);
+    uv += (p->y>>1) * p->dimX;
+
+    uchar4 *out = (uchar4 *)p->out;
+    uint32_t x1 = xstart;
+    uint32_t x2 = xend;
+
+    if(x2 > x1) {
+#if defined(ARCH_ARM_HAVE_NEON)
+        int32_t len = (x2 - x1 - 1) >> 3;
+        if(len > 0) {
+            rsdIntrinsicYuv_K(out, Y, uv, len, YuvCoeff);
+            x1 += len << 3;
+            out += len << 3;
+        }
+#endif
+
+       // ALOGE("y %i  %i  %i", p->y, x1, x2);
+        while(x1 < x2) {
+            uchar u = uv[(x1 & 0xffffe) + 1];
+            uchar v = uv[(x1 & 0xffffe) + 0];
+            *out = rsYuvToRGBA_uchar4(Y[x1], u, v);
+            out++;
+            x1++;
+            *out = rsYuvToRGBA_uchar4(Y[x1], u, v);
+            out++;
+            x1++;
+        }
+    }
+}
+
+RsdCpuScriptIntrinsicYuvToRGB::RsdCpuScriptIntrinsicYuvToRGB(
+            RsdCpuReferenceImpl *ctx, const Script *s)
+            : RsdCpuScriptIntrinsic(ctx, s, RS_SCRIPT_INTRINSIC_ID_YUV_TO_RGB) {
+
+    mRootPtr = &kernel;
+}
+
+RsdCpuScriptIntrinsicYuvToRGB::~RsdCpuScriptIntrinsicYuvToRGB() {
+}
+
+void RsdCpuScriptIntrinsicYuvToRGB::populateScript(Script *s) {
+    s->mHal.info.exportedVariableCount = 1;
+}
+
+void RsdCpuScriptIntrinsicYuvToRGB::invokeFreeChildren() {
+    alloc.clear();
+}
+
+
+RsdCpuScriptImpl * rsdIntrinsic_YuvToRGB(RsdCpuReferenceImpl *ctx, const Script *s) {
+    return new RsdCpuScriptIntrinsicYuvToRGB(ctx, s);
+}
+
+
diff --git a/cpu_ref/rsCpuIntrinsics_neon.S b/cpu_ref/rsCpuIntrinsics_neon.S
new file mode 100644
index 0000000..04dd8b1
--- /dev/null
+++ b/cpu_ref/rsCpuIntrinsics_neon.S
@@ -0,0 +1,1524 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+#include <machine/cpu-features.h>
+#include <machine/asm.h>
+
+/*
+        r0 = dst
+        r1 = y0 base pointer
+        r2 = y1 base pointer
+        r3 = y2 base pointer
+        sp = coeffs
+        sp = length / 2
+*/
+
+ENTRY(rsdIntrinsicConvolve3x3_K)
+        push            {r4-r8, r10, r11, lr}
+        vpush           {q4-q7}
+
+        /* Get the coeffs pointer from the stack and load the
+           coefficients in the q0, q1 NEON registers */
+        ldr r4, [sp, #32+64]
+        vld1.16 {q0, q1}, [r4]
+
+        /* Get count from the stack */
+        ldr r4, [sp, #36+64]
+
+        /* Load the frequently used immediate in a register */
+        mov r5, #8
+
+1:
+        /* Load and post-increase the address by r5=#8 */
+        vld1.8 {q13}, [r1], r5
+        vld1.8 {q14}, [r2], r5
+        vld1.8 {q15}, [r3], r5
+
+        /* Signal memory for data that will be used in the loop after the next */
+        PLD         (r1, r5)
+        PLD         (r2, r5)
+        PLD         (r3, r5)
+
+        vmovl.u8 q2, d26
+        vmovl.u8 q3, d27
+        vmovl.u8 q4, d28
+        vmovl.u8 q5, d29
+        vmovl.u8 q6, d30
+        vmovl.u8 q7, d31
+
+/*
+        The two pixel source array is
+        d4,  d5,  d6,  d7
+        d8,  d9,  d10, d11
+        d12, d13, d14, d15
+*/
+
+        vmull.s16 q8, d4, d0[0]
+        vmlal.s16 q8, d5, d0[1]
+        vmlal.s16 q8, d6, d0[2]
+        vmlal.s16 q8, d8, d0[3]
+        vmlal.s16 q8, d9, d1[0]
+        vmlal.s16 q8, d10, d1[1]
+        vmlal.s16 q8, d12, d1[2]
+        vmlal.s16 q8, d13, d1[3]
+        vmlal.s16 q8, d14, d2[0]
+
+        vmull.s16 q9, d5, d0[0]
+        vmlal.s16 q9, d6, d0[1]
+        vmlal.s16 q9, d7, d0[2]
+        vmlal.s16 q9, d9, d0[3]
+        vmlal.s16 q9, d10, d1[0]
+        vmlal.s16 q9, d11, d1[1]
+        vmlal.s16 q9, d13, d1[2]
+        vmlal.s16 q9, d14, d1[3]
+        vmlal.s16 q9, d15, d2[0]
+
+        vshrn.i32 d16, q8, #8
+        vshrn.i32 d17, q9, #8
+
+        vqmovun.s16 d16, q8
+        vst1.8 d16, [r0]!
+
+        /* Are we done yet? */
+        subs r4, r4, #1
+        bne 1b
+
+        /* We're done, bye! */
+        vpop            {q4-q7}
+        pop             {r4-r8, r10, r11, lr}
+        bx              lr
+END(rsdIntrinsicConvolve3x3_K)
+
+/*
+        r0 = dst
+        r1 = src
+        r2 = matrix
+        r3 = length
+*/
+ENTRY(rsdIntrinsicColorMatrix4x4_K)
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        vld1.16 {q2}, [r2]!
+        vld1.16 {q3}, [r2]!
+
+1:
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+
+        vmovl.u8 q12, d0  /* R */
+        vmovl.u8 q13, d1  /* G */
+        vmovl.u8 q14, d2  /* B */
+        vmovl.u8 q15, d3  /* A */
+
+        vmull.s16 q8,  d24, d4[0]
+        vmull.s16 q9,  d24, d4[1]
+        vmull.s16 q10, d24, d4[2]
+        vmull.s16 q11, d24, d4[3]
+
+        vmlal.s16 q8,  d26, d5[0]
+        vmlal.s16 q9,  d26, d5[1]
+        vmlal.s16 q10, d26, d5[2]
+        vmlal.s16 q11, d26, d5[3]
+
+        vmlal.s16 q8,  d28, d6[0]
+        vmlal.s16 q9,  d28, d6[1]
+        vmlal.s16 q10, d28, d6[2]
+        vmlal.s16 q11, d28, d6[3]
+
+        vmlal.s16 q8,  d30, d7[0]
+        vmlal.s16 q9,  d30, d7[1]
+        vmlal.s16 q10, d30, d7[2]
+        vmlal.s16 q11, d30, d7[3]
+
+        vshrn.i32 d24, q8, #8
+        vshrn.i32 d26, q9, #8
+        vshrn.i32 d28, q10, #8
+        vshrn.i32 d30, q11, #8
+
+        vqmovun.s16 d0, q12
+        vqmovun.s16 d1, q13
+        vqmovun.s16 d2, q14
+        vqmovun.s16 d3, q15
+
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+
+        subs r3, r3, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicColorMatrix4x4_K)
+
+/*
+        r0 = dst
+        r1 = src
+        r2 = matrix
+        r3 = length
+*/
+ENTRY(rsdIntrinsicColorMatrix3x3_K)
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        vld1.16 {q2}, [r2]!
+        vld1.16 {q3}, [r2]!
+
+1:
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+
+        vmull.s16 q8,  d24, d4[0]
+        vmull.s16 q9,  d24, d4[1]
+        vmull.s16 q10, d24, d4[2]
+
+        vmlal.s16 q8,  d26, d5[0]
+        vmlal.s16 q9,  d26, d5[1]
+        vmlal.s16 q10, d26, d5[2]
+
+        vmlal.s16 q8,  d28, d6[0]
+        vmlal.s16 q9,  d28, d6[1]
+        vmlal.s16 q10, d28, d6[2]
+
+        vshrn.i32 d24, q8, #8
+        vshrn.i32 d26, q9, #8
+        vshrn.i32 d28, q10, #8
+
+        vqmovun.s16 d0, q12
+        vqmovun.s16 d1, q13
+        vqmovun.s16 d2, q14
+
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+
+        subs r3, r3, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicColorMatrix3x3_K)
+
+/*
+        r0 = dst
+        r1 = src
+        r2 = matrix
+        r3 = length
+*/
+ENTRY(rsdIntrinsicColorMatrixDot_K)
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        vld1.16 {q2}, [r2]!
+        vld1.16 {q3}, [r2]!
+
+1:
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+
+        vmull.s16 q8,  d24, d4[0]
+        vmlal.s16 q8,  d26, d5[0]
+        vmlal.s16 q8,  d28, d6[0]
+        vshrn.i32 d24, q8, #8
+        vqmovun.s16 d0, q12
+        vmov.u8 d1, d0
+        vmov.u8 d2, d0
+
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+
+        subs r3, r3, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicColorMatrixDot_K)
+
+
+/*
+static void OneVF(float4 *out, const uchar *ptrIn, int iStride,
+                  const float* gPtr, int iradius, int x1, int x2)
+
+    r0 = out
+    r1 = pin
+    r2 = stride
+    r3 = gptr
+    r4 = sp, ct
+    r5 = sp+4, x1
+    r6 = sp+8, x2
+*/
+ENTRY(rsdIntrinsicBlurVF_K)
+        push            {r4-r8, r10, r11, lr}
+        vpush           {q4-q7}
+
+        ldr r4, [sp, #32+64]
+        ldr r5, [sp, #32+64 + 4]
+        ldr r6, [sp, #32+64 + 8]
+
+1:
+        veor q10, q10, q10         /* float4 blurredPixel = 0; */
+        veor q11, q11, q11         /* float4 blurredPixel = 0; */
+        add r7, r1, r5, lsl #2  /* const uchar *pi = ptrIn + x1 * 4; */
+        mov r10, r3
+
+        mov r11, r4
+
+2:
+        vld1.32 {d2}, [r7]
+        vmovl.u8 q1, d2
+        vmovl.u16 q3, d2
+        vmovl.u16 q4, d3
+        vcvt.f32.s32 q3, q3
+        vcvt.f32.s32 q4, q4
+        vld1.32 {d0[0]}, [r10]!
+        add r7, r7, r2
+        vmla.f32 q10, q3, d0[0]
+        vmla.f32 q11, q4, d0[0]
+        subs r11, r11, #1
+        bne 2b
+
+        vst1.32 {q10}, [r0]!
+        vst1.32 {q11}, [r0]!
+        add r5, r5, #2
+        cmp r5, r6
+        bne 1b
+
+
+        vpop            {q4-q7}
+        pop             {r4-r8, r10, r11, lr}
+        bx              lr
+END(rsdIntrinsicBlurVF_K)
+
+/*
+static void OneVF(float4 *out, const uchar *ptrIn, int iStride,
+                  const float* gPtr, int iradius, int x1, int x2)
+
+    r0 = out
+    r1 = pin
+    r2 = gptr
+    r3 = ct
+    r4 = sp, x1
+    r5 = sp+4, x2
+*/
+ENTRY(rsdIntrinsicBlurHF_K)
+        push            {r4-r8, r10, r11, lr}
+        vpush           {q4-q7}
+
+        ldr r4, [sp, #32+64]
+        ldr r5, [sp, #32+64 + 4]
+
+1:
+        add r7, r1, r4, lsl #4  /* const uchar *pi = ptrIn + x1 * 4; */
+        mov r10, r2
+        mov r11, r3
+
+        vld1.32 {q1}, [r7]!
+        vld1.32 {d6[0]}, [r10]!
+        vmul.f32 q0, q1, d6[0]
+        sub r11, r11, #1
+
+2:
+        vld1.32 {q1}, [r7]!
+        vld1.32 {q2}, [r7]!
+        vld1.32 {d6[0]}, [r10]!
+        vld1.32 {d6[1]}, [r10]!
+        vmla.f32 q0, q1, d6[0]
+        vmla.f32 q0, q2, d6[1]
+        subs r11, r11, #2
+        bne 2b
+
+        vcvt.s32.f32 q0, q0
+        vmovn.u32 d0, q0
+        vmovn.u16 d0, q0
+
+        vst1.32 {d0[0]}, [r0]!
+        add r4, r4, #1
+        cmp r4, r5
+        bne 1b
+
+        vpop            {q4-q7}
+        pop             {r4-r8, r10, r11, lr}
+        bx              lr
+END(rsdIntrinsicBlurHF_K)
+
+/*
+        r0 = dst
+        r1 = Y
+        r2 = VU
+        r3 = length (pixels / 8)
+        r4 = sp, params
+
+        This function converts 8 pixels per iteration
+*/
+ENTRY(rsdIntrinsicYuv_K)
+        push            {r4-r8, r10, r11, lr}
+        vpush           {q4-q7}
+
+        ldr r4, [sp, #32+64]
+        vld1.16 {q2}, [r4]!  // mults
+        vld1.16 {q3}, [r4]!  // y offset
+        vld1.16 {q4}, [r4]!  // 128
+        vdup.8 d3, d5[1]
+
+1:
+        vld1.8 {d10}, [r1]!
+        vld1.8 {d12}, [r2]!
+        vmovl.u8 q5, d10 // Y at .16
+        vmovl.u8 q6, d12 // vu at .16
+
+        vsub.i16 q5, q5, q3
+        vsub.i16 q6, q6, q4
+        vtrn.16 d12, d13  // d12 = u, d13 = v
+        vmov q7, q6
+        vtrn.16 d12, d14
+        vtrn.32 d12, d14
+        vtrn.16 d13, d15
+        vtrn.32 d13, d15
+
+        vmull.s16 q8, d10, d4[0]
+        vmull.s16 q11, d11, d4[0]
+        vmov q9, q8
+        vmov q10, q8
+        vmov q12, q11
+        vmov q13, q11
+
+        vmlal.s16 q8,  d12, d4[1]
+        vmlal.s16 q9,  d12, d5[0]
+        vmlal.s16 q10, d13, d4[3]
+        vmlal.s16 q9,  d13, d4[2]
+
+        vmlal.s16 q11, d14, d4[1]
+        vmlal.s16 q12, d14, d5[0]
+        vmlal.s16 q13, d15, d4[3]
+        vmlal.s16 q12, d15, d4[2]
+
+
+        vshrn.i32 d16, q8, #8
+        vshrn.i32 d18, q9, #8
+        vshrn.i32 d20, q10, #8
+        vqmovun.s16 d0, q8
+        vqmovun.s16 d1, q9
+        vqmovun.s16 d2, q10
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+
+        vshrn.i32 d16, q11, #8
+        vshrn.i32 d18, q12, #8
+        vshrn.i32 d20, q13, #8
+        vqmovun.s16 d0, q8
+        vqmovun.s16 d1, q9
+        vqmovun.s16 d2, q10
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+
+        subs r3, r3, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        pop             {r4-r8, r10, r11, lr}
+        bx              lr
+END(rsdIntrinsicYuv_K)
+
+/* Convolve 5x5 */
+
+/*
+        r0 = dst
+        r1 = y0 base pointer
+        r2 = y1 base pointer
+        r3 = y2 base pointer
+        r4 = y3 base pointer
+        r5 = y4 base pointer
+        r6 = coeffs
+        r7 = length
+*/
+ENTRY(rsdIntrinsicConvolve5x5_K)
+        push        {r4-r7, lr}
+        vpush       {q4-q7}
+
+        /* load y3 in r4 */
+        ldr     r4, [sp, #20 + 64]
+
+        /* load y4 in r5 */
+        ldr     r5, [sp, #24 + 64]
+
+        /* Load the coefficients pointer */
+        ldr     r6, [sp, #28 + 64]
+
+        /* Create the coefficients vector */
+        vld1.16     {d0, d1, d2, d3}, [r6]!
+        vld1.16     {d4, d5, d6}, [r6]
+
+        /* load the count */
+        ldr     r6, [sp, #32 + 64]
+
+        /* Load the frequently used immediate in a register */
+        mov     r7, #8
+
+1:
+        /* Load the y base pointers in Qregs and post-increase the address by r7=#8 */
+        vld1.8  {d24, d25, d26}, [r1], r7      @  y0 ( y - 2 )
+        vld1.8  {d27, d28, d29}, [r2], r7      @  y0 ( y - 1 )
+
+        /* Signal memory for data that will be used in the loop after the next */
+        PLD         (r1, r7)
+        PLD         (r2, r7)
+
+        /* Promoting the 8bit channels to 16bit */
+        vmovl.u8 q9,  d24
+        vmovl.u8 q10, d25
+        vmovl.u8 q11, d26
+        vmovl.u8 q12, d27
+        vmovl.u8 q13, d28
+        vmovl.u8 q14, d29
+
+/*
+        d18,  d19,  d20, d21, d22, d23,
+        d24,  d25
+*/
+        vmull.s16 q4, d18, d0[0]
+        vmlal.s16 q4, d19, d0[1]
+        vmlal.s16 q4, d20, d0[2]
+        vmlal.s16 q4, d21, d0[3]
+        vmlal.s16 q4, d22, d1[0]
+
+        vmlal.s16 q4, d24, d1[1]
+        vmlal.s16 q4, d25, d1[2]
+        vmlal.s16 q4, d26, d1[3]
+        vmlal.s16 q4, d27, d2[0]
+        vmlal.s16 q4, d28, d2[1]
+
+        vmull.s16 q5, d19, d0[0]
+        vmlal.s16 q5, d20, d0[1]
+        vmlal.s16 q5, d21, d0[2]
+        vmlal.s16 q5, d22, d0[3]
+        vmlal.s16 q5, d23, d1[0]
+
+        vmlal.s16 q5, d25, d1[1]
+        vmlal.s16 q5, d26, d1[2]
+        vmlal.s16 q5, d27, d1[3]
+        vmlal.s16 q5, d28, d2[0]
+        vmlal.s16 q5, d29, d2[1]
+
+
+        /* Next 2 rows */
+        /* Load the y base pointers in Qregs and post-increase the address by r7=#8 */
+        vld1.8  {d24, d25, d26}, [r3], r7      @  y0 ( y )
+        vld1.8  {d27, d28, d29}, [r4], r7      @  y0 ( y + 1 )
+
+        /* Signal memory for data that will be used in the loop after the next */
+        PLD         (r3, r7)
+        PLD         (r4, r7)
+
+        /* Promoting the 8bit channels to 16bit */
+        vmovl.u8 q9,  d24
+        vmovl.u8 q10, d25
+        vmovl.u8 q11, d26
+        vmovl.u8 q12, d27
+        vmovl.u8 q13, d28
+        vmovl.u8 q14, d29
+
+/*
+        d18,  d19,  d20, d21, d22, d23,
+        d24,  d25
+*/
+        vmlal.s16 q4, d18, d2[2]
+        vmlal.s16 q4, d19, d2[3]
+        vmlal.s16 q4, d20, d3[0]
+        vmlal.s16 q4, d21, d3[1]
+        vmlal.s16 q4, d22, d3[2]
+
+        vmlal.s16 q4, d24, d3[3]
+        vmlal.s16 q4, d25, d4[0]
+        vmlal.s16 q4, d26, d4[1]
+        vmlal.s16 q4, d27, d4[2]
+        vmlal.s16 q4, d28, d4[3]
+
+        vmlal.s16 q5, d19, d2[2]
+        vmlal.s16 q5, d20, d2[3]
+        vmlal.s16 q5, d21, d3[0]
+        vmlal.s16 q5, d22, d3[1]
+        vmlal.s16 q5, d23, d3[2]
+
+        vmlal.s16 q5, d25, d3[3]
+        vmlal.s16 q5, d26, d4[0]
+        vmlal.s16 q5, d27, d4[1]
+        vmlal.s16 q5, d28, d4[2]
+        vmlal.s16 q5, d29, d4[3]
+
+        /* Last row */
+        /* Load the y base pointers in Qregs and post-increase the address by r7=#8 */
+        vld1.8  {d24, d25, d26}, [r5], r7      @  y0 ( y + 2 )
+
+        /* Signal memory for data that will be used in the loop after the next */
+        PLD         (r5, r7)
+
+        /* Promoting the 8bit channels to 16bit */
+        vmovl.u8 q9,  d24
+        vmovl.u8 q10, d25
+        vmovl.u8 q11, d26
+
+/*
+        d18,  d19,  d20, d21, d22, d23,
+        d24,  d25
+*/
+
+        vmlal.s16 q4, d18, d5[0]
+        vmlal.s16 q4, d19, d5[1]
+        vmlal.s16 q4, d20, d5[2]
+        vmlal.s16 q4, d21, d5[3]
+        vmlal.s16 q4, d22, d6[0]
+
+        vmlal.s16 q5, d19, d5[0]
+        vmlal.s16 q5, d20, d5[1]
+        vmlal.s16 q5, d21, d5[2]
+        vmlal.s16 q5, d22, d5[3]
+        vmlal.s16 q5, d23, d6[0]
+
+
+
+
+/*      Narrow it to a d-reg 32 -> 16 bit */
+        vshrn.i32 d8, q4, #8
+        vshrn.i32 d9, q5, #8
+
+/*      Pack 16 -> 8 bit, saturate, put two pixels into D reg */
+        vqmovun.s16 d8, q4
+
+        vst1.8 d8, [r0]!           @ return the output and increase the address of r0
+
+        /* Are we done? */
+        subs r6, r6, #1
+        bne 1b
+
+        /* Yup, bye */
+        vpop        {q4-q7}
+        pop         {r4-r7, lr}
+        bx          lr
+
+END(rsdIntrinsicConvolve5x5_K)
+
+
+
+
+/*
+        dst = src + dst * (1.0 - src.a)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendSrcOver_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vshll.u8 q12, d0, #8
+        vshll.u8 q13, d1, #8
+        vshll.u8 q14, d2, #8
+        vmovl.u8 q6, d3
+        vsub.i16 q6, q7, q6        // q6 = 1 - src.a
+        vshll.u8 q15, d3, #8
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+        vmla.i16 q12, q8, q6
+        vmla.i16 q13, q9, q6
+        vmla.i16 q14, q10, q6
+        vmla.i16 q15, q11, q6
+
+        vshrn.i16 d0, q12, #8
+        vshrn.i16 d1, q13, #8
+        vshrn.i16 d2, q14, #8
+        vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendSrcOver_K)
+
+/*
+        dst = dst + src * (1.0 - dst.a)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendDstOver_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vshll.u8 q8, d0, #8
+        vshll.u8 q9, d1, #8
+        vshll.u8 q10, d2, #8
+        vmovl.u8 q6, d3
+        vsub.i16 q6, q7, q6        // q6 = 1 - dst.a
+        vshll.u8 q11, d3, #8
+
+
+        vmla.i16 q8, q12, q6
+        vmla.i16 q9, q13, q6
+        vmla.i16 q10, q14, q6
+        vmla.i16 q11, q15, q6
+
+        vshrn.i16 d0, q8, #8
+        vshrn.i16 d1, q9, #8
+        vshrn.i16 d2, q10, #8
+        vshrn.i16 d3, q11, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendDstOver_K)
+
+/*
+        dst = src * dst.a
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendSrcIn_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        //vmovl.u8 q8, d0
+        //vmovl.u8 q9, d1
+        //vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+        vmul.i16 q12, q12, q11
+        vmul.i16 q13, q13, q11
+        vmul.i16 q14, q14, q11
+        vmul.i16 q15, q15, q11
+
+        vshrn.i16 d0, q12, #8
+        vshrn.i16 d1, q13, #8
+        vshrn.i16 d2, q14, #8
+        vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendSrcIn_K)
+
+/*
+        dst = dst * src.a
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendDstIn_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        //vmovl.u8 q12, d0
+        //vmovl.u8 q13, d1
+        //vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+        vmul.i16 q8, q8, q15
+        vmul.i16 q9, q9, q15
+        vmul.i16 q10, q10, q15
+        vmul.i16 q11, q11, q15
+
+        vshrn.i16 d0, q8, #8
+        vshrn.i16 d1, q9, #8
+        vshrn.i16 d2, q10, #8
+        vshrn.i16 d3, q11, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendDstIn_K)
+
+
+
+/*
+        dst = src * (1.0 - dst.a)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendSrcOut_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        //vmovl.u8 q8, d0
+        //vmovl.u8 q9, d1
+        //vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vsub.i16 q6, q7, q11        // q6 = 1 - dst.a
+        vmul.i16 q12, q12, q6
+        vmul.i16 q13, q13, q6
+        vmul.i16 q14, q14, q6
+        vmul.i16 q15, q15, q6
+
+        vshrn.i16 d0, q12, #8
+        vshrn.i16 d1, q13, #8
+        vshrn.i16 d2, q14, #8
+        vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendSrcOut_K)
+
+
+/*
+        dst = dst * (1.0 - src.a)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendDstOut_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        //vmovl.u8 q12, d0
+        //vmovl.u8 q13, d1
+        //vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vsub.i16 q6, q7, q15        // q6 = 1 - src.a
+        vmul.i16 q12, q8, q6
+        vmul.i16 q13, q9, q6
+        vmul.i16 q14, q10, q6
+        vmul.i16 q15, q11, q6
+
+        vshrn.i16 d0, q12, #8
+        vshrn.i16 d1, q13, #8
+        vshrn.i16 d2, q14, #8
+        vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendDstOut_K)
+
+
+/*
+        dst.rgb = src.rgb * dst.a + (1.0 - src.a) * dst.rgb
+        dst.a = dst.a
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendSrcAtop_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vsub.i16 q6, q7, q15        // q6 = 1 - src.a
+        vmul.i16 q8, q8, q6
+        vmul.i16 q9, q9, q6
+        vmul.i16 q10, q10, q6
+
+        vmla.i16 q8, q12, q11
+        vmla.i16 q9, q13, q11
+        vmla.i16 q10, q14, q11
+
+
+        vshrn.i16 d0, q8, #8
+        vshrn.i16 d1, q9, #8
+        vshrn.i16 d2, q10, #8
+        //vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendSrcAtop_K)
+
+/*
+        dst = dst.rgb * src.a + (1.0 - dst.a) * src.rgb
+        dst.a = src.a
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendDstAtop_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vsub.i16 q6, q7, q11        // q6 = 1 - dst.a
+        vmul.i16 q12, q12, q6
+        vmul.i16 q13, q13, q6
+        vmul.i16 q14, q14, q6
+
+        vmla.i16 q12, q8, q15
+        vmla.i16 q13, q9, q15
+        vmla.i16 q14, q10, q15
+
+
+        vshrn.i16 d0, q12, #8
+        vshrn.i16 d1, q13, #8
+        vshrn.i16 d2, q14, #8
+        //vshrn.i16 d3, q15, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendDstAtop_K)
+
+/*
+        dst = dst ^ src
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendXor_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmov.u8 d4, d0
+        vmov.u8 d5, d1
+        vmov.u8 d6, d2
+        vmov.u8 d7, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+
+        veor d0, d0, d4
+        veor d1, d1, d5
+        veor d2, d2, d6
+        veor d3, d3, d7
+
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendXor_K)
+
+/*
+        dst = dst * src
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendMultiply_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vmul.i16 q8, q8, q12
+        vmul.i16 q9, q9, q13
+        vmul.i16 q10, q10, q14
+        vmul.i16 q11, q11, q15
+
+        vshrn.i16 d0, q8, #8
+        vshrn.i16 d1, q9, #8
+        vshrn.i16 d2, q10, #8
+        vshrn.i16 d3, q11, #8
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendMultiply_K)
+
+/*
+        dst = min(src + dst, 1.0)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendAdd_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vadd.i16 q8, q8, q12
+        vadd.i16 q9, q9, q13
+        vadd.i16 q10, q10, q14
+        vadd.i16 q11, q11, q15
+
+        vqmovun.s16 d0, q8
+        vqmovun.s16 d1, q9
+        vqmovun.s16 d2, q10
+        vqmovun.s16 d3, q11
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendAdd_K)
+
+
+/*
+        dst = max(dst - src, 0.0)
+
+        r0 = dst
+        r1 = src
+        r2 = length
+*/
+ENTRY(rsdIntrinsicBlendSub_K)
+        .save           {r4, lr}
+        stmfd           sp!, {r4, lr}
+        vpush           {q4-q7}
+
+        mov r4, #255
+        vdup.16 q7, r4
+
+        mov r4, r0
+1:
+
+        /* src */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r1]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r1]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r1]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r1]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r1]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r1]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r1]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r1]!
+        vmovl.u8 q12, d0
+        vmovl.u8 q13, d1
+        vmovl.u8 q14, d2
+        vmovl.u8 q15, d3
+
+        /* dst */
+        vld4.8 {d0[0],d1[0],d2[0],d3[0]}, [r0]!
+        vld4.8 {d0[1],d1[1],d2[1],d3[1]}, [r0]!
+        vld4.8 {d0[2],d1[2],d2[2],d3[2]}, [r0]!
+        vld4.8 {d0[3],d1[3],d2[3],d3[3]}, [r0]!
+        vld4.8 {d0[4],d1[4],d2[4],d3[4]}, [r0]!
+        vld4.8 {d0[5],d1[5],d2[5],d3[5]}, [r0]!
+        vld4.8 {d0[6],d1[6],d2[6],d3[6]}, [r0]!
+        vld4.8 {d0[7],d1[7],d2[7],d3[7]}, [r0]!
+        vmovl.u8 q8, d0
+        vmovl.u8 q9, d1
+        vmovl.u8 q10, d2
+        vmovl.u8 q11, d3
+
+
+        vsub.i16 q8, q8, q12
+        vsub.i16 q9, q9, q13
+        vsub.i16 q10, q10, q14
+        vsub.i16 q11, q11, q15
+
+        vqmovun.s16 d0, q8
+        vqmovun.s16 d1, q9
+        vqmovun.s16 d2, q10
+        vqmovun.s16 d3, q11
+        vst4.8 {d0[0],d1[0],d2[0],d3[0]}, [r4]!
+        vst4.8 {d0[1],d1[1],d2[1],d3[1]}, [r4]!
+        vst4.8 {d0[2],d1[2],d2[2],d3[2]}, [r4]!
+        vst4.8 {d0[3],d1[3],d2[3],d3[3]}, [r4]!
+        vst4.8 {d0[4],d1[4],d2[4],d3[4]}, [r4]!
+        vst4.8 {d0[5],d1[5],d2[5],d3[5]}, [r4]!
+        vst4.8 {d0[6],d1[6],d2[6],d3[6]}, [r4]!
+        vst4.8 {d0[7],d1[7],d2[7],d3[7]}, [r4]!
+
+        subs r2, r2, #1
+        bne 1b
+
+        vpop            {q4-q7}
+        ldmfd           sp!, {r4, lr}
+        bx              lr
+END(rsdIntrinsicBlendSub_K)
+
diff --git a/cpu_ref/rsCpuRuntimeMath.cpp b/cpu_ref/rsCpuRuntimeMath.cpp
new file mode 100644
index 0000000..cf2c8a4
--- /dev/null
+++ b/cpu_ref/rsCpuRuntimeMath.cpp
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2011-2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cutils/compiler.h>
+
+#include "rsContext.h"
+#include "rsScriptC.h"
+#include "rsMatrix4x4.h"
+#include "rsMatrix3x3.h"
+#include "rsMatrix2x2.h"
+
+#include "rsCpuCore.h"
+#include "rsCpuScript.h"
+
+
+using namespace android;
+using namespace android::renderscript;
+
+
+static float SC_exp10(float v) {
+    return pow(10.f, v);
+}
+
+static float SC_fract(float v, float *iptr) {
+    int i = (int)floor(v);
+    iptr[0] = (float)i;
+    return fmin(v - i, 0x1.fffffep-1f);
+}
+
+static float SC_log2(float v) {
+    return log10(v) / log10(2.f);
+}
+
+#if 0
+static float SC_pown(float v, int p) {
+    return powf(v, (float)p);
+}
+
+static float SC_powr(float v, float p) {
+    return powf(v, p);
+}
+#endif
+
+float SC_rootn(float v, int r) {
+    return pow(v, 1.f / r);
+}
+
+float SC_rsqrt(float v) {
+    return 1.f / sqrtf(v);
+}
+
+float SC_sincos(float v, float *cosptr) {
+    *cosptr = cosf(v);
+    return sinf(v);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Integer
+//////////////////////////////////////////////////////////////////////////////
+
+
+static uint32_t SC_abs_i32(int32_t v) {return abs(v);}
+static uint16_t SC_abs_i16(int16_t v) {return (uint16_t)abs(v);}
+static uint8_t SC_abs_i8(int8_t v) {return (uint8_t)abs(v);}
+
+static uint32_t SC_clz_u32(uint32_t v) {return __builtin_clz(v);}
+static uint16_t SC_clz_u16(uint16_t v) {return (uint16_t)__builtin_clz(v);}
+static uint8_t SC_clz_u8(uint8_t v) {return (uint8_t)__builtin_clz(v);}
+static int32_t SC_clz_i32(int32_t v) {return (int32_t)__builtin_clz((uint32_t)v);}
+static int16_t SC_clz_i16(int16_t v) {return (int16_t)__builtin_clz(v);}
+static int8_t SC_clz_i8(int8_t v) {return (int8_t)__builtin_clz(v);}
+
+static uint32_t SC_max_u32(uint32_t v, uint32_t v2) {return rsMax(v, v2);}
+static uint16_t SC_max_u16(uint16_t v, uint16_t v2) {return rsMax(v, v2);}
+static uint8_t SC_max_u8(uint8_t v, uint8_t v2) {return rsMax(v, v2);}
+static int32_t SC_max_i32(int32_t v, int32_t v2) {return rsMax(v, v2);}
+static int16_t SC_max_i16(int16_t v, int16_t v2) {return rsMax(v, v2);}
+static int8_t SC_max_i8(int8_t v, int8_t v2) {return rsMax(v, v2);}
+
+static uint32_t SC_min_u32(uint32_t v, uint32_t v2) {return rsMin(v, v2);}
+static uint16_t SC_min_u16(uint16_t v, uint16_t v2) {return rsMin(v, v2);}
+static uint8_t SC_min_u8(uint8_t v, uint8_t v2) {return rsMin(v, v2);}
+static int32_t SC_min_i32(int32_t v, int32_t v2) {return rsMin(v, v2);}
+static int16_t SC_min_i16(int16_t v, int16_t v2) {return rsMin(v, v2);}
+static int8_t SC_min_i8(int8_t v, int8_t v2) {return rsMin(v, v2);}
+
+//////////////////////////////////////////////////////////////////////////////
+// Float util
+//////////////////////////////////////////////////////////////////////////////
+
+static float SC_clamp_f32(float amount, float low, float high) {
+    return amount < low ? low : (amount > high ? high : amount);
+}
+
+static float SC_max_f32(float v, float v2) {
+    return rsMax(v, v2);
+}
+
+static float SC_min_f32(float v, float v2) {
+    return rsMin(v, v2);
+}
+
+static float SC_step_f32(float edge, float v) {
+    if (v < edge) return 0.f;
+    return 1.f;
+}
+
+static float SC_sign_f32(float value) {
+    if (value > 0) return 1.f;
+    if (value < 0) return -1.f;
+    return value;
+}
+
+static void SC_MatrixLoadIdentity_4x4(Matrix4x4 *m) {
+    m->loadIdentity();
+}
+static void SC_MatrixLoadIdentity_3x3(Matrix3x3 *m) {
+    m->loadIdentity();
+}
+static void SC_MatrixLoadIdentity_2x2(Matrix2x2 *m) {
+    m->loadIdentity();
+}
+
+static void SC_MatrixLoad_4x4_f(Matrix4x4 *m, const float *f) {
+    m->load(f);
+}
+static void SC_MatrixLoad_3x3_f(Matrix3x3 *m, const float *f) {
+    m->load(f);
+}
+static void SC_MatrixLoad_2x2_f(Matrix2x2 *m, const float *f) {
+    m->load(f);
+}
+
+static void SC_MatrixLoad_4x4_4x4(Matrix4x4 *m, const Matrix4x4 *s) {
+    m->load(s);
+}
+static void SC_MatrixLoad_4x4_3x3(Matrix4x4 *m, const Matrix3x3 *s) {
+    m->load(s);
+}
+static void SC_MatrixLoad_4x4_2x2(Matrix4x4 *m, const Matrix2x2 *s) {
+    m->load(s);
+}
+static void SC_MatrixLoad_3x3_3x3(Matrix3x3 *m, const Matrix3x3 *s) {
+    m->load(s);
+}
+static void SC_MatrixLoad_2x2_2x2(Matrix2x2 *m, const Matrix2x2 *s) {
+    m->load(s);
+}
+
+static void SC_MatrixLoadRotate(Matrix4x4 *m, float rot, float x, float y, float z) {
+    m->loadRotate(rot, x, y, z);
+}
+static void SC_MatrixLoadScale(Matrix4x4 *m, float x, float y, float z) {
+    m->loadScale(x, y, z);
+}
+static void SC_MatrixLoadTranslate(Matrix4x4 *m, float x, float y, float z) {
+    m->loadTranslate(x, y, z);
+}
+static void SC_MatrixRotate(Matrix4x4 *m, float rot, float x, float y, float z) {
+    m->rotate(rot, x, y, z);
+}
+static void SC_MatrixScale(Matrix4x4 *m, float x, float y, float z) {
+    m->scale(x, y, z);
+}
+static void SC_MatrixTranslate(Matrix4x4 *m, float x, float y, float z) {
+    m->translate(x, y, z);
+}
+
+static void SC_MatrixLoadMultiply_4x4_4x4_4x4(Matrix4x4 *m, const Matrix4x4 *lhs, const Matrix4x4 *rhs) {
+    m->loadMultiply(lhs, rhs);
+}
+static void SC_MatrixLoadMultiply_3x3_3x3_3x3(Matrix3x3 *m, const Matrix3x3 *lhs, const Matrix3x3 *rhs) {
+    m->loadMultiply(lhs, rhs);
+}
+static void SC_MatrixLoadMultiply_2x2_2x2_2x2(Matrix2x2 *m, const Matrix2x2 *lhs, const Matrix2x2 *rhs) {
+    m->loadMultiply(lhs, rhs);
+}
+
+static void SC_MatrixMultiply_4x4_4x4(Matrix4x4 *m, const Matrix4x4 *rhs) {
+    m->multiply(rhs);
+}
+static void SC_MatrixMultiply_3x3_3x3(Matrix3x3 *m, const Matrix3x3 *rhs) {
+    m->multiply(rhs);
+}
+static void SC_MatrixMultiply_2x2_2x2(Matrix2x2 *m, const Matrix2x2 *rhs) {
+    m->multiply(rhs);
+}
+
+static void SC_MatrixLoadOrtho(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) {
+    m->loadOrtho(l, r, b, t, n, f);
+}
+static void SC_MatrixLoadFrustum(Matrix4x4 *m, float l, float r, float b, float t, float n, float f) {
+    m->loadFrustum(l, r, b, t, n, f);
+}
+static void SC_MatrixLoadPerspective(Matrix4x4 *m, float fovy, float aspect, float near, float far) {
+    m->loadPerspective(fovy, aspect, near, far);
+}
+
+static bool SC_MatrixInverse_4x4(Matrix4x4 *m) {
+    return m->inverse();
+}
+static bool SC_MatrixInverseTranspose_4x4(Matrix4x4 *m) {
+    return m->inverseTranspose();
+}
+static void SC_MatrixTranspose_4x4(Matrix4x4 *m) {
+    m->transpose();
+}
+static void SC_MatrixTranspose_3x3(Matrix3x3 *m) {
+    m->transpose();
+}
+static void SC_MatrixTranspose_2x2(Matrix2x2 *m) {
+    m->transpose();
+}
+
+static float SC_randf(float max) {
+    float r = (float)rand();
+    r *= max;
+    r /= RAND_MAX;
+    return r;
+}
+
+static float SC_randf2(float min, float max) {
+    float r = (float)rand();
+    r /= RAND_MAX;
+    r = r * (max - min) + min;
+    return r;
+}
+
+static int SC_randi(int max) {
+    return (int)SC_randf(max);
+}
+
+static int SC_randi2(int min, int max) {
+    return (int)SC_randf2(min, max);
+}
+
+static float SC_frac(float v) {
+    int i = (int)floor(v);
+    return fmin(v - i, 0x1.fffffep-1f);
+}
+
+
+static int32_t SC_AtomicCas(volatile int32_t *ptr, int32_t expectedValue, int32_t newValue) {
+    int32_t prev;
+
+    do {
+        int32_t ret = android_atomic_release_cas(expectedValue, newValue, ptr);
+        if (!ret) {
+            // The android cas return 0 if it wrote the value.  This means the
+            // previous value was the expected value and we can return.
+            return expectedValue;
+        }
+        // We didn't write the value and need to load the "previous" value.
+        prev = *ptr;
+
+        // A race condition exists where the expected value could appear after our cas failed
+        // above.  In this case loop until we have a legit previous value or the
+        // write passes.
+        } while (prev == expectedValue);
+    return prev;
+}
+
+
+static int32_t SC_AtomicInc(volatile int32_t *ptr) {
+    return android_atomic_inc(ptr);
+}
+
+static int32_t SC_AtomicDec(volatile int32_t *ptr) {
+    return android_atomic_dec(ptr);
+}
+
+static int32_t SC_AtomicAdd(volatile int32_t *ptr, int32_t value) {
+    return android_atomic_add(value, ptr);
+}
+
+static int32_t SC_AtomicSub(volatile int32_t *ptr, int32_t value) {
+    int32_t prev, status;
+    do {
+        prev = *ptr;
+        status = android_atomic_release_cas(prev, prev - value, ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+static int32_t SC_AtomicAnd(volatile int32_t *ptr, int32_t value) {
+    return android_atomic_and(value, ptr);
+}
+
+static int32_t SC_AtomicOr(volatile int32_t *ptr, int32_t value) {
+    return android_atomic_or(value, ptr);
+}
+
+static int32_t SC_AtomicXor(volatile int32_t *ptr, int32_t value) {
+    int32_t prev, status;
+    do {
+        prev = *ptr;
+        status = android_atomic_release_cas(prev, prev ^ value, ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+static uint32_t SC_AtomicUMin(volatile uint32_t *ptr, uint32_t value) {
+    uint32_t prev, status;
+    do {
+        prev = *ptr;
+        uint32_t n = rsMin(value, prev);
+        status = android_atomic_release_cas((int32_t) prev, (int32_t)n, (volatile int32_t*) ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+static int32_t SC_AtomicMin(volatile int32_t *ptr, int32_t value) {
+    int32_t prev, status;
+    do {
+        prev = *ptr;
+        int32_t n = rsMin(value, prev);
+        status = android_atomic_release_cas(prev, n, ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+static uint32_t SC_AtomicUMax(volatile uint32_t *ptr, uint32_t value) {
+    uint32_t prev, status;
+    do {
+        prev = *ptr;
+        uint32_t n = rsMax(value, prev);
+        status = android_atomic_release_cas((int32_t) prev, (int32_t) n, (volatile int32_t*) ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+static int32_t SC_AtomicMax(volatile int32_t *ptr, int32_t value) {
+    int32_t prev, status;
+    do {
+        prev = *ptr;
+        int32_t n = rsMax(value, prev);
+        status = android_atomic_release_cas(prev, n, ptr);
+    } while (CC_UNLIKELY(status != 0));
+    return prev;
+}
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Class implementation
+//////////////////////////////////////////////////////////////////////////////
+
+// llvm name mangling ref
+//  <builtin-type> ::= v  # void
+//                 ::= b  # bool
+//                 ::= c  # char
+//                 ::= a  # signed char
+//                 ::= h  # unsigned char
+//                 ::= s  # short
+//                 ::= t  # unsigned short
+//                 ::= i  # int
+//                 ::= j  # unsigned int
+//                 ::= l  # long
+//                 ::= m  # unsigned long
+//                 ::= x  # long long, __int64
+//                 ::= y  # unsigned long long, __int64
+//                 ::= f  # float
+//                 ::= d  # double
+
+static RsdCpuReference::CpuSymbol gSyms[] = {
+    { "_Z4acosf", (void *)&acosf, true },
+    { "_Z5acoshf", (void *)&acoshf, true },
+    { "_Z4asinf", (void *)&asinf, true },
+    { "_Z5asinhf", (void *)&asinhf, true },
+    { "_Z4atanf", (void *)&atanf, true },
+    { "_Z5atan2ff", (void *)&atan2f, true },
+    { "_Z5atanhf", (void *)&atanhf, true },
+    { "_Z4cbrtf", (void *)&cbrtf, true },
+    { "_Z4ceilf", (void *)&ceilf, true },
+    { "_Z8copysignff", (void *)&copysignf, true },
+    { "_Z3cosf", (void *)&cosf, true },
+    { "_Z4coshf", (void *)&coshf, true },
+    { "_Z4erfcf", (void *)&erfcf, true },
+    { "_Z3erff", (void *)&erff, true },
+    { "_Z3expf", (void *)&expf, true },
+    { "_Z4exp2f", (void *)&exp2f, true },
+    { "_Z5exp10f", (void *)&SC_exp10, true },
+    { "_Z5expm1f", (void *)&expm1f, true },
+    { "_Z4fabsf", (void *)&fabsf, true },
+    { "_Z4fdimff", (void *)&fdimf, true },
+    { "_Z5floorf", (void *)&floorf, true },
+    { "_Z3fmafff", (void *)&fmaf, true },
+    { "_Z4fmaxff", (void *)&fmaxf, true },
+    { "_Z4fminff", (void *)&fminf, true },  // float fmin(float, float)
+    { "_Z4fmodff", (void *)&fmodf, true },
+    { "_Z5fractfPf", (void *)&SC_fract, true },
+    { "_Z5frexpfPi", (void *)&frexpf, true },
+    { "_Z5hypotff", (void *)&hypotf, true },
+    { "_Z5ilogbf", (void *)&ilogbf, true },
+    { "_Z5ldexpfi", (void *)&ldexpf, true },
+    { "_Z6lgammaf", (void *)&lgammaf, true },
+    { "_Z6lgammafPi", (void *)&lgammaf_r, true },
+    { "_Z3logf", (void *)&logf, true },
+    { "_Z4log2f", (void *)&SC_log2, true },
+    { "_Z5log10f", (void *)&log10f, true },
+    { "_Z5log1pf", (void *)&log1pf, true },
+    { "_Z4logbf", (void *)&logbf, true },
+    { "_Z4modffPf", (void *)&modff, true },
+    //{ "_Z3nanj", (void *)&SC_nan, true },
+    { "_Z9nextafterff", (void *)&nextafterf, true },
+    { "_Z3powff", (void *)&powf, true },
+    { "_Z9remainderff", (void *)&remainderf, true },
+    { "_Z6remquoffPi", (void *)&remquof, true },
+    { "_Z4rintf", (void *)&rintf, true },
+    { "_Z5rootnfi", (void *)&SC_rootn, true },
+    { "_Z5roundf", (void *)&roundf, true },
+    { "_Z5rsqrtf", (void *)&SC_rsqrt, true },
+    { "_Z3sinf", (void *)&sinf, true },
+    { "_Z6sincosfPf", (void *)&SC_sincos, true },
+    { "_Z4sinhf", (void *)&sinhf, true },
+    { "_Z4sqrtf", (void *)&sqrtf, true },
+    { "_Z3tanf", (void *)&tanf, true },
+    { "_Z4tanhf", (void *)&tanhf, true },
+    { "_Z6tgammaf", (void *)&tgammaf, true },
+    { "_Z5truncf", (void *)&truncf, true },
+
+    { "_Z3absi", (void *)&SC_abs_i32, true },
+    { "_Z3abss", (void *)&SC_abs_i16, true },
+    { "_Z3absc", (void *)&SC_abs_i8, true },
+    { "_Z3clzj", (void *)&SC_clz_u32, true },
+    { "_Z3clzt", (void *)&SC_clz_u16, true },
+    { "_Z3clzh", (void *)&SC_clz_u8, true },
+    { "_Z3clzi", (void *)&SC_clz_i32, true },
+    { "_Z3clzs", (void *)&SC_clz_i16, true },
+    { "_Z3clzc", (void *)&SC_clz_i8, true },
+    { "_Z3maxjj", (void *)&SC_max_u32, true },
+    { "_Z3maxtt", (void *)&SC_max_u16, true },
+    { "_Z3maxhh", (void *)&SC_max_u8, true },
+    { "_Z3maxii", (void *)&SC_max_i32, true },
+    { "_Z3maxss", (void *)&SC_max_i16, true },
+    { "_Z3maxcc", (void *)&SC_max_i8, true },
+    { "_Z3minjj", (void *)&SC_min_u32, true },
+    { "_Z3mintt", (void *)&SC_min_u16, true },
+    { "_Z3minhh", (void *)&SC_min_u8, true },
+    { "_Z3minii", (void *)&SC_min_i32, true },
+    { "_Z3minss", (void *)&SC_min_i16, true },
+    { "_Z3mincc", (void *)&SC_min_i8, true },
+
+    { "_Z5clampfff", (void *)&SC_clamp_f32, true },
+    { "_Z3maxff", (void *)&SC_max_f32, true },
+    { "_Z3minff", (void *)&SC_min_f32, true },
+    { "_Z4stepff", (void *)&SC_step_f32, true },
+    //{ "smoothstep", (void *)&, true },
+    { "_Z4signf", (void *)&SC_sign_f32, true },
+
+    // matrix
+    { "_Z20rsMatrixLoadIdentityP12rs_matrix4x4", (void *)&SC_MatrixLoadIdentity_4x4, true },
+    { "_Z20rsMatrixLoadIdentityP12rs_matrix3x3", (void *)&SC_MatrixLoadIdentity_3x3, true },
+    { "_Z20rsMatrixLoadIdentityP12rs_matrix2x2", (void *)&SC_MatrixLoadIdentity_2x2, true },
+
+    { "_Z12rsMatrixLoadP12rs_matrix4x4PKf", (void *)&SC_MatrixLoad_4x4_f, true },
+    { "_Z12rsMatrixLoadP12rs_matrix3x3PKf", (void *)&SC_MatrixLoad_3x3_f, true },
+    { "_Z12rsMatrixLoadP12rs_matrix2x2PKf", (void *)&SC_MatrixLoad_2x2_f, true },
+
+    { "_Z12rsMatrixLoadP12rs_matrix4x4PKS_", (void *)&SC_MatrixLoad_4x4_4x4, true },
+    { "_Z12rsMatrixLoadP12rs_matrix4x4PK12rs_matrix3x3", (void *)&SC_MatrixLoad_4x4_3x3, true },
+    { "_Z12rsMatrixLoadP12rs_matrix4x4PK12rs_matrix2x2", (void *)&SC_MatrixLoad_4x4_2x2, true },
+    { "_Z12rsMatrixLoadP12rs_matrix3x3PKS_", (void *)&SC_MatrixLoad_3x3_3x3, true },
+    { "_Z12rsMatrixLoadP12rs_matrix2x2PKS_", (void *)&SC_MatrixLoad_2x2_2x2, true },
+
+    { "_Z18rsMatrixLoadRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadRotate, true },
+    { "_Z17rsMatrixLoadScaleP12rs_matrix4x4fff", (void *)&SC_MatrixLoadScale, true },
+    { "_Z21rsMatrixLoadTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixLoadTranslate, true },
+    { "_Z14rsMatrixRotateP12rs_matrix4x4ffff", (void *)&SC_MatrixRotate, true },
+    { "_Z13rsMatrixScaleP12rs_matrix4x4fff", (void *)&SC_MatrixScale, true },
+    { "_Z17rsMatrixTranslateP12rs_matrix4x4fff", (void *)&SC_MatrixTranslate, true },
+
+    { "_Z20rsMatrixLoadMultiplyP12rs_matrix4x4PKS_S2_", (void *)&SC_MatrixLoadMultiply_4x4_4x4_4x4, true },
+    { "_Z16rsMatrixMultiplyP12rs_matrix4x4PKS_", (void *)&SC_MatrixMultiply_4x4_4x4, true },
+    { "_Z20rsMatrixLoadMultiplyP12rs_matrix3x3PKS_S2_", (void *)&SC_MatrixLoadMultiply_3x3_3x3_3x3, true },
+    { "_Z16rsMatrixMultiplyP12rs_matrix3x3PKS_", (void *)&SC_MatrixMultiply_3x3_3x3, true },
+    { "_Z20rsMatrixLoadMultiplyP12rs_matrix2x2PKS_S2_", (void *)&SC_MatrixLoadMultiply_2x2_2x2_2x2, true },
+    { "_Z16rsMatrixMultiplyP12rs_matrix2x2PKS_", (void *)&SC_MatrixMultiply_2x2_2x2, true },
+
+    { "_Z17rsMatrixLoadOrthoP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadOrtho, true },
+    { "_Z19rsMatrixLoadFrustumP12rs_matrix4x4ffffff", (void *)&SC_MatrixLoadFrustum, true },
+    { "_Z23rsMatrixLoadPerspectiveP12rs_matrix4x4ffff", (void *)&SC_MatrixLoadPerspective, true },
+
+    { "_Z15rsMatrixInverseP12rs_matrix4x4", (void *)&SC_MatrixInverse_4x4, true },
+    { "_Z24rsMatrixInverseTransposeP12rs_matrix4x4", (void *)&SC_MatrixInverseTranspose_4x4, true },
+    { "_Z17rsMatrixTransposeP12rs_matrix4x4", (void *)&SC_MatrixTranspose_4x4, true },
+    { "_Z17rsMatrixTransposeP12rs_matrix3x3", (void *)&SC_MatrixTranspose_3x3, true },
+    { "_Z17rsMatrixTransposeP12rs_matrix2x2", (void *)&SC_MatrixTranspose_2x2, true },
+
+    // RS Math
+    { "_Z6rsRandi", (void *)&SC_randi, true },
+    { "_Z6rsRandii", (void *)&SC_randi2, true },
+    { "_Z6rsRandf", (void *)&SC_randf, true },
+    { "_Z6rsRandff", (void *)&SC_randf2, true },
+    { "_Z6rsFracf", (void *)&SC_frac, true },
+
+    // Atomics
+    { "_Z11rsAtomicIncPVi", (void *)&SC_AtomicInc, true },
+    { "_Z11rsAtomicIncPVj", (void *)&SC_AtomicInc, true },
+    { "_Z11rsAtomicDecPVi", (void *)&SC_AtomicDec, true },
+    { "_Z11rsAtomicDecPVj", (void *)&SC_AtomicDec, true },
+    { "_Z11rsAtomicAddPVii", (void *)&SC_AtomicAdd, true },
+    { "_Z11rsAtomicAddPVjj", (void *)&SC_AtomicAdd, true },
+    { "_Z11rsAtomicSubPVii", (void *)&SC_AtomicSub, true },
+    { "_Z11rsAtomicSubPVjj", (void *)&SC_AtomicSub, true },
+    { "_Z11rsAtomicAndPVii", (void *)&SC_AtomicAnd, true },
+    { "_Z11rsAtomicAndPVjj", (void *)&SC_AtomicAnd, true },
+    { "_Z10rsAtomicOrPVii", (void *)&SC_AtomicOr, true },
+    { "_Z10rsAtomicOrPVjj", (void *)&SC_AtomicOr, true },
+    { "_Z11rsAtomicXorPVii", (void *)&SC_AtomicXor, true },
+    { "_Z11rsAtomicXorPVjj", (void *)&SC_AtomicXor, true },
+    { "_Z11rsAtomicMinPVii", (void *)&SC_AtomicMin, true },
+    { "_Z11rsAtomicMinPVjj", (void *)&SC_AtomicUMin, true },
+    { "_Z11rsAtomicMaxPVii", (void *)&SC_AtomicMax, true },
+    { "_Z11rsAtomicMaxPVjj", (void *)&SC_AtomicUMax, true },
+    { "_Z11rsAtomicCasPViii", (void *)&SC_AtomicCas, true },
+    { "_Z11rsAtomicCasPVjjj", (void *)&SC_AtomicCas, true },
+
+    { NULL, NULL, false }
+};
+
+const RsdCpuReference::CpuSymbol * RsdCpuScriptImpl::lookupSymbolMath(const char *sym) {
+    const RsdCpuReference::CpuSymbol *syms = gSyms;
+
+    while (syms->fnPtr) {
+        if (!strcmp(syms->name, sym)) {
+            return syms;
+        }
+        syms++;
+    }
+    return NULL;
+}
+
diff --git a/cpu_ref/rsCpuRuntimeStubs.cpp b/cpu_ref/rsCpuRuntimeStubs.cpp
new file mode 100644
index 0000000..b87a639
--- /dev/null
+++ b/cpu_ref/rsCpuRuntimeStubs.cpp
@@ -0,0 +1,335 @@
+/*
+ * Copyright (C) 2011-2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsContext.h"
+#include "rsScriptC.h"
+#include "rsMatrix4x4.h"
+#include "rsMatrix3x3.h"
+#include "rsMatrix2x2.h"
+#include "rsRuntime.h"
+
+#include "utils/Timers.h"
+#include "rsCpuCore.h"
+#include "rsCpuScript.h"
+
+#include <time.h>
+
+using namespace android;
+using namespace android::renderscript;
+
+typedef float float2 __attribute__((ext_vector_type(2)));
+typedef float float3 __attribute__((ext_vector_type(3)));
+typedef float float4 __attribute__((ext_vector_type(4)));
+typedef char char2 __attribute__((ext_vector_type(2)));
+typedef char char3 __attribute__((ext_vector_type(3)));
+typedef char char4 __attribute__((ext_vector_type(4)));
+typedef unsigned char uchar2 __attribute__((ext_vector_type(2)));
+typedef unsigned char uchar3 __attribute__((ext_vector_type(3)));
+typedef unsigned char uchar4 __attribute__((ext_vector_type(4)));
+typedef short short2 __attribute__((ext_vector_type(2)));
+typedef short short3 __attribute__((ext_vector_type(3)));
+typedef short short4 __attribute__((ext_vector_type(4)));
+typedef unsigned short ushort2 __attribute__((ext_vector_type(2)));
+typedef unsigned short ushort3 __attribute__((ext_vector_type(3)));
+typedef unsigned short ushort4 __attribute__((ext_vector_type(4)));
+typedef int32_t int2 __attribute__((ext_vector_type(2)));
+typedef int32_t int3 __attribute__((ext_vector_type(3)));
+typedef int32_t int4 __attribute__((ext_vector_type(4)));
+typedef uint32_t uint2 __attribute__((ext_vector_type(2)));
+typedef uint32_t uint3 __attribute__((ext_vector_type(3)));
+typedef uint32_t uint4 __attribute__((ext_vector_type(4)));
+typedef long long long2 __attribute__((ext_vector_type(2)));
+typedef long long long3 __attribute__((ext_vector_type(3)));
+typedef long long long4 __attribute__((ext_vector_type(4)));
+typedef unsigned long long ulong2 __attribute__((ext_vector_type(2)));
+typedef unsigned long long ulong3 __attribute__((ext_vector_type(3)));
+typedef unsigned long long ulong4 __attribute__((ext_vector_type(4)));
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Message routines
+//////////////////////////////////////////////////////////////////////////////
+
+
+int SC_divsi3(int a, int b) {
+    return a / b;
+}
+
+int SC_modsi3(int a, int b) {
+    return a % b;
+}
+
+unsigned int SC_udivsi3(unsigned int a, unsigned int b) {
+    return a / b;
+}
+
+unsigned int SC_umodsi3(unsigned int a, unsigned int b) {
+    return a % b;
+}
+
+static void SC_debugF(const char *s, float f) {
+    ALOGD("%s %f, 0x%08x", s, f, *((int *) (&f)));
+}
+static void SC_debugFv2(const char *s, float f1, float f2) {
+    ALOGD("%s {%f, %f}", s, f1, f2);
+}
+static void SC_debugFv3(const char *s, float f1, float f2, float f3) {
+    ALOGD("%s {%f, %f, %f}", s, f1, f2, f3);
+}
+static void SC_debugFv4(const char *s, float f1, float f2, float f3, float f4) {
+    ALOGD("%s {%f, %f, %f, %f}", s, f1, f2, f3, f4);
+}
+static void SC_debugF2(const char *s, float2 f) {
+    ALOGD("%s {%f, %f}", s, f.x, f.y);
+}
+static void SC_debugF3(const char *s, float3 f) {
+    ALOGD("%s {%f, %f, %f}", s, f.x, f.y, f.z);
+}
+static void SC_debugF4(const char *s, float4 f) {
+    ALOGD("%s {%f, %f, %f, %f}", s, f.x, f.y, f.z, f.w);
+}
+static void SC_debugD(const char *s, double d) {
+    ALOGD("%s %f, 0x%08llx", s, d, *((long long *) (&d)));
+}
+static void SC_debugFM4v4(const char *s, const float *f) {
+    ALOGD("%s {%f, %f, %f, %f", s, f[0], f[4], f[8], f[12]);
+    ALOGD("%s  %f, %f, %f, %f", s, f[1], f[5], f[9], f[13]);
+    ALOGD("%s  %f, %f, %f, %f", s, f[2], f[6], f[10], f[14]);
+    ALOGD("%s  %f, %f, %f, %f}", s, f[3], f[7], f[11], f[15]);
+}
+static void SC_debugFM3v3(const char *s, const float *f) {
+    ALOGD("%s {%f, %f, %f", s, f[0], f[3], f[6]);
+    ALOGD("%s  %f, %f, %f", s, f[1], f[4], f[7]);
+    ALOGD("%s  %f, %f, %f}",s, f[2], f[5], f[8]);
+}
+static void SC_debugFM2v2(const char *s, const float *f) {
+    ALOGD("%s {%f, %f", s, f[0], f[2]);
+    ALOGD("%s  %f, %f}",s, f[1], f[3]);
+}
+static void SC_debugI8(const char *s, char c) {
+    ALOGD("%s %hhd  0x%hhx", s, c, (unsigned char)c);
+}
+static void SC_debugC2(const char *s, char2 c) {
+    ALOGD("%s {%hhd, %hhd}  0x%hhx 0x%hhx", s, c.x, c.y, (unsigned char)c.x, (unsigned char)c.y);
+}
+static void SC_debugC3(const char *s, char3 c) {
+    ALOGD("%s {%hhd, %hhd, %hhd}  0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z);
+}
+static void SC_debugC4(const char *s, char4 c) {
+    ALOGD("%s {%hhd, %hhd, %hhd, %hhd}  0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, (unsigned char)c.x, (unsigned char)c.y, (unsigned char)c.z, (unsigned char)c.w);
+}
+static void SC_debugU8(const char *s, unsigned char c) {
+    ALOGD("%s %hhu  0x%hhx", s, c, c);
+}
+static void SC_debugUC2(const char *s, uchar2 c) {
+    ALOGD("%s {%hhu, %hhu}  0x%hhx 0x%hhx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugUC3(const char *s, uchar3 c) {
+    ALOGD("%s {%hhu, %hhu, %hhu}  0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugUC4(const char *s, uchar4 c) {
+    ALOGD("%s {%hhu, %hhu, %hhu, %hhu}  0x%hhx 0x%hhx 0x%hhx 0x%hhx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugI16(const char *s, short c) {
+    ALOGD("%s %hd  0x%hx", s, c, c);
+}
+static void SC_debugS2(const char *s, short2 c) {
+    ALOGD("%s {%hd, %hd}  0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugS3(const char *s, short3 c) {
+    ALOGD("%s {%hd, %hd, %hd}  0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugS4(const char *s, short4 c) {
+    ALOGD("%s {%hd, %hd, %hd, %hd}  0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugU16(const char *s, unsigned short c) {
+    ALOGD("%s %hu  0x%hx", s, c, c);
+}
+static void SC_debugUS2(const char *s, ushort2 c) {
+    ALOGD("%s {%hu, %hu}  0x%hx 0x%hx", s, c.x, c.y, c.x, c.y);
+}
+static void SC_debugUS3(const char *s, ushort3 c) {
+    ALOGD("%s {%hu, %hu, %hu}  0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.x, c.y, c.z);
+}
+static void SC_debugUS4(const char *s, ushort4 c) {
+    ALOGD("%s {%hu, %hu, %hu, %hu}  0x%hx 0x%hx 0x%hx 0x%hx", s, c.x, c.y, c.z, c.w, c.x, c.y, c.z, c.w);
+}
+static void SC_debugI32(const char *s, int32_t i) {
+    ALOGD("%s %d  0x%x", s, i, i);
+}
+static void SC_debugI2(const char *s, int2 i) {
+    ALOGD("%s {%d, %d}  0x%x 0x%x", s, i.x, i.y, i.x, i.y);
+}
+static void SC_debugI3(const char *s, int3 i) {
+    ALOGD("%s {%d, %d, %d}  0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
+}
+static void SC_debugI4(const char *s, int4 i) {
+    ALOGD("%s {%d, %d, %d, %d}  0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
+}
+static void SC_debugU32(const char *s, uint32_t i) {
+    ALOGD("%s %u  0x%x", s, i, i);
+}
+static void SC_debugUI2(const char *s, uint2 i) {
+    ALOGD("%s {%u, %u}  0x%x 0x%x", s, i.x, i.y, i.x, i.y);
+}
+static void SC_debugUI3(const char *s, uint3 i) {
+    ALOGD("%s {%u, %u, %u}  0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.x, i.y, i.z);
+}
+static void SC_debugUI4(const char *s, uint4 i) {
+    ALOGD("%s {%u, %u, %u, %u}  0x%x 0x%x 0x%x 0x%x", s, i.x, i.y, i.z, i.w, i.x, i.y, i.z, i.w);
+}
+static void SC_debugLL64(const char *s, long long ll) {
+    ALOGD("%s %lld  0x%llx", s, ll, ll);
+}
+static void SC_debugL2(const char *s, long2 ll) {
+    ALOGD("%s {%lld, %lld}  0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
+}
+static void SC_debugL3(const char *s, long3 ll) {
+    ALOGD("%s {%lld, %lld, %lld}  0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
+}
+static void SC_debugL4(const char *s, long4 ll) {
+    ALOGD("%s {%lld, %lld, %lld, %lld}  0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
+}
+static void SC_debugULL64(const char *s, unsigned long long ll) {
+    ALOGD("%s %llu  0x%llx", s, ll, ll);
+}
+static void SC_debugUL2(const char *s, ulong2 ll) {
+    ALOGD("%s {%llu, %llu}  0x%llx 0x%llx", s, ll.x, ll.y, ll.x, ll.y);
+}
+static void SC_debugUL3(const char *s, ulong3 ll) {
+    ALOGD("%s {%llu, %llu, %llu}  0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.x, ll.y, ll.z);
+}
+static void SC_debugUL4(const char *s, ulong4 ll) {
+    ALOGD("%s {%llu, %llu, %llu, %llu}  0x%llx 0x%llx 0x%llx 0x%llx", s, ll.x, ll.y, ll.z, ll.w, ll.x, ll.y, ll.z, ll.w);
+}
+static void SC_debugP(const char *s, const void *p) {
+    ALOGD("%s %p", s, p);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Stub implementation
+//////////////////////////////////////////////////////////////////////////////
+
+// llvm name mangling ref
+//  <builtin-type> ::= v  # void
+//                 ::= b  # bool
+//                 ::= c  # char
+//                 ::= a  # signed char
+//                 ::= h  # unsigned char
+//                 ::= s  # short
+//                 ::= t  # unsigned short
+//                 ::= i  # int
+//                 ::= j  # unsigned int
+//                 ::= l  # long
+//                 ::= m  # unsigned long
+//                 ::= x  # long long, __int64
+//                 ::= y  # unsigned long long, __int64
+//                 ::= f  # float
+//                 ::= d  # double
+
+static RsdCpuReference::CpuSymbol gSyms[] = {
+    { "memset", (void *)&memset, true },
+    { "memcpy", (void *)&memcpy, true },
+
+    // Debug
+    { "_Z7rsDebugPKcf", (void *)&SC_debugF, true },
+    { "_Z7rsDebugPKcff", (void *)&SC_debugFv2, true },
+    { "_Z7rsDebugPKcfff", (void *)&SC_debugFv3, true },
+    { "_Z7rsDebugPKcffff", (void *)&SC_debugFv4, true },
+    { "_Z7rsDebugPKcDv2_f", (void *)&SC_debugF2, true },
+    { "_Z7rsDebugPKcDv3_f", (void *)&SC_debugF3, true },
+    { "_Z7rsDebugPKcDv4_f", (void *)&SC_debugF4, true },
+    { "_Z7rsDebugPKcd", (void *)&SC_debugD, true },
+    { "_Z7rsDebugPKcPK12rs_matrix4x4", (void *)&SC_debugFM4v4, true },
+    { "_Z7rsDebugPKcPK12rs_matrix3x3", (void *)&SC_debugFM3v3, true },
+    { "_Z7rsDebugPKcPK12rs_matrix2x2", (void *)&SC_debugFM2v2, true },
+    { "_Z7rsDebugPKcc", (void *)&SC_debugI8, true },
+    { "_Z7rsDebugPKcDv2_c", (void *)&SC_debugC2, true },
+    { "_Z7rsDebugPKcDv3_c", (void *)&SC_debugC3, true },
+    { "_Z7rsDebugPKcDv4_c", (void *)&SC_debugC4, true },
+    { "_Z7rsDebugPKch", (void *)&SC_debugU8, true },
+    { "_Z7rsDebugPKcDv2_h", (void *)&SC_debugUC2, true },
+    { "_Z7rsDebugPKcDv3_h", (void *)&SC_debugUC3, true },
+    { "_Z7rsDebugPKcDv4_h", (void *)&SC_debugUC4, true },
+    { "_Z7rsDebugPKcs", (void *)&SC_debugI16, true },
+    { "_Z7rsDebugPKcDv2_s", (void *)&SC_debugS2, true },
+    { "_Z7rsDebugPKcDv3_s", (void *)&SC_debugS3, true },
+    { "_Z7rsDebugPKcDv4_s", (void *)&SC_debugS4, true },
+    { "_Z7rsDebugPKct", (void *)&SC_debugU16, true },
+    { "_Z7rsDebugPKcDv2_t", (void *)&SC_debugUS2, true },
+    { "_Z7rsDebugPKcDv3_t", (void *)&SC_debugUS3, true },
+    { "_Z7rsDebugPKcDv4_t", (void *)&SC_debugUS4, true },
+    { "_Z7rsDebugPKci", (void *)&SC_debugI32, true },
+    { "_Z7rsDebugPKcDv2_i", (void *)&SC_debugI2, true },
+    { "_Z7rsDebugPKcDv3_i", (void *)&SC_debugI3, true },
+    { "_Z7rsDebugPKcDv4_i", (void *)&SC_debugI4, true },
+    { "_Z7rsDebugPKcj", (void *)&SC_debugU32, true },
+    { "_Z7rsDebugPKcDv2_j", (void *)&SC_debugUI2, true },
+    { "_Z7rsDebugPKcDv3_j", (void *)&SC_debugUI3, true },
+    { "_Z7rsDebugPKcDv4_j", (void *)&SC_debugUI4, true },
+    // Both "long" and "unsigned long" need to be redirected to their
+    // 64-bit counterparts, since we have hacked Slang to use 64-bit
+    // for "long" on Arm (to be similar to Java).
+    { "_Z7rsDebugPKcl", (void *)&SC_debugLL64, true },
+    { "_Z7rsDebugPKcDv2_l", (void *)&SC_debugL2, true },
+    { "_Z7rsDebugPKcDv3_l", (void *)&SC_debugL3, true },
+    { "_Z7rsDebugPKcDv4_l", (void *)&SC_debugL4, true },
+    { "_Z7rsDebugPKcm", (void *)&SC_debugULL64, true },
+    { "_Z7rsDebugPKcDv2_m", (void *)&SC_debugUL2, true },
+    { "_Z7rsDebugPKcDv3_m", (void *)&SC_debugUL3, true },
+    { "_Z7rsDebugPKcDv4_m", (void *)&SC_debugUL4, true },
+    { "_Z7rsDebugPKcx", (void *)&SC_debugLL64, true },
+    { "_Z7rsDebugPKcDv2_x", (void *)&SC_debugL2, true },
+    { "_Z7rsDebugPKcDv3_x", (void *)&SC_debugL3, true },
+    { "_Z7rsDebugPKcDv4_x", (void *)&SC_debugL4, true },
+    { "_Z7rsDebugPKcy", (void *)&SC_debugULL64, true },
+    { "_Z7rsDebugPKcDv2_y", (void *)&SC_debugUL2, true },
+    { "_Z7rsDebugPKcDv3_y", (void *)&SC_debugUL3, true },
+    { "_Z7rsDebugPKcDv4_y", (void *)&SC_debugUL4, true },
+    { "_Z7rsDebugPKcPKv", (void *)&SC_debugP, true },
+
+    { NULL, NULL, false }
+};
+
+
+void * RsdCpuScriptImpl::lookupRuntimeStub(void* pContext, char const* name) {
+    RsdCpuScriptImpl *s = (RsdCpuScriptImpl *)pContext;
+    const RsdCpuReference::CpuSymbol *syms = gSyms;
+    const RsdCpuReference::CpuSymbol *sym = NULL;
+
+    sym = s->mCtx->symLookup(name);
+    if (!sym) {
+        sym = s->lookupSymbolMath(name);
+    }
+    if (!sym) {
+        while (syms->fnPtr) {
+            if (!strcmp(syms->name, name)) {
+                sym = syms;
+            }
+            syms++;
+        }
+    }
+
+    if (sym) {
+        s->mIsThreadable &= sym->threadable;
+        return sym->fnPtr;
+    }
+    ALOGE("ScriptC sym lookup failed for %s", name);
+    return NULL;
+}
+
+
diff --git a/cpu_ref/rsCpuScript.cpp b/cpu_ref/rsCpuScript.cpp
new file mode 100644
index 0000000..06ce4bb
--- /dev/null
+++ b/cpu_ref/rsCpuScript.cpp
@@ -0,0 +1,463 @@
+/*
+ * Copyright (C) 2011-2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+#include "rsCpuCore.h"
+
+#include "rsCpuScript.h"
+//#include "rsdRuntime.h"
+//#include "rsdAllocation.h"
+//#include "rsCpuIntrinsics.h"
+
+
+#include "utils/Vector.h"
+#include "utils/Timers.h"
+#include "utils/StopWatch.h"
+
+
+#include <bcc/BCCContext.h>
+#include <bcc/Renderscript/RSCompilerDriver.h>
+#include <bcc/Renderscript/RSExecutable.h>
+#include <bcc/Renderscript/RSInfo.h>
+
+namespace android {
+namespace renderscript {
+
+
+
+RsdCpuScriptImpl::RsdCpuScriptImpl(RsdCpuReferenceImpl *ctx, const Script *s) {
+    mCtx = ctx;
+    mScript = s;
+
+    mRoot = NULL;
+    mRootExpand = NULL;
+    mInit = NULL;
+    mFreeChildren = NULL;
+
+    mCompilerContext = NULL;
+    mCompilerDriver = NULL;
+    mExecutable = NULL;
+
+    mBoundAllocs = NULL;
+    mIntrinsicData = NULL;
+    mIsThreadable = true;
+}
+
+
+bool RsdCpuScriptImpl::init(char const *resName, char const *cacheDir,
+                            uint8_t const *bitcode, size_t bitcodeSize,
+                            uint32_t flags) {
+    //ALOGE("rsdScriptCreate %p %p %p %p %i %i %p", rsc, resName, cacheDir, bitcode, bitcodeSize, flags, lookupFunc);
+    //ALOGE("rsdScriptInit %p %p", rsc, script);
+
+    mCtx->lockMutex();
+
+    bcc::RSExecutable *exec;
+    const bcc::RSInfo *info;
+
+    mCompilerContext = NULL;
+    mCompilerDriver = NULL;
+    mExecutable = NULL;
+
+    mCompilerContext = new bcc::BCCContext();
+    if (mCompilerContext == NULL) {
+        ALOGE("bcc: FAILS to create compiler context (out of memory)");
+        mCtx->unlockMutex();
+        return false;
+    }
+
+    mCompilerDriver = new bcc::RSCompilerDriver();
+    if (mCompilerDriver == NULL) {
+        ALOGE("bcc: FAILS to create compiler driver (out of memory)");
+        mCtx->unlockMutex();
+        return false;
+    }
+
+    mCompilerDriver->setRSRuntimeLookupFunction(lookupRuntimeStub);
+    mCompilerDriver->setRSRuntimeLookupContext(this);
+
+    exec = mCompilerDriver->build(*mCompilerContext, cacheDir, resName,
+                                  (const char *)bitcode, bitcodeSize, NULL);
+
+    if (exec == NULL) {
+        ALOGE("bcc: FAILS to prepare executable for '%s'", resName);
+        mCtx->unlockMutex();
+        return false;
+    }
+
+    mExecutable = exec;
+
+    exec->setThreadable(mIsThreadable);
+    if (!exec->syncInfo()) {
+        ALOGW("bcc: FAILS to synchronize the RS info file to the disk");
+    }
+
+    mRoot = reinterpret_cast<int (*)()>(exec->getSymbolAddress("root"));
+    mRootExpand =
+        reinterpret_cast<int (*)()>(exec->getSymbolAddress("root.expand"));
+    mInit = reinterpret_cast<void (*)()>(exec->getSymbolAddress("init"));
+    mFreeChildren =
+        reinterpret_cast<void (*)()>(exec->getSymbolAddress(".rs.dtor"));
+
+
+    info = &mExecutable->getInfo();
+    if (info->getExportVarNames().size()) {
+        mBoundAllocs = new Allocation *[info->getExportVarNames().size()];
+        memset(mBoundAllocs, 0, sizeof(void *) * info->getExportVarNames().size());
+    }
+
+    mCtx->unlockMutex();
+    return true;
+}
+
+void RsdCpuScriptImpl::populateScript(Script *script) {
+    const bcc::RSInfo *info = &mExecutable->getInfo();
+
+    // Copy info over to runtime
+    script->mHal.info.exportedFunctionCount = info->getExportFuncNames().size();
+    script->mHal.info.exportedVariableCount = info->getExportVarNames().size();
+    script->mHal.info.exportedPragmaCount = info->getPragmas().size();
+    script->mHal.info.exportedPragmaKeyList =
+        const_cast<const char**>(mExecutable->getPragmaKeys().array());
+    script->mHal.info.exportedPragmaValueList =
+        const_cast<const char**>(mExecutable->getPragmaValues().array());
+
+    if (mRootExpand) {
+        script->mHal.info.root = mRootExpand;
+    } else {
+        script->mHal.info.root = mRoot;
+    }
+}
+
+/*
+bool rsdInitIntrinsic(const Context *rsc, Script *s, RsScriptIntrinsicID iid, Element *e) {
+    pthread_mutex_lock(&rsdgInitMutex);
+
+    DrvScript *drv = (DrvScript *)calloc(1, sizeof(DrvScript));
+    if (drv == NULL) {
+        goto error;
+    }
+    s->mHal.drv = drv;
+    drv->mIntrinsicID = iid;
+    drv->mIntrinsicData = rsdIntrinsic_Init(rsc, s, iid, &drv->mIntrinsicFuncs);
+    s->mHal.info.isThreadable = true;
+
+    pthread_mutex_unlock(&rsdgInitMutex);
+    return true;
+
+error:
+    pthread_mutex_unlock(&rsdgInitMutex);
+    return false;
+}
+*/
+
+typedef void (*rs_t)(const void *, void *, const void *, uint32_t, uint32_t, uint32_t, uint32_t);
+
+void RsdCpuScriptImpl::forEachMtlsSetup(const Allocation * ain, Allocation * aout,
+                                        const void * usr, uint32_t usrLen,
+                                        const RsScriptCall *sc,
+                                        MTLaunchStruct *mtls) {
+
+    memset(mtls, 0, sizeof(MTLaunchStruct));
+
+    if (ain) {
+        mtls->fep.dimX = ain->getType()->getDimX();
+        mtls->fep.dimY = ain->getType()->getDimY();
+        mtls->fep.dimZ = ain->getType()->getDimZ();
+        //mtls->dimArray = ain->getType()->getDimArray();
+    } else if (aout) {
+        mtls->fep.dimX = aout->getType()->getDimX();
+        mtls->fep.dimY = aout->getType()->getDimY();
+        mtls->fep.dimZ = aout->getType()->getDimZ();
+        //mtls->dimArray = aout->getType()->getDimArray();
+    } else {
+        mCtx->getContext()->setError(RS_ERROR_BAD_SCRIPT, "rsForEach called with null allocations");
+        return;
+    }
+
+    if (!sc || (sc->xEnd == 0)) {
+        mtls->xEnd = mtls->fep.dimX;
+    } else {
+        rsAssert(sc->xStart < mtls->fep.dimX);
+        rsAssert(sc->xEnd <= mtls->fep.dimX);
+        rsAssert(sc->xStart < sc->xEnd);
+        mtls->xStart = rsMin(mtls->fep.dimX, sc->xStart);
+        mtls->xEnd = rsMin(mtls->fep.dimX, sc->xEnd);
+        if (mtls->xStart >= mtls->xEnd) return;
+    }
+
+    if (!sc || (sc->yEnd == 0)) {
+        mtls->yEnd = mtls->fep.dimY;
+    } else {
+        rsAssert(sc->yStart < mtls->fep.dimY);
+        rsAssert(sc->yEnd <= mtls->fep.dimY);
+        rsAssert(sc->yStart < sc->yEnd);
+        mtls->yStart = rsMin(mtls->fep.dimY, sc->yStart);
+        mtls->yEnd = rsMin(mtls->fep.dimY, sc->yEnd);
+        if (mtls->yStart >= mtls->yEnd) return;
+    }
+
+    mtls->xEnd = rsMax((uint32_t)1, mtls->xEnd);
+    mtls->yEnd = rsMax((uint32_t)1, mtls->yEnd);
+    mtls->zEnd = rsMax((uint32_t)1, mtls->zEnd);
+    mtls->arrayEnd = rsMax((uint32_t)1, mtls->arrayEnd);
+
+    rsAssert(!ain || (ain->getType()->getDimZ() == 0));
+
+    mtls->rsc = mCtx;
+    mtls->ain = ain;
+    mtls->aout = aout;
+    mtls->fep.usr = usr;
+    mtls->fep.usrLen = usrLen;
+    mtls->mSliceSize = 1;
+    mtls->mSliceNum = 0;
+
+    mtls->fep.ptrIn = NULL;
+    mtls->fep.eStrideIn = 0;
+    mtls->isThreadable = mIsThreadable;
+
+    if (ain) {
+        mtls->fep.ptrIn = (const uint8_t *)ain->mHal.drvState.lod[0].mallocPtr;
+        mtls->fep.eStrideIn = ain->getType()->getElementSizeBytes();
+        mtls->fep.yStrideIn = ain->mHal.drvState.lod[0].stride;
+    }
+
+    mtls->fep.ptrOut = NULL;
+    mtls->fep.eStrideOut = 0;
+    if (aout) {
+        mtls->fep.ptrOut = (uint8_t *)aout->mHal.drvState.lod[0].mallocPtr;
+        mtls->fep.eStrideOut = aout->getType()->getElementSizeBytes();
+        mtls->fep.yStrideOut = aout->mHal.drvState.lod[0].stride;
+    }
+}
+
+
+void RsdCpuScriptImpl::invokeForEach(uint32_t slot,
+                                     const Allocation * ain,
+                                     Allocation * aout,
+                                     const void * usr,
+                                     uint32_t usrLen,
+                                     const RsScriptCall *sc) {
+
+    MTLaunchStruct mtls;
+    forEachMtlsSetup(ain, aout, usr, usrLen, sc, &mtls);
+    forEachKernelSetup(slot, &mtls);
+
+    RsdCpuScriptImpl * oldTLS = mCtx->setTLS(this);
+    mCtx->launchThreads(ain, aout, sc, &mtls);
+    mCtx->setTLS(oldTLS);
+}
+
+void RsdCpuScriptImpl::forEachKernelSetup(uint32_t slot, MTLaunchStruct *mtls) {
+
+    mtls->script = this;
+    mtls->fep.slot = slot;
+
+    rsAssert(slot < mExecutable->getExportForeachFuncAddrs().size());
+    mtls->kernel = reinterpret_cast<ForEachFunc_t>(
+                      mExecutable->getExportForeachFuncAddrs()[slot]);
+    rsAssert(mtls->kernel != NULL);
+    mtls->sig = mExecutable->getInfo().getExportForeachFuncs()[slot].second;
+}
+
+int RsdCpuScriptImpl::invokeRoot() {
+    RsdCpuScriptImpl * oldTLS = mCtx->setTLS(this);
+    int ret = mRoot();
+    mCtx->setTLS(oldTLS);
+    return ret;
+}
+
+void RsdCpuScriptImpl::invokeInit() {
+    if (mInit) {
+        mInit();
+    }
+}
+
+void RsdCpuScriptImpl::invokeFreeChildren() {
+    if (mFreeChildren) {
+        mFreeChildren();
+    }
+}
+
+void RsdCpuScriptImpl::invokeFunction(uint32_t slot, const void *params,
+                                      size_t paramLength) {
+    //ALOGE("invoke %p %p %i %p %i", dc, script, slot, params, paramLength);
+
+    RsdCpuScriptImpl * oldTLS = mCtx->setTLS(this);
+    reinterpret_cast<void (*)(const void *, uint32_t)>(
+        mExecutable->getExportFuncAddrs()[slot])(params, paramLength);
+    mCtx->setTLS(oldTLS);
+}
+
+void RsdCpuScriptImpl::setGlobalVar(uint32_t slot, const void *data, size_t dataLength) {
+    //rsAssert(!script->mFieldIsObject[slot]);
+    //ALOGE("setGlobalVar %p %p %i %p %i", dc, script, slot, data, dataLength);
+
+    //if (mIntrinsicID) {
+        //mIntrinsicFuncs.setVar(dc, script, drv->mIntrinsicData, slot, data, dataLength);
+        //return;
+    //}
+
+    int32_t *destPtr = reinterpret_cast<int32_t *>(
+                          mExecutable->getExportVarAddrs()[slot]);
+    if (!destPtr) {
+        //ALOGV("Calling setVar on slot = %i which is null", slot);
+        return;
+    }
+
+    memcpy(destPtr, data, dataLength);
+}
+
+void RsdCpuScriptImpl::setGlobalVarWithElemDims(uint32_t slot, const void *data, size_t dataLength,
+                                                const Element *elem,
+                                                const size_t *dims, size_t dimLength) {
+
+    int32_t *destPtr = reinterpret_cast<int32_t *>(
+        mExecutable->getExportVarAddrs()[slot]);
+    if (!destPtr) {
+        //ALOGV("Calling setVar on slot = %i which is null", slot);
+        return;
+    }
+
+    // We want to look at dimension in terms of integer components,
+    // but dimLength is given in terms of bytes.
+    dimLength /= sizeof(int);
+
+    // Only a single dimension is currently supported.
+    rsAssert(dimLength == 1);
+    if (dimLength == 1) {
+        // First do the increment loop.
+        size_t stride = elem->getSizeBytes();
+        const char *cVal = reinterpret_cast<const char *>(data);
+        for (size_t i = 0; i < dims[0]; i++) {
+            elem->incRefs(cVal);
+            cVal += stride;
+        }
+
+        // Decrement loop comes after (to prevent race conditions).
+        char *oldVal = reinterpret_cast<char *>(destPtr);
+        for (size_t i = 0; i < dims[0]; i++) {
+            elem->decRefs(oldVal);
+            oldVal += stride;
+        }
+    }
+
+    memcpy(destPtr, data, dataLength);
+}
+
+void RsdCpuScriptImpl::setGlobalBind(uint32_t slot, Allocation *data) {
+
+    //rsAssert(!script->mFieldIsObject[slot]);
+    //ALOGE("setGlobalBind %p %p %i %p", dc, script, slot, data);
+
+    int32_t *destPtr = reinterpret_cast<int32_t *>(
+                          mExecutable->getExportVarAddrs()[slot]);
+    if (!destPtr) {
+        //ALOGV("Calling setVar on slot = %i which is null", slot);
+        return;
+    }
+
+    void *ptr = NULL;
+    mBoundAllocs[slot] = data;
+    if(data) {
+        ptr = data->mHal.drvState.lod[0].mallocPtr;
+    }
+    memcpy(destPtr, &ptr, sizeof(void *));
+}
+
+void RsdCpuScriptImpl::setGlobalObj(uint32_t slot, ObjectBase *data) {
+
+    //rsAssert(script->mFieldIsObject[slot]);
+    //ALOGE("setGlobalObj %p %p %i %p", dc, script, slot, data);
+
+    //if (mIntrinsicID) {
+        //mIntrinsicFuncs.setVarObj(dc, script, drv->mIntrinsicData, slot, alloc);
+        //return;
+    //}
+
+    int32_t *destPtr = reinterpret_cast<int32_t *>(
+                          mExecutable->getExportVarAddrs()[slot]);
+    if (!destPtr) {
+        //ALOGV("Calling setVar on slot = %i which is null", slot);
+        return;
+    }
+
+    rsrSetObject(mCtx->getContext(), (ObjectBase **)destPtr, data);
+}
+
+RsdCpuScriptImpl::~RsdCpuScriptImpl() {
+
+    if (mExecutable) {
+        Vector<void *>::const_iterator var_addr_iter =
+            mExecutable->getExportVarAddrs().begin();
+        Vector<void *>::const_iterator var_addr_end =
+            mExecutable->getExportVarAddrs().end();
+
+        bcc::RSInfo::ObjectSlotListTy::const_iterator is_object_iter =
+            mExecutable->getInfo().getObjectSlots().begin();
+        bcc::RSInfo::ObjectSlotListTy::const_iterator is_object_end =
+            mExecutable->getInfo().getObjectSlots().end();
+
+        while ((var_addr_iter != var_addr_end) &&
+               (is_object_iter != is_object_end)) {
+            // The field address can be NULL if the script-side has optimized
+            // the corresponding global variable away.
+            ObjectBase **obj_addr =
+                reinterpret_cast<ObjectBase **>(*var_addr_iter);
+            if (*is_object_iter) {
+                if (*var_addr_iter != NULL) {
+                    rsrClearObject(mCtx->getContext(), obj_addr);
+                }
+            }
+            var_addr_iter++;
+            is_object_iter++;
+        }
+    }
+
+    if (mCompilerContext) {
+        delete mCompilerContext;
+    }
+    if (mCompilerDriver) {
+        delete mCompilerDriver;
+    }
+    if (mExecutable) {
+        delete mExecutable;
+    }
+    if (mBoundAllocs) {
+        delete[] mBoundAllocs;
+    }
+}
+
+Allocation * RsdCpuScriptImpl::getAllocationForPointer(const void *ptr) const {
+    if (!ptr) {
+        return NULL;
+    }
+
+    for (uint32_t ct=0; ct < mScript->mHal.info.exportedVariableCount; ct++) {
+        Allocation *a = mBoundAllocs[ct];
+        if (!a) continue;
+        if (a->mHal.drvState.lod[0].mallocPtr == ptr) {
+            return a;
+        }
+    }
+    ALOGE("rsGetAllocation, failed to find %p", ptr);
+    return NULL;
+}
+
+
+}
+}
diff --git a/cpu_ref/rsCpuScript.h b/cpu_ref/rsCpuScript.h
new file mode 100644
index 0000000..2197a20
--- /dev/null
+++ b/cpu_ref/rsCpuScript.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2011-2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSD_BCC_H
+#define RSD_BCC_H
+
+#include <rs_hal.h>
+#include <rsRuntime.h>
+
+#include "rsCpuCore.h"
+
+namespace bcc {
+    class BCCContext;
+    class RSCompilerDriver;
+    class RSExecutable;
+}
+
+namespace android {
+namespace renderscript {
+
+
+
+class RsdCpuScriptImpl : public RsdCpuReferenceImpl::CpuScript {
+public:
+    typedef void (*outer_foreach_t)(
+        const RsForEachStubParamStruct *,
+        uint32_t x1, uint32_t x2,
+        uint32_t instep, uint32_t outstep);
+
+    bool init(char const *resName, char const *cacheDir,
+              uint8_t const *bitcode, size_t bitcodeSize, uint32_t flags);
+    virtual void populateScript(Script *);
+
+    virtual void invokeFunction(uint32_t slot, const void *params, size_t paramLength);
+    virtual int invokeRoot();
+    virtual void invokeForEach(uint32_t slot,
+                       const Allocation * ain,
+                       Allocation * aout,
+                       const void * usr,
+                       uint32_t usrLen,
+                       const RsScriptCall *sc);
+    virtual void invokeInit();
+    virtual void invokeFreeChildren();
+
+    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
+    virtual void setGlobalVarWithElemDims(uint32_t slot, const void *data, size_t dataLength,
+                                  const Element *e, const size_t *dims, size_t dimLength);
+    virtual void setGlobalBind(uint32_t slot, Allocation *data);
+    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
+
+
+    virtual ~RsdCpuScriptImpl();
+    RsdCpuScriptImpl(RsdCpuReferenceImpl *ctx, const Script *s);
+
+    const Script * getScript() {return mScript;}
+
+    void forEachMtlsSetup(const Allocation * ain, Allocation * aout,
+                          const void * usr, uint32_t usrLen,
+                          const RsScriptCall *sc, MTLaunchStruct *mtls);
+    virtual void forEachKernelSetup(uint32_t slot, MTLaunchStruct *mtls);
+
+
+    const RsdCpuReference::CpuSymbol * lookupSymbolMath(const char *sym);
+    static void * lookupRuntimeStub(void* pContext, char const* name);
+
+    virtual Allocation * getAllocationForPointer(const void *ptr) const;
+
+
+protected:
+    RsdCpuReferenceImpl *mCtx;
+    const Script *mScript;
+
+    int (*mRoot)();
+    int (*mRootExpand)();
+    void (*mInit)();
+    void (*mFreeChildren)();
+
+    bcc::BCCContext *mCompilerContext;
+    bcc::RSCompilerDriver *mCompilerDriver;
+    bcc::RSExecutable *mExecutable;
+
+    Allocation **mBoundAllocs;
+    void * mIntrinsicData;
+    bool mIsThreadable;
+
+};
+
+
+Allocation * rsdScriptGetAllocationForPointer(
+                        const Context *dc,
+                        const Script *script,
+                        const void *);
+
+
+
+}
+}
+
+#endif
diff --git a/cpu_ref/rsCpuScriptGroup.cpp b/cpu_ref/rsCpuScriptGroup.cpp
new file mode 100644
index 0000000..765057d
--- /dev/null
+++ b/cpu_ref/rsCpuScriptGroup.cpp
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsCpuCore.h"
+#include "rsCpuScript.h"
+#include "rsCpuScriptGroup.h"
+
+#include <bcc/BCCContext.h>
+#include <bcc/Renderscript/RSCompilerDriver.h>
+#include <bcc/Renderscript/RSExecutable.h>
+#include <bcc/Renderscript/RSInfo.h>
+
+#include "rsScript.h"
+#include "rsScriptGroup.h"
+#include "rsCpuScriptGroup.h"
+//#include "rsdBcc.h"
+//#include "rsdAllocation.h"
+
+using namespace android;
+using namespace android::renderscript;
+
+CpuScriptGroupImpl::CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroup *sg) {
+    mCtx = ctx;
+    mSG = sg;
+}
+
+CpuScriptGroupImpl::~CpuScriptGroupImpl() {
+
+}
+
+bool CpuScriptGroupImpl::init() {
+    return true;
+}
+
+void CpuScriptGroupImpl::setInput(const ScriptKernelID *kid, Allocation *a) {
+}
+
+void CpuScriptGroupImpl::setOutput(const ScriptKernelID *kid, Allocation *a) {
+}
+
+
+typedef void (*ScriptGroupRootFunc_t)(const RsForEachStubParamStruct *p,
+                                      uint32_t xstart, uint32_t xend,
+                                      uint32_t instep, uint32_t outstep);
+
+void CpuScriptGroupImpl::scriptGroupRoot(const RsForEachStubParamStruct *p,
+                                         uint32_t xstart, uint32_t xend,
+                                         uint32_t instep, uint32_t outstep) {
+
+
+    const ScriptList *sl = (const ScriptList *)p->usr;
+    RsForEachStubParamStruct *mp = (RsForEachStubParamStruct *)p;
+    const void *oldUsr = p->usr;
+
+    for(size_t ct=0; ct < sl->count; ct++) {
+        ScriptGroupRootFunc_t func;
+        func = (ScriptGroupRootFunc_t)sl->fnPtrs[ct];
+        mp->usr = sl->usrPtrs[ct];
+
+        mp->ptrIn = NULL;
+        mp->in = NULL;
+        mp->ptrOut = NULL;
+        mp->out = NULL;
+
+        if (sl->ins[ct]) {
+            mp->ptrIn = (const uint8_t *)sl->ins[ct]->mHal.drvState.lod[0].mallocPtr;
+            mp->in = mp->ptrIn;
+            if (sl->inExts[ct]) {
+                mp->in = mp->ptrIn + sl->ins[ct]->mHal.drvState.lod[0].stride * p->y;
+            } else {
+                if (sl->ins[ct]->mHal.drvState.lod[0].dimY > p->lid) {
+                    mp->in = mp->ptrIn + sl->ins[ct]->mHal.drvState.lod[0].stride * p->lid;
+                }
+            }
+        }
+
+        if (sl->outs[ct]) {
+            mp->ptrOut = (uint8_t *)sl->outs[ct]->mHal.drvState.lod[0].mallocPtr;
+            mp->out = mp->ptrOut;
+            if (sl->outExts[ct]) {
+                mp->out = mp->ptrOut + sl->outs[ct]->mHal.drvState.lod[0].stride * p->y;
+            } else {
+                if (sl->outs[ct]->mHal.drvState.lod[0].dimY > p->lid) {
+                    mp->out = mp->ptrOut + sl->outs[ct]->mHal.drvState.lod[0].stride * p->lid;
+                }
+            }
+        }
+
+        //ALOGE("kernel %i %p,%p  %p,%p", ct, mp->ptrIn, mp->in, mp->ptrOut, mp->out);
+        func(p, xstart, xend, instep, outstep);
+    }
+    //ALOGE("script group root");
+
+    //ConvolveParams *cp = (ConvolveParams *)p->usr;
+
+    mp->usr = oldUsr;
+}
+
+
+
+void CpuScriptGroupImpl::execute() {
+    Vector<Allocation *> ins;
+    Vector<bool> inExts;
+    Vector<Allocation *> outs;
+    Vector<bool> outExts;
+    Vector<const ScriptKernelID *> kernels;
+    bool fieldDep = false;
+
+    for (size_t ct=0; ct < mSG->mNodes.size(); ct++) {
+        ScriptGroup::Node *n = mSG->mNodes[ct];
+        Script *s = n->mKernels[0]->mScript;
+
+        //ALOGE("node %i, order %i, in %i out %i", (int)ct, n->mOrder, (int)n->mInputs.size(), (int)n->mOutputs.size());
+
+        for (size_t ct2=0; ct2 < n->mInputs.size(); ct2++) {
+            if (n->mInputs[ct2]->mDstField.get() && n->mInputs[ct2]->mDstField->mScript) {
+                //ALOGE("field %p %zu", n->mInputs[ct2]->mDstField->mScript, n->mInputs[ct2]->mDstField->mSlot);
+                s->setVarObj(n->mInputs[ct2]->mDstField->mSlot, n->mInputs[ct2]->mAlloc.get());
+            }
+        }
+
+        for (size_t ct2=0; ct2 < n->mKernels.size(); ct2++) {
+            const ScriptKernelID *k = n->mKernels[ct2];
+            Allocation *ain = NULL;
+            Allocation *aout = NULL;
+            bool inExt = false;
+            bool outExt = false;
+
+            for (size_t ct3=0; ct3 < n->mInputs.size(); ct3++) {
+                if (n->mInputs[ct3]->mDstKernel.get() == k) {
+                    ain = n->mInputs[ct3]->mAlloc.get();
+                    //ALOGE(" link in %p", ain);
+                }
+            }
+            for (size_t ct3=0; ct3 < mSG->mInputs.size(); ct3++) {
+                if (mSG->mInputs[ct3]->mKernel == k) {
+                    ain = mSG->mInputs[ct3]->mAlloc.get();
+                    inExt = true;
+                    //ALOGE(" io in %p", ain);
+                }
+            }
+
+            for (size_t ct3=0; ct3 < n->mOutputs.size(); ct3++) {
+                if (n->mOutputs[ct3]->mSource.get() == k) {
+                    aout = n->mOutputs[ct3]->mAlloc.get();
+                    if(n->mOutputs[ct3]->mDstField.get() != NULL) {
+                        fieldDep = true;
+                    }
+                    //ALOGE(" link out %p", aout);
+                }
+            }
+            for (size_t ct3=0; ct3 < mSG->mOutputs.size(); ct3++) {
+                if (mSG->mOutputs[ct3]->mKernel == k) {
+                    aout = mSG->mOutputs[ct3]->mAlloc.get();
+                    outExt = true;
+                    //ALOGE(" io out %p", aout);
+                }
+            }
+
+            if ((k->mHasKernelOutput == (aout != NULL)) &&
+                (k->mHasKernelInput == (ain != NULL))) {
+                ins.add(ain);
+                inExts.add(inExt);
+                outs.add(aout);
+                outExts.add(outExt);
+                kernels.add(k);
+            }
+        }
+
+    }
+
+    MTLaunchStruct mtls;
+
+    if(fieldDep) {
+        for (size_t ct=0; ct < ins.size(); ct++) {
+            Script *s = kernels[ct]->mScript;
+            RsdCpuScriptImpl *si = (RsdCpuScriptImpl *)mCtx->lookupScript(s);
+            uint32_t slot = kernels[ct]->mSlot;
+
+            si->forEachMtlsSetup(ins[ct], outs[ct], NULL, 0, NULL, &mtls);
+            si->forEachKernelSetup(slot, &mtls);
+            mCtx->launchThreads(ins[ct], outs[ct], NULL, &mtls);
+        }
+    } else {
+        ScriptList sl;
+        sl.ins = ins.array();
+        sl.outs = outs.array();
+        sl.kernels = kernels.array();
+        sl.count = kernels.size();
+
+        Vector<const void *> usrPtrs;
+        Vector<const void *> fnPtrs;
+        Vector<uint32_t> sigs;
+        for (size_t ct=0; ct < kernels.size(); ct++) {
+            Script *s = kernels[ct]->mScript;
+            RsdCpuScriptImpl *si = (RsdCpuScriptImpl *)mCtx->lookupScript(s);
+
+            si->forEachKernelSetup(kernels[ct]->mSlot, &mtls);
+            fnPtrs.add((void *)mtls.kernel);
+            usrPtrs.add(mtls.fep.usr);
+            sigs.add(mtls.fep.usrLen);
+        }
+        sl.sigs = sigs.array();
+        sl.usrPtrs = usrPtrs.array();
+        sl.fnPtrs = fnPtrs.array();
+        sl.inExts = inExts.array();
+        sl.outExts = outExts.array();
+
+        Script *s = kernels[0]->mScript;
+        RsdCpuScriptImpl *si = (RsdCpuScriptImpl *)mCtx->lookupScript(s);
+        si->forEachMtlsSetup(ins[0], outs[0], NULL, 0, NULL, &mtls);
+        mtls.script = NULL;
+        mtls.kernel = (void (*)())&scriptGroupRoot;
+        mtls.fep.usr = &sl;
+        mCtx->launchThreads(ins[0], outs[0], NULL, &mtls);
+    }
+}
+
+void rsdScriptGroupDestroy(const android::renderscript::Context *rsc,
+                           const android::renderscript::ScriptGroup *sg) {
+}
+
+
diff --git a/cpu_ref/rsCpuScriptGroup.h b/cpu_ref/rsCpuScriptGroup.h
new file mode 100644
index 0000000..f6fa2ac
--- /dev/null
+++ b/cpu_ref/rsCpuScriptGroup.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2011-2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSD_SCRIPT_GROUP_H
+#define RSD_SCRIPT_GROUP_H
+
+#include <rsd_cpu.h>
+
+namespace android {
+namespace renderscript {
+
+
+class CpuScriptGroupImpl : public RsdCpuReference::CpuScriptGroup {
+public:
+    virtual void setInput(const ScriptKernelID *kid, Allocation *);
+    virtual void setOutput(const ScriptKernelID *kid, Allocation *);
+    virtual void execute();
+    virtual ~CpuScriptGroupImpl();
+
+    CpuScriptGroupImpl(RsdCpuReferenceImpl *ctx, const ScriptGroup *sg);
+    bool init();
+
+    static void scriptGroupRoot(const RsForEachStubParamStruct *p,
+                                uint32_t xstart, uint32_t xend,
+                                uint32_t instep, uint32_t outstep);
+
+protected:
+    struct ScriptList {
+        size_t count;
+        Allocation *const* ins;
+        bool const* inExts;
+        Allocation *const* outs;
+        bool const* outExts;
+        const void *const* usrPtrs;
+        size_t const *usrSizes;
+        uint32_t const *sigs;
+        const void *const* fnPtrs;
+
+        const ScriptKernelID *const* kernels;
+    };
+    ScriptList mSl;
+    const ScriptGroup *mSG;
+    RsdCpuReferenceImpl *mCtx;
+};
+
+}
+}
+
+#endif // RSD_SCRIPT_GROUP_H
diff --git a/cpu_ref/rsd_cpu.h b/cpu_ref/rsd_cpu.h
new file mode 100644
index 0000000..d96d2d1
--- /dev/null
+++ b/cpu_ref/rsd_cpu.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSD_CPU_H
+#define RSD_CPU_H
+
+#include "rsAllocation.h"
+
+
+namespace android {
+namespace renderscript {
+
+class ScriptC;
+class Script;
+class ScriptGroup;
+class ScriptKernelID;
+
+
+class RsdCpuReference {
+public:
+    struct CpuSymbol {
+        const char * name;
+        void * fnPtr;
+        bool threadable;
+    };
+
+    typedef const CpuSymbol * (* sym_lookup_t)(Context *, const char *name);
+
+    struct CpuTls {
+        Context *rsc;
+        const ScriptC * sc;
+    };
+
+    class CpuScript {
+    public:
+        virtual void populateScript(Script *) = 0;
+        virtual void invokeFunction(uint32_t slot, const void *params, size_t paramLength) = 0;
+        virtual int invokeRoot() = 0;
+        virtual void invokeForEach(uint32_t slot,
+                           const Allocation * ain,
+                           Allocation * aout,
+                           const void * usr,
+                           uint32_t usrLen,
+                           const RsScriptCall *sc) = 0;
+        virtual void invokeInit() = 0;
+        virtual void invokeFreeChildren() = 0;
+
+        virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength) = 0;
+        virtual void setGlobalVarWithElemDims(uint32_t slot, const void *data, size_t dataLength,
+                                      const Element *e, const size_t *dims, size_t dimLength) = 0;
+        virtual void setGlobalBind(uint32_t slot, Allocation *data) = 0;
+        virtual void setGlobalObj(uint32_t slot, ObjectBase *obj) = 0;
+
+        virtual Allocation * getAllocationForPointer(const void *ptr) const = 0;
+        virtual ~CpuScript() {}
+    };
+    typedef CpuScript * (* script_lookup_t)(Context *, const Script *s);
+
+    class CpuScriptGroup {
+    public:
+        virtual void setInput(const ScriptKernelID *kid, Allocation *) = 0;
+        virtual void setOutput(const ScriptKernelID *kid, Allocation *) = 0;
+        virtual void execute() = 0;
+        virtual ~CpuScriptGroup() {};
+    };
+
+    static Context * getTlsContext();
+    static const Script * getTlsScript();
+
+    static RsdCpuReference * create(Context *c, uint32_t version_major,
+                                    uint32_t version_minor, sym_lookup_t lfn, script_lookup_t slfn);
+    virtual ~RsdCpuReference();
+    virtual void setPriority(int32_t priority) = 0;
+
+    virtual CpuScript * createScript(const ScriptC *s, char const *resName, char const *cacheDir,
+                                     uint8_t const *bitcode, size_t bitcodeSize,
+                                     uint32_t flags) = 0;
+    virtual CpuScript * createIntrinsic(const Script *s, RsScriptIntrinsicID iid, Element *e) = 0;
+    virtual CpuScriptGroup * createScriptGroup(const ScriptGroup *sg) = 0;
+};
+
+
+}
+}
+
+#endif