Context

I have an Android app that takes a picture, blurs the picture, removes the blur based on a mask and applies a final layer (not relevant). The last 2 steps, removing the blur based on a mask and applying a final layer is done repeatedly, each time with a new mask (150 masks).

The output get's drawn on a canvas (SurfaceView). This way the app effectively creates a view of the image with an animated blur.

Technical details & code

All of these image processing steps are achieved with RenderScript.

I'm leaving out the code for step 1, blurring the picture, since this is irrelevant for the problem I'm facing.

Step 2: removing the blur based on a mask

I have a custom kernel which takes an in Allocation as argument and holds 2 global variables, which are Allocations as well.

These 3 Allocations all get their data from bitmaps using Allocation.copyFrom(bitmap).

Step 3: applying a final layer

Here I have a custom kernel as well which takes an in Allocation as argument and holds 3 global variables, of which 1 is and Allocation and 2 are floats.

How these kernels work is irrelevant to this question but just to be sure I included some simplified snippets below.

Another thing to note is that I am following all best practices to ensure performance is at its best regarding Allocations, RenderScript and my SurfaceView.

So common mistakes such as creating a new RenderScript instance each time, not re-using Allocations when possible,.. are safe to ignore.

blurMask.rs

#pragma version(1)
#pragma rs java_package_name(com.example.rs)
#pragma rs_fp_relaxed

// Extra allocations
rs_allocation allocBlur;
rs_allocation allocBlurMask;

/*
 * RenderScript kernel that performs a masked blur manipulation.
 * Blur Pseudo: out = original * blurMask + blur * (1.0 - blurMask)
 * -> Execute this for all channels
 */
uchar4 __attribute__((kernel)) blur_mask(uchar4 inOriginal, uint32_t x, uint32_t y) {
    // Manually getting current element from the blur and mask allocations
    uchar4 inBlur = rsGetElementAt_uchar4(allocBlur, x, y);
    uchar4 inBlurMask = rsGetElementAt_uchar4(allocBlurMask, x, y);

   // normalize to 0.0 -> 1.0
    float4 inOriginalNorm = rsUnpackColor8888(inOriginal);
    float4 inBlurNorm = rsUnpackColor8888(inBlur);
    float4 inBlurMaskNorm = rsUnpackColor8888(inBlurMask);

    inBlurNorm.rgb = inBlurNorm.rgb * 0.7 + 0.3;

    float4 outNorm = inOriginalNorm;
    outNorm.rgb = inOriginalNorm.rgb * inBlurMaskNorm.rgb + inBlurNorm.rgb * (1.0 - inBlurMaskNorm.rgb);

    return rsPackColorTo8888(outNorm);
}

myKernel.rs

#pragma version(1)
#pragma rs java_package_name(com.example.rs)
#pragma rs_fp_relaxed

// Extra allocations
rs_allocation allocExtra;

// Randoms; Values are set from kotlin, the values below just act as a min placeholder.
float randB = 0.1f;
float randW = 0.75f;

/*
 * RenderScript kernel that performs a manipulation.
 */
uchar4 __attribute__((kernel)) my_kernel(uchar4 inOriginal, uint32_t x, uint32_t y) {
    // Manually getting current element from the extra allocation
    uchar4 inExtra = rsGetElementAt_uchar4(allocExtra, x, y);

   // normalize to 0.0 -> 1.0
    float4 inOriginalNorm = rsUnpackColor8888(inOriginal);
    float4 inExtraNorm = rsUnpackColor8888(inExtra);

    float4 outNorm = inOriginalNorm;
    if (inExtraNorm.r > 0.0) {
        outNorm.rgb = inOriginalNorm.rgb * 0.7 + 0.3;
        // Separate channel operation since we are using inExtraNorm.r everywhere
        outNorm.r = outNorm.r * inExtraNorm.r + inOriginalNorm.r * (1.0 - inExtraNorm.r);
        outNorm.g = outNorm.g * inExtraNorm.r + inOriginalNorm.g * (1.0 - inExtraNorm.r);
        outNorm.b = outNorm.b * inExtraNorm.r + inOriginalNorm.b * (1.0 - inExtraNorm.r);
    }
    else if (inExtraNorm.g > 0.0) {
        ...
    }

    return rsPackColorTo8888(outNorm);
}

Problem

So the app works great on a range of devices, even on low-end devices. I manually cap the FPS at 15, but when I remove this cap, I get results ranging from 15-20 on low-end devices to 35-40 on high-end devices.

The Samsung Galaxy S8 is where my problem occurs. For some reason I only manage to get around 10 FPS. If I use adb to force RenderScript to use CPU instead:

adb shell setprop debug.rs.default-CPU-driver 1

I get around 12-15 FPS, but obviously I want it to run on the GPU.

An important, weird thing I noticed

If I trigger a touch event, no matter where (even out of the app), the performance dramatically increases to around 35-40 FPS. If I lift my finger from the screen again, FPS drops back to 10 FPS.

NOTE: drawing the result on the SurfaceView can be excluded as an impacting factor since the results are the same with just the computation in RenderScript without drawing the actual result.

Questions

So I have more than one question really:

What could be the reason behind the low performance?
Why would a touch event improve this performance so dramatically?
How could I solve or work around this issue?