实现高性能Android高斯模糊技术

原创 于 2025-07-11 09:41:15 发布 · 294 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：高斯模糊在Android开发中用于创造视觉上的朦胧效果，例如启动图、背景和对话框边缘处理。本文将探讨在Android平台实现高斯模糊的多种方法，并强调性能优化的重要性。通过分块处理、离屏渲染、降低精度、异步处理和复用结果等关键优化手段，可以提升图片模糊处理的性能。本文提供了不同的高斯模糊实现方式，如Bitmap的ColorFilter、Renderscript、GPU Image库、自定义Shader和JavaCV，并强调在实际项目中根据需求和性能瓶颈灵活选择。
Android高斯模糊

1. Android高斯模糊实现

1.1 高斯模糊在Android上的应用背景

在移动应用中，模糊效果被广泛用于创造焦点效果、模拟景深、实现图像滤镜等视觉效果。Android平台上的开发者通过实现高斯模糊算法，可以提升应用的视觉吸引力。随着Android设备性能的提升，动态和实时模糊效果的需求日益增长。

1.2 实现高斯模糊的技术挑战

传统的高斯模糊算法可能在移动设备上运行缓慢，特别是在处理高分辨率的图片时。开发者必须考虑算法的优化，以及如何利用Android提供的API高效地实现高斯模糊，保证应用的流畅性和响应速度。

1.3 章节概述

本章将介绍高斯模糊效果的基本原理，以及在Android中实现该效果的多种方法。从使用平台提供的ColorFilter方法开始，到掌握更高效的自定义Shader编程技巧，以及如何通过多线程和优化技术提高模糊效果的性能。最后，我们将探讨如何异步处理高斯模糊操作，并复用模糊结果，以优化应用性能和用户体验。

2. 高斯模糊基本原理与Bitmap的ColorFilter方法

高斯模糊是一个图像处理中广泛使用的算法，它可以用于创建图片的模糊效果，常用于设计界面元素的阴影效果、减少图像噪声等。在Android开发中，我们通常可以通过使用Bitmap的ColorFilter方法来实现高斯模糊效果。

2.1 高斯模糊基本原理

高斯模糊是基于高斯函数的图像处理技术。高斯函数是自然界中一种非常重要的分布规律，具有平滑、无界的特性，因此非常适合用于图像模糊。

2.1.1 高斯模糊的数学基础

高斯模糊的核心在于高斯函数，其数学表达式如下： 

G(x) = 1 / (σ√(2π)) * e^(-(x^2) / (2σ^2))

其中， σ 表示标准差，控制模糊程度。 x 是高斯函数的输入变量，即像素值。高斯函数通过加权平均的方式，将每个像素的值与其周围像素值相结合，生成新的模糊像素值。

2.1.2 高斯核的构造与作用

在高斯模糊算法中，高斯核是一个非常重要的概念。它是一个矩阵，其元素值根据高斯分布进行分布。高斯核中的每个值都代表了相应像素及其邻域对目标像素的影响程度，也被称为权重。通过应用高斯核到图像上，我们可以对图像的每个像素进行加权平均，从而实现模糊效果。

2.2 Bitmap的ColorFilter方法应用

在Android中，Bitmap类提供了ColorFilter方法，允许开发者对图片进行颜色过滤处理。利用ColorFilter，我们可以实现高斯模糊效果。

2.2.1 ColorFilter的类型与特性

ColorFilter类是Android图像处理中的一个抽象类，它有多种子类，如LightingColorFilter、PorterDuffColorFilter和ColorMatrixColorFilter等。ColorFilter可以改变图像的显示，包括颜色、亮度、对比度等。

2.2.2 ColorFilter在高斯模糊中的应用实例

以下是一个使用ColorFilter实现高斯模糊的简单示例： 

// 假设我们有一个Bitmap对象叫做originalBitmap
Bitmap blurredBitmap = originalBitmap.copy(Bitmap.Config.ARGB_8888, true);

// 创建一个高斯模糊矩阵
Matrix matrix = new Matrix();
matrix.postScale(1.0f, 1.0f);
matrix.postTranslate(0, 0);

