Android平台OpenGLES中实现最多10帧缓冲的方案咨询

我之前在做Android实时滤镜项目时也碰到过几乎一模一样的问题——多滤镜叠加导致GPU负载波动，帧率从相机的30FPS掉到25FPS，用循环帧缓冲来做“流量平滑”确实是个能平衡延迟和帧率稳定性的靠谱方案。下面给你拆解具体实现步骤和踩过的坑：

循环缓冲的本质是用固定延迟换稳定输出帧率：我们提前把处理好的帧缓存起来（最多10帧），输出阶段不管GPU当前处理速度，严格按照相机的30FPS间隔从缓冲池取帧显示。这样哪怕某几帧GPU处理慢了，也有之前缓存的帧兜底，不会出现掉帧卡顿；代价是引入约330ms的延迟（30FPS下每帧≈33ms，10帧就是330ms），这在大多数实时场景下是可接受的。

1. 创建循环复用的FBO帧缓冲池 #

首先要创建最多10个帧缓冲对象（FBO），每个FBO绑定一个纹理作为处理后帧的存储载体。注意要和相机输出的宽高完全一致，避免后续缩放额外消耗GPU性能。

private val frameBufferPool = mutableListOf<Int>()
private val frameBufferTextures = mutableListOf<Int>()
private val MAX_BUFFER_SIZE = 10

fun initFrameBufferPool(cameraWidth: Int, cameraHeight: Int) {
    for (i in 0 until MAX_BUFFER_SIZE) {
        // 创建FBO
        val fbo = IntArray(1)
        GLES20.glGenFramebuffers(1, fbo, 0)
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fbo[0])

        // 创建绑定纹理作为FBO的颜色附件
        val texture = IntArray(1)
        GLES20.glGenTextures(1, texture, 0)
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture[0])
        // 配置纹理参数，适配相机帧的RGBA格式
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, 
                            cameraWidth, cameraHeight, 0, 
                            GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null)
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR)
        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR)

        // 将纹理绑定到FBO
        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
                                      GLES20.GL_TEXTURE_2D, texture[0], 0)

        // 检查FBO完整性，避免后续渲染异常
        if (GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER) != GLES20.GL_FRAMEBUFFER_COMPLETE) {
            throw RuntimeException("FrameBuffer $i initialization failed")
        }

        // 加入池并解绑资源
        frameBufferPool.add(fbo[0])
        frameBufferTextures.add(texture[0])
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0)
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0)
    }
}

2. 用双指针+计数器实现循环缓冲逻辑 #

我们需要三个核心变量来管理缓冲池：

• writeIndex：当前处理后的帧要写入的FBO索引（生产者指针）
• readIndex：当前要输出到屏幕的FBO索引（消费者指针）
• bufferedFrameCount：已缓存的有效帧数（用来控制初始延迟）

核心流程： #

1. 填充缓冲阶段：启动后先让GPU处理10帧并填满缓冲池，此时不输出，直到bufferedFrameCount达到10，确保后续输出有足够的帧兜底。
2. 稳定输出阶段：
   • 相机采集到帧后，GL线程依次应用所有滤镜，将结果写入writeIndex指向的FBO，然后writeIndex递增（取模10）。
   • 输出线程（绑定屏幕刷新节奏）每隔33ms从readIndex指向的FBO取帧渲染到屏幕，然后readIndex递增（取模10）。
   • 如果GPU处理速度暂时跟不上采集速度，缓冲池里的帧会被逐步消耗，但只要之前填满过，就能撑过短期的负载高峰；如果长期处理速度不足，也可以选择覆盖最旧的帧（保证输出帧率稳定）。

线程安全的指针管理示例： #

private val writeIndex = AtomicInteger(0)
private val readIndex = AtomicInteger(0)
private val bufferedFrameCount = AtomicInteger(0)

// GL处理线程的帧处理逻辑
fun processCameraFrame(surfaceTexture: SurfaceTexture) {
    surfaceTexture.updateTexImage()
    val transformMatrix = FloatArray(16)
    surfaceTexture.getTransformMatrix(transformMatrix)

    // 获取当前要写入的FBO
    val currentFbo = frameBufferPool[writeIndex.get()]
    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, currentFbo)
    GLES20.glViewport(0, 0, cameraWidth, cameraHeight)

    // 依次应用所有滤镜（这里假设你已经有封装好的Filter类）
    var inputTexture = surfaceTexture.textureId
    for (filter in filterList) {
        inputTexture = filter.render(inputTexture, transformMatrix)
    }

    // 将最终结果渲染到FBO的纹理（用全屏四边形渲染即可）
    renderFullScreenQuad(inputTexture)

    // 更新指针和缓冲计数
    val nextWriteIndex = (writeIndex.get() + 1) % MAX_BUFFER_SIZE
    writeIndex.set(nextWriteIndex)
    if (bufferedFrameCount.get() < MAX_BUFFER_SIZE) {
        bufferedFrameCount.incrementAndGet()
    }

    // 解绑FBO
    GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0)
}

// 输出线程（绑定屏幕刷新，用Choreographer保证帧率稳定）
private val frameCallback = object : Choreographer.FrameCallback {
    override fun doFrame(frameTimeNanos: Long) {
        // 缓冲未填满时等待，避免初始输出空帧
        if (bufferedFrameCount.get() < MAX_BUFFER_SIZE) {
            Choreographer.getInstance().postFrameCallback(this)
            return
        }

        // 绑定屏幕Surface并渲染缓冲帧
        val surface = textureView.surface
        val eglSurface = eglHelper.createWindowSurface(surface)
        eglHelper.makeCurrent(eglSurface)

        val outputTexture = frameBufferTextures[readIndex.get()]
        GLES20.glViewport(0, 0, textureView.width, textureView.height)
        renderFullScreenQuad(outputTexture)

        // 交换缓冲区显示
        eglHelper.swapBuffers(eglSurface)
        eglHelper.destroySurface(eglSurface)

        // 更新读取指针
        val nextReadIndex = (readIndex.get() + 1) % MAX_BUFFER_SIZE
        readIndex.set(nextReadIndex)

        // 继续下一次屏幕刷新回调
        Choreographer.getInstance().postFrameCallback(this)
    }
}

// 启动输出
fun startRendering() {
    Choreographer.getInstance().postFrameCallback(frameCallback)
}

3. 关键注意事项 #

• EGL上下文共享：如果处理线程和输出线程是不同的线程，必须共享EGL上下文，否则纹理无法跨线程访问。创建EGL上下文时指定EGL_CONTEXT_CLIENT_VERSION并传入共享上下文即可。
• 资源销毁：在页面销毁时，必须调用glDeleteFramebuffers和glDeleteTextures释放FBO和纹理，避免内存泄漏。
• 帧同步：用Choreographer而不是Handler.postDelayed来触发输出，因为它和屏幕刷新率严格同步，能保证输出帧率的稳定性。
• 异常处理：要处理FBO初始化失败、纹理绑定错误等情况，避免Crash。

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