diff --git a/driver/rsdAllocation.cpp b/driver/rsdAllocation.cpp
index 790005d..a3203a7 100644
--- a/driver/rsdAllocation.cpp
+++ b/driver/rsdAllocation.cpp
@@ -302,16 +302,15 @@
     return uvSize;
 }
 
-
 static size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc,
-        const Type *type, uint8_t *ptr) {
+                                          const Type *type, uint8_t *ptr, size_t requiredAlignment) {
     alloc->mHal.drvState.lod[0].dimX = type->getDimX();
     alloc->mHal.drvState.lod[0].dimY = type->getDimY();
     alloc->mHal.drvState.lod[0].dimZ = type->getDimZ();
     alloc->mHal.drvState.lod[0].mallocPtr = 0;
-    // Stride needs to be 16-byte aligned too!
+    // Stride needs to be aligned to a boundary defined by requiredAlignment!
     size_t stride = alloc->mHal.drvState.lod[0].dimX * type->getElementSizeBytes();
-    alloc->mHal.drvState.lod[0].stride = rsRound(stride, 16);
+    alloc->mHal.drvState.lod[0].stride = rsRound(stride, requiredAlignment);
     alloc->mHal.drvState.lodCount = type->getLODCount();
     alloc->mHal.drvState.faceCount = type->getDimFaces();
 
@@ -335,7 +334,7 @@
             alloc->mHal.drvState.lod[lod].dimY = ty;
             alloc->mHal.drvState.lod[lod].dimZ = tz;
             alloc->mHal.drvState.lod[lod].stride =
-                    rsRound(tx * type->getElementSizeBytes(), 16);
+                    rsRound(tx * type->getElementSizeBytes(), requiredAlignment);
             offsets[lod] = o;
             o += alloc->mHal.drvState.lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u);
             if (tx > 1) tx >>= 1;
@@ -359,9 +358,14 @@
     return allocSize;
 }
 
-static uint8_t* allocAlignedMemory(size_t allocSize, bool forceZero) {
-    // We align all allocations to a 16-byte boundary.
-    uint8_t* ptr = (uint8_t *)memalign(16, allocSize);
+static size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc,
+                                          const Type *type, uint8_t *ptr) {
+    return AllocationBuildPointerTable(rsc, alloc, type, ptr, Allocation::kMinimumRSAlignment);
+}
+
+static uint8_t* allocAlignedMemory(size_t allocSize, bool forceZero, size_t requiredAlignment) {
+    // We align all allocations to a boundary defined by requiredAlignment.
+    uint8_t* ptr = (uint8_t *)memalign(requiredAlignment, allocSize);
     if (!ptr) {
         return nullptr;
     }
@@ -371,15 +375,20 @@
     return ptr;
 }
 
-bool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) {
+bool rsdAllocationInitStrided(const Context *rsc, Allocation *alloc, bool forceZero, size_t requiredAlignment) {
     DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation));
     if (!drv) {
         return false;
     }
     alloc->mHal.drv = drv;
 
+    // Check if requiredAlignment is power of 2, also requiredAlignment should be larger or equal than kMinimumRSAlignment.
+    if ((requiredAlignment & (requiredAlignment-1)) != 0 || requiredAlignment < Allocation::kMinimumRSAlignment) {
+        ALOGE("requiredAlignment must be power of 2");
+        return false;
+    }
     // Calculate the object size.
-    size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), nullptr);
+    size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), nullptr, requiredAlignment);
 
     uint8_t * ptr = nullptr;
     if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) {
@@ -387,6 +396,20 @@
     } else if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) {
         // Allocation is allocated when the surface is created
         // in getSurface
+#ifdef RS_COMPATIBILITY_LIB
+    } else if (alloc->mHal.state.usageFlags == (RS_ALLOCATION_USAGE_INCREMENTAL_SUPPORT | RS_ALLOCATION_USAGE_SHARED)) {
+        if (alloc->mHal.state.userProvidedPtr == nullptr) {
+            ALOGE("User-backed buffer pointer cannot be null");
+            return false;
+        }
+        if (alloc->getType()->getDimLOD() || alloc->getType()->getDimFaces()) {
+            ALOGE("User-allocated buffers must not have multiple faces or LODs");
+            return false;
+        }
+
+        drv->useUserProvidedPtr = true;
+        ptr = (uint8_t*)alloc->mHal.state.userProvidedPtr;
+#endif
     } else if (alloc->mHal.state.userProvidedPtr != nullptr) {
         // user-provided allocation
         // limitations: no faces, no LOD, USAGE_SCRIPT or SCRIPT+TEXTURE only
@@ -400,13 +423,13 @@
             return false;
         }
 
-        // rows must be 16-byte aligned
+        // rows must be aligned based on requiredAlignment.
         // validate that here, otherwise fall back to not use the user-backed allocation
-        if (((alloc->getType()->getDimX() * alloc->getType()->getElement()->getSizeBytes()) % 16) != 0) {
+        if (((alloc->getType()->getDimX() * alloc->getType()->getElement()->getSizeBytes()) % requiredAlignment) != 0) {
             ALOGV("User-backed allocation failed stride requirement, falling back to separate allocation");
             drv->useUserProvidedPtr = false;
 
-            ptr = allocAlignedMemory(allocSize, forceZero);
+            ptr = allocAlignedMemory(allocSize, forceZero, requiredAlignment);
             if (!ptr) {
                 alloc->mHal.drv = nullptr;
                 free(drv);
@@ -418,7 +441,7 @@
             ptr = (uint8_t*)alloc->mHal.state.userProvidedPtr;
         }
     } else {
-        ptr = allocAlignedMemory(allocSize, forceZero);
+        ptr = allocAlignedMemory(allocSize, forceZero, requiredAlignment);
         if (!ptr) {
             alloc->mHal.drv = nullptr;
             free(drv);
@@ -426,7 +449,7 @@
         }
     }
     // Build the pointer tables
-    size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr);
+    size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr, requiredAlignment);
     if(allocSize != verifySize) {
         rsAssert(!"Size mismatch");
     }
@@ -476,6 +499,10 @@
     return true;
 }
 
+bool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) {
+    return rsdAllocationInitStrided(rsc, alloc, forceZero, Allocation::kMinimumRSAlignment);
+}
+
 void rsdAllocationAdapterOffset(const Context *rsc, const Allocation *alloc) {
     //ALOGE("rsdAllocationAdapterOffset");