// 使用ColorMatrixColorFilter来应用模糊矩阵
ColorMatrixColorFilter filter = new ColorMatrixColorFilter(new float[] {
    1, 0, 0, 0, 0,
    0, 1, 0, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 0, 25, 0  // 这里的25是一个模糊因子，可以根据需要调整
});

Paint paint = new Paint();
paint.setColorFilter(filter);

// 使用Canvas将滤镜效果应用到新的Bitmap上
Canvas canvas = new Canvas(blurredBitmap);
canvas.drawBitmap(originalBitmap, 0, 0, paint);

// 现在blurredBitmap就是模糊后的图像

以上代码中，我们首先复制了一份原始的Bitmap对象，然后创建了一个高斯模糊矩阵，通过 ColorMatrixColorFilter 将其应用到图像上。 ColorMatrixColorFilter 接受一个 ColorMatrix 对象，其中 new float[] { 1, 0, 0, 0, 0, ... } 定义了矩阵的元素。其中，第四个元素是模糊因子，其值越大，图像越模糊。

请注意，上述示例并不是一个真正的高斯模糊实现，而是为了演示如何使用ColorFilter来应用模糊效果。真正的高斯模糊实现需要应用一个精确的高斯核，并考虑性能优化。

2.2.3 高斯模糊算法的实现

实现高斯模糊算法涉及到卷积操作，这里我们通过一个简化的例子来展示如何用代码实现高斯模糊的核心思想： 

// 假设我们已经根据需要的模糊度计算出一个高斯核
int[] gaussianKernel = new int[] {
    1, 2, 1,
    2, 4, 2,
    1, 2, 1
};

// 将高斯核归一化（除以核所有元素的和）
int sum = 0;
for (int i : gaussianKernel) {
    sum += i;
}
for (int i = 0; i < gaussianKernel.length; i++) {
    gaussianKernel[i] /= sum;
}

// 应用高斯核进行模糊处理
public Bitmap applyGaussianBlur(Bitmap source, int[] kernel) {
    Bitmap result = Bitmap.createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
    // 这里只是一个示意性的伪代码，实际应用时需要考虑边界条件，进行像素值的读取和计算
    for (int y = 0; y < source.getHeight(); y++) {
        for (int x = 0; x < source.getWidth(); x++) {
            // 对每个像素应用高斯核
            result.setPixel(x, y, applyKernel(source, x, y, kernel));
        }
    }
    return result;
}

// applyKernel函数负责读取周围像素值，乘以高斯核的权重，然后求和得到新像素值

以上代码展示了如何创建一个简单的高斯核，对其进行归一化处理，并将其应用于图片的每个像素上。在实际应用中，我们通常需要考虑边界处理以及处理性能问题，这可能会涉及到更复杂的像素读取和计算。

通过上面的例子我们可以看到，高斯模糊的基本原理和在Android中实现高斯模糊的基本方式。在下一章中，我们将深入探讨如何通过不同的技术手段实现高斯模糊效果，以达到更高的性能和更好的用户体验。

3. 高斯模糊的高效实现方式

高斯模糊是一种图像处理技术，广泛应用于视觉效果、隐私保护、界面美观等领域。本章节将深入探讨高斯模糊的高效实现方法，包括使用Renderscript、GPU Image库以及自定义Shader编程。这些方法各有其特点和适用场景，掌握它们将有助于开发者更有效地优化图像处理的性能。

3.1 Renderscript实现高斯模糊

Renderscript是一种性能强大的脚本语言，适用于运行在Android设备的多核处理器上，可执行高度优化的计算任务。本节将详细介绍Renderscript的基本概念和优势，以及如何利用它实现高斯模糊。

3.1.1 Renderscript的基本概念和优势

Renderscript最初设计用于3D图形渲染，但其强大的计算能力同样适用于图像处理。Renderscript使用自己的专用API，可与Android的其他图形处理部分无缝集成。它的主要优势在于：

  • 多核处理 ：Renderscript可以利用多核心CPU的优势，显著提升运算效率。
  • 优化性能 ：提供接近原生代码级别的性能，特别是在图像处理上。
  • 易用性 ：虽然基于C99标准，但Renderscript为Android开发者提供了简化接口。

