Hi David,

Great question—let’s break this down based on your core priorities: performance and device support.

Feasibility #

Absolutely doable. OpenGL ES (Android’s standard graphics API) lets you implement Lanczos interpolation directly in a fragment shader. Since Lanczos is essentially a convolution filter that weights surrounding pixels, you can write shader code to sample nearby texels, multiply by precomputed Lanczos kernel weights, and sum the results to get the interpolated pixel color.

Performance #

This is where OpenGL shines. The GPU is built for parallel pixel processing, and since your texture data is already in GPU memory (as part of the graphics pipeline), you avoid the overhead of copying data between CPU and GPU—a huge win for real-time use cases. Even with larger Lanczos kernels (like 5x5, which gives sharper results), modern Android GPUs handle the calculations with minimal latency—far faster than CPU-based implementations, and on par with optimized OpenCL code (without the data transfer costs).

Device Support #

Virtually universal. Every Android device ships with OpenGL ES support:

• GLES 2.0 works on Android 2.2+ (ancient devices at this point)
• GLES 3.0+ (which adds nicer shader features like textureLod for better sampling control) supports Android 4.3+ (99% of active devices as of 2024)
  You won’t have to worry about fragmentation here—your implementation will run on almost every phone/tablet out there.

Feasibility #

Yes, you can implement Lanczos with OpenCL—its parallel compute model is well-suited for convolution tasks. But the practical downsides outweigh the benefits for most Android use cases:

Performance #

While OpenCL can deliver fast GPU computations, the overhead of setting up the OpenCL context, copying image data from CPU memory to the GPU, and transferring results back can eat into performance. Unlike OpenGL, which keeps textures in GPU memory natively, OpenCL requires explicit data management—this is a big hit for real-time or interactive scenarios.

Device Support #

This is the killer issue. OpenCL support on Android is extremely fragmented. Some flagship devices (from Samsung, Qualcomm, etc.) include it, but it’s not a system-level requirement. Many mid-range and budget devices don’t support OpenCL at all, so your implementation would fail to run on a large chunk of your user base.

Go with OpenGL ES for Lanczos interpolation on Android. It’s:

• Fully compatible with nearly all devices
• Faster in practice (thanks to zero extra data transfers)
• Straightforward to implement with fragment shaders

Here’s a quick snippet of a GLES 3.0 fragment shader to get you started (for a 3x3 Lanczos kernel):

#version 300 es
precision mediump float;

in vec2 v_texCoord;
uniform sampler2D s_sourceTexture;
uniform vec2 u_textureDimensions;

// Precomputed Lanczos 3x3 kernel weights
const float lanczosKernel[9] = float[](
    0.037, 0.123, 0.037,
    0.123, 0.402, 0.123,
    0.037, 0.123, 0.037
);

out vec4 fragColor;

void main() {
    vec2 texelSize = 1.0 / u_textureDimensions;
    vec3 finalColor = vec3(0.0);
    int kernelIndex = 0;

    // Sample 3x3 surrounding texels
    for (int y = -1; y <= 1; y++) {
        for (int x = -1; x <= 1; x++) {
            vec2 sampleOffset = vec2(x, y) * texelSize;
            finalColor += texture(s_sourceTexture, v_texCoord + sampleOffset).rgb * lanczosKernel[kernelIndex];
            kernelIndex++;
        }
    }

    fragColor = vec4(finalColor, 1.0);
}

Note: For better results with variable scaling, you’ll want to adjust the kernel size and weights dynamically based on the scale factor, but this gives you the core idea.

内容的提问来源于stack exchange，提问作者David