3.1.2 使用Renderscript实现高斯模糊的步骤

以下是一个使用Renderscript实现高斯模糊的简化步骤：

  1. 创建Renderscript环境：
    java private void initRenderscript() { mRS = RenderScript.create(this); }

  2. 准备高斯核（Kernel）数据：
    java // 以二维数组的形式定义高斯核 final float[] GBlur = new float[] { 1, 2, 1, 2, 4, 2, 1, 2, 1 };

  3. 创建脚本以执行模糊操作：
    java ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(mRS, Element.U8_4(mRS));

  4. 加载图像并进行模糊处理：
    java Allocation allIn = Allocation.createFromBitmap(mRS, sourceBitmap); Allocation allOut = Allocation.createFromBitmap(mRS, resultBitmap); blurScript.setRadius(radius); // radius为高斯模糊半径 blurScript.setInput(allIn); blurScript.forEach(allOut); allOut.copyTo(resultBitmap);

参数说明与逻辑分析 ：

  • Radius ： setRadius() 方法设置的是高斯模糊的半径，值越大模糊程度越高，但同时计算量也会增加。
  • Allocation ：Renderscript中的Allocation用于管理内存中的数据，包括输入和输出。 createFromBitmap 用于创建与位图相关联的Allocation。
  • ScriptIntrinsicBlur ：Renderscript提供的内置高斯模糊算法，通过 forEach() 方法应用高斯核到图像上。

3.2 GPU Image库应用

GPU Image是一个开源的iOS和Android库，专门用于图像和视频处理。GPU Image可以利用设备的GPU硬件加速进行图像处理，从而提高处理效率。本节将介绍GPU Image库的基本概念，并示范如何利用它实现高斯模糊。

3.2.1 GPU Image库简介

GPU Image提供了一套完整的图像处理流程，从图像获取到处理再到显示，可以方便地添加各种过滤器。它封装了OpenGL ES的复杂性，使得开发者可以不需要深入了解GPU编程就能实现高性能的图像处理。

3.2.2 通过GPU Image库实现高斯模糊

使用GPU Image实现高斯模糊可以很简单，主要步骤如下：

  1. 配置GPUImage框架环境。

  2. 创建一个 GPUImageGaussianBlurFilter 对象，并设置相关参数：
    java GPUImageGaussianBlurFilter blurFilter = new GPUImageGaussianBlurFilter(); blurFilter.setBlurRadiusInPixels(2); // 设置模糊半径，单位为像素

  3. 将图像源和目标绑定到过滤器，并进行处理：
    java GPUImagePicture picture = new GPUImagePicture(inputImage); GPUImagePicture outputPicture = new GPUImagePicture(outputImageView); picture.addTarget(blurFilter); blurFilter.addTarget(outputPicture); picture.process();

以上代码首先创建了 GPUImagePicture 对象作为图像源，然后创建了一个 GPUImageGaussianBlurFilter 对象用于模糊处理，最后将模糊处理的结果绑定到 outputPicture 并进行渲染。

3.3 自定义Shader编程

Shader是一种在图形处理器（GPU）上运行的小程序，用于控制渲染效果。本节将介绍自定义Shader的基础知识，并通过技巧来实现高斯模糊。

3.3.1 Shader编程基础

Shader程序通常分为顶点Shader（Vertex Shader）和片段Shader（Fragment Shader）。顶点Shader负责处理顶点数据，而片段Shader负责处理像素数据。

3.3.2 自定义Shader实现高斯模糊的技巧

自定义Shader实现高斯模糊需要编写一个片段Shader程序来模糊图像。实现步骤如下：

  1. 创建自定义的片段Shader代码，实现高斯模糊算法。 
precision mediump float;

varying vec2 textureCoordinate;
uniform sampler2D inputImageTexture;

uniform float blurSize;

void main() {
    vec2 textureCoordinateToUse = textureCoordinate;
    vec2 singleStepOffset = vec2(blurSize, blurSize);
    vec4 sum = vec4(0.0);

    sum += texture2D(inputImageTexture, textureCoordinateToUse);
    textureCoordinateToUse -= singleStepOffset;
    sum += texture2D(inputImageTexture, textureCoordinateToUse);
    // 此处省略中间若干步
    gl_FragColor = sum / 9.0;
}
  1. 在Android中加载Shader并设置相应的uniform参数（如模糊半径），然后进行绘制。 
public void onDrawFrame(GL10 gl) {
    // 此处省略绘制的代码
}

代码逻辑解读 ：

  • uniform ：Shader中用于设置从外部传入的常量值，本例中 blurSize 即模糊半径。
  • texture2D ：读取对应纹理坐标的像素值。
  • sum ：用于累加模糊结果的变量。
  1. 通过调整 blurSize ，可以控制模糊程度，实现不同程度的高斯模糊效果。这种方式利用GPU的强大计算能力，相比CPU计算，可以实现更加高效的图像处理。

以上是本章第三个章节的内容，通过Renderscript、GPU Image库和自定义Shader编程，开发者可以实现高斯模糊的高效实现方式，满足不同场景下的性能和效果需求。

4. 高斯模糊的多线程与优化技术

高斯模糊作为图像处理中的常用技术，其计算过程往往对性能有着较高的要求。特别是在处理高分辨率图像时，如果没有合理的优化和处理策略，很容易出现卡顿或响应延迟的问题。因此，在本章节中，我们将深入探讨如何通过多线程技术以及相关的优化手段，提升高斯模糊的处理效率和性能。

4.1 性能优化策略

4.1.1 高斯模糊性能瓶颈分析

高斯模糊的实现过程，本质上是对图像进行卷积操作，该操作的复杂度与图像的分辨率成正比。以一个简单的一维高斯模糊为例，如果图像的宽度为W，高斯核的半径为R，则对于每个像素点的操作时间复杂度为O(2R)。在实际应用中，高斯模糊通常需要在水平和垂直两个方向上分别进行卷积操作，因此总体的时间复杂度为O((2R)²)。这使得高斯模糊在处理大尺寸图像时，对计算资源的需求大幅增加，成为性能的瓶颈。

在多线程处理的背景下，我们通常会遇到线程同步、资源竞争等挑战。这些问题若处理不当，将会带来额外的性能开销，反而降低程序的效率。

4.1.2 高斯模糊性能优化方案

为了优化高斯模糊的性能，我们可以采取以下几个策略：

  1. 分块处理技术 ：将大图像分割成若干个小块分别处理，可以有效减少内存消耗，并且能更好地利用多核处理器的并行计算能力。

  2. 离屏渲染 ：使用离屏缓冲区（off-screen buffer）来处理图像，可以减少对屏幕刷新的依赖，提高渲染效率。

  3. 降低颜色精度 ：通过减少图像颜色通道的位数来降低计算复杂度。例如，将颜色通道从32位降低到16位。

  4. 多线程处理 ：合理分配任务到多个线程中，充分利用多核CPU的计算资源，提升处理速度。

  5. 硬件加速 ：利用GPU进行图像处理，其并行计算能力远超CPU，特别适合大规模图像数据的处理。

4.2 分块处理技术

4.2.1 分块处理的原理和优势

分块处理技术是将原图像分割成多个小块，然后在这些小块上分别进行高斯模糊处理。这样做的优势在于：

  • 内存使用更高效 ：减少每次处理的图像大小，可以有效降低内存的消耗。
  • 并行处理能力提升 ：多个小块可以并行进行处理，提升计算效率。
  • 线程管理简化 ：小块的处理可以更快地完成，简化了线程同步和管理的复杂性。

4.2.2 实现分块处理高斯模糊的方法

假设我们有一个宽为W、高为H的图像，我们需要对这个图像进行高斯模糊处理。以下是一个简单的伪代码来说明分块处理高斯模糊的基本步骤： 

void processImageInBlocks() {
    int blockSize = 256; // 假设每个小块的大小为256x256
    for (int y = 0; y < H; y += blockSize) {
        for (int x = 0; x < W; x += blockSize) {
            int endX = Math.min(x + blockSize, W);
            int endY = Math.min(y + blockSize, H);
            Bitmap subImage = extractSubImage(image, x, y, endX, endY);
            Bitmap blurredSubImage = gaussianBlur(subImage);
            overwriteSubImage(image, blurredSubImage, x, y);
        }
    }
}

Bitmap extractSubImage(Bitmap image, int x, int y, int endX, int endY) {
    // 提取图像子块的逻辑
}

Bitmap gaussianBlur(Bitmap subImage) {
    // 对子块进行高斯模糊处理的逻辑
}

void overwriteSubImage(Bitmap original, Bitmap subBlurredImage, int x, int y) {
    // 将模糊处理后的子块覆盖到原图的对应位置
}

在上述伪代码中，我们首先定义了一个块的大小（blockSize），然后通过双层循环遍历图像的每一个块。对于每个块，我们提取出相应的子图像，执行高斯模糊操作，然后将模糊后的图像覆盖到原图的对应位置。这样，就可以实现分块处理高斯模糊的效果。

4.3 离屏渲染技术

4.3.1 离屏渲染的基本概念

离屏渲染技术是在屏幕之外的缓冲区内完成图像的渲染。与传统的直接在屏幕上渲染相比，离屏渲染可以将图像渲染过程与屏幕刷新过程分离，减少渲染对屏幕刷新的依赖，从而提高渲染效率。

在Android开发中，可以通过OpenGL ES或者类似的技术来实现离屏渲染。

4.3.2 应用离屏渲染优化高斯模糊的效果

使用离屏渲染优化高斯模糊，主要思路是在一个帧缓冲对象（Frame Buffer Object, FBO）中执行模糊操作，然后将结果绘制到屏幕上。这样可以减少对主线程的依赖，提高模糊操作的执行效率。 

int fbo; // 离屏渲染的帧缓冲对象

void setupFBO() {
    // 创建和配置帧缓冲对象的逻辑
    fbo = createFrameBufferObject();
}

void renderImageToScreen() {
    // 使用离屏渲染进行图像处理
    renderImageToFBO(fbo);
    // 将离屏渲染的结果绘制到屏幕上
    drawFBOContentToScreen(fbo);
}

int createFrameBufferObject() {
    // 创建帧缓冲对象的逻辑
}

void renderImageToFBO(int fbo) {
    // 在帧缓冲对象中进行高斯模糊处理的逻辑
}

void drawFBOContentToScreen(int fbo) {
    // 将帧缓冲对象中的内容绘制到屏幕的逻辑
}

通过上述代码示例，我们可以看到，离屏渲染首先需要创建一个帧缓冲对象（FBO），然后将图像渲染到这个FBO中进行处理。最后，再将FBO的内容绘制到屏幕上。这种方式可以有效地减少渲染过程中的同步问题，提高处理效率。

4.4 降低颜色精度

4.4.1 颜色精度对性能的影响

颜色精度是指在计算机图形学中，用于表示颜色信息的位数。一个颜色通道的位数越高，能够表示的颜色就越丰富。然而，更高的颜色精度意味着更高的计算和存储成本。在进行高斯模糊这样的图像处理操作时，如果可以适当降低颜色精度，不仅可以减少计算量，还能节省内存空间。

4.4.2 降低颜色精度提升高斯模糊性能的实践

例如，在Android中，Bitmap的默认颜色格式通常是ARGB_8888，每个像素需要32位的存储空间。我们可以通过改变颜色格式来降低颜色精度，比如使用RGB_565格式，每个像素只需要16位。以下是一个降低颜色精度的示例代码： 

Bitmap rgb565Image = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
Canvas canvas = new Canvas(rgb565Image);
canvas.drawBitmap(sourceImage, 0, 0, null);

在上述代码中，我们首先创建了一个RGB_565格式的Bitmap对象（rgb565Image），然后在这个对象上绘制原始图像（sourceImage）。这样，原始图像的像素数据就会被转换为RGB_565格式，从而实现颜色精度的降低。

在实际应用中，需要注意的是颜色精度的降低可能会导致图像质量的下降，特别是在颜色渐变和细节丰富的部分。因此，在决定降低颜色精度时，需要平衡性能提升与图像质量之间的关系。

至此，我们已经详细介绍了高斯模糊的多线程处理与优化技术。通过性能分析与优化策略的制定、分块处理、离屏渲染技术的运用，以及颜色精度的降低，我们可以显著提升高斯模糊的处理效率和性能。在下一章中，我们将进一步探讨如何处理高斯模糊操作的异步处理与复用，以便在应用中更加高效和智能地使用高斯模糊技术。

5. 高斯模糊操作的异步处理与复用

高斯模糊是一种广泛应用于图像处理的技术，可以产生模糊的视觉效果，增强图像的美观性或突出图像中需要关注的部分。然而，在Android开发中，高斯模糊的计算往往需要消耗较多的CPU资源，因此，合理地处理模糊操作，以及复用模糊结果，对于提升应用性能和用户体验至关重要。

5.1 异步处理模糊操作

5.1.1 异步处理的必要性

在Android应用中，UI线程（主线程）负责更新UI元素和处理用户交互，其响应速度直接影响了用户对应用的直观感受。如果在主线程中直接进行高斯模糊操作，那么模糊的计算可能会导致UI线程阻塞，出现短暂的界面卡顿，从而降低用户体验。因此，将高斯模糊操作放在一个单独的线程执行，采用异步处理方式是保证应用流畅运行的必要手段。

5.1.2 实现高斯模糊异步操作的技术方案

为了在Android中实现高斯模糊的异步操作，可以使用如 AsyncTask 、 HandlerThread 、 ExecutorService 或者 Kotlin协程 等并发工具。下面是一个使用 ExecutorService 实现高斯模糊异步操作的示例代码： 

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(() -> {
    // 在后台线程执行高斯模糊操作
    Bitmap blurredImage = gaussianBlur(inputImage);
    // 将处理后的结果返回到主线程
    final Handler mainHandler = new Handler(Looper.getMainLooper());
    mainHandler.post(() -> {
        imageView.setImageBitmap(blurredImage);
    });
});
executorService.shutdown();

上述代码中，我们创建了一个 ExecutorService ，提交了一个任务来执行高斯模糊，并通过 Handler 将处理好的图像传回主线程进行显示。

5.2 复用模糊结果

5.2.1 模糊结果复用的优势

在很多场景中，高斯模糊的操作结果是可以复用的。例如，如果应用中某个界面的背景经常需要模糊效果，那么可以预先计算一次模糊图像，并将其缓存起来。在后续需要时，直接从缓存中读取模糊图像，无需重新计算，这可以显著提高性能。

5.2.2 高斯模糊结果复用的实现方法

为了复用高斯模糊的结果，我们可以使用 LruCache 来缓存模糊后的图像。下面是一个简单的缓存实现示例： 

public class ImageCache {
    private LruCache<String, Bitmap> mMemoryCache;

    public ImageCache(int maxMemory) {
        // 获取应用的最大可用内存
        int cacheSize = maxMemory / 8;
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // 返回Bitmap的内存大小
                return bitmap.getByteCount();
            }
        };
    }

    public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
        if (getBitmapFromMemCache(key) == null) {
            mMemoryCache.put(key, bitmap);
        }
    }

    public Bitmap getBitmapFromMemCache(String key) {
        return mMemoryCache.get(key);
    }
}

在上述 ImageCache 类中，我们通过 LruCache 来缓存键值对，其中键为需要模糊的图片，值为模糊后的结果。当需要获取模糊图片时，我们首先尝试从缓存中获取，如果缓存中没有，我们才去计算模糊并将其存入缓存。

通过以上方法，我们实现了高斯模糊操作的异步处理和结果复用，有效提升了应用的性能和响应速度，同时也改善了用户体验。在后续的开发中，可以结合具体的应用场景进一步优化高斯模糊的实现策略。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：高斯模糊在Android开发中用于创造视觉上的朦胧效果，例如启动图、背景和对话框边缘处理。本文将探讨在Android平台实现高斯模糊的多种方法，并强调性能优化的重要性。通过分块处理、离屏渲染、降低精度、异步处理和复用结果等关键优化手段，可以提升图片模糊处理的性能。本文提供了不同的高斯模糊实现方式，如Bitmap的ColorFilter、Renderscript、GPU Image库、自定义Shader和JavaCV，并强调在实际项目中根据需求和性能瓶颈灵活选择。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

老光私享
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