Android OpenGL ES 3.0 Pixel Buffer Object使用

素颜马尾好姑娘i 2022-05-21 06:44 114阅读 0赞

关于PBO，找了很多资料，然而google了很久，大部分的PBO资料都和这个类似[https://blog.csdn.net/panda1234lee/article/details/51546502][https_blog.csdn.net_panda1234lee_article_details_51546502] 。在上传texture的过程中，我分别试了1、2、3个PBO来进行上传，然而效率并没有增加，反而下低了，有点无法理解。然而在读取数据时候，使用两个PBO是可以提高效率，所以总的来说还是有一定研究价值的。

#### 使用两个PBO减少glReadPixels的时间 ####

我这里模仿了一下不断采集纹理，我每次用同一张图片去完整更新纹理，就好像每次都采集了一张图片。然后使用FBO进行中间处理，读取数据后复制出来到一个数组。总的来说就是模拟摄像头采集然后编码的流程吧。主要是为了避免过多的逻辑尽量减少额外的功能点。

首先先生成两个PBO，并且分配空间，这里我还生成了三个上传纹理的PBO，但是没有使用了，因为上传纹理没办法通过PBO提高效率，有知道的大佬可以告诉一下原因。

if (init) {
            init= false;
            uploadPobs = new GLuint[3];
            downloadPbos = new GLuint[2];
            glGenBuffers(3, uploadPobs);
            glGenBuffers(2, downloadPbos);
            int align = 128;
            int width = curPicWidth;
            int height = curPicHeight;
            mPboSize = ((width * 4 + (align - 1)) & ~(align - 1)) * height;
            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, uploadPobs[0]);
            glBufferData(GL_PIXEL_UNPACK_BUFFER, mPboSize, 0, GL_STREAM_DRAW);
            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, uploadPobs[1]);
            glBufferData(GL_PIXEL_UNPACK_BUFFER, mPboSize, 0, GL_STREAM_DRAW);
            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, uploadPobs[2]);
            glBufferData(GL_PIXEL_UNPACK_BUFFER, mPboSize, 0, GL_STREAM_DRAW);
            glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
            glBindBuffer(GL_PIXEL_PACK_BUFFER, downloadPbos[0]);
            glBufferData(GL_PIXEL_PACK_BUFFER, mPboSize, 0, GL_STATIC_READ);
            glBindBuffer(GL_PIXEL_PACK_BUFFER, downloadPbos[1]);
            glBufferData(GL_PIXEL_PACK_BUFFER, mPboSize, 0, GL_STATIC_READ);
            glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
        }

接下来就是正常的OpenGL 的纹理绘制，我们将坐标绑定到VAO，然后创建FBO，并且绘制到FBO的纹理上。然后读取数据。最后我们再切换回屏幕，在绘制到屏幕上，这次看到的图形就是上下颠倒的了。之前我也试过不使用FBO直接每次更新单个纹理的整体数据来进行绘制，再使用PBO进行读取，但是无法提高效率。应该更新纹理的时候，发现异步DMA没有完成会等待，所以会导致纹理更新时间变长。所以还是需要使用FBO。

void PboRender::render() {
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        glDisable(GL_DITHER);
        glEnable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glViewport(0, 0, curPicWidth, curPicHeight);
        glUseProgram(program);
    //    resetTexture();
        glBindFramebuffer(GL_FRAMEBUFFER, frame);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture);
        glUniform1i(textureLocation, 0);
        glBindVertexArray(VAO[0]);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        readPixels();
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glViewport(0, 0, _backingWidth, _backingHeight);
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glBindTexture(GL_TEXTURE_2D, textureFrame);
        glBindVertexArray(VAO[0]);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    
    }

接着下面就是读取数据,同样模拟一下，功能就是读取数据之后复制到另一个数组，在这个过程中PBO真的是个大坑。同样的代码在不同的设备上性能差距太大了。提一下我发现的点吧。

*  首先看glReadPixels()，这个函数在使用PBO的时候，网上的资料都说会立刻返回，然后我实测依然会有等待时间。读取的byte数(也就是宽\*高\*4)不是128的倍数的时候，使用PBO和不使用几乎没有提升性能。而如果是128的倍数，这个时间几乎减少了5倍左右。应该是64位cpu的优化吧，也就是说如果我们录屏的时候分辨率设置设置得当，在使用软编的时候，是可以得到一些性能提升的。但是如果分辨率设置不当，考虑到后面需要复制数据，综合起来性能甚至会降低。(对于可能不是64位cpu的手机没有测试过）。
 *  接着就是复制数据时候的坑了，直接是memcpy()进行复制的时候，在不使用PBO的时候速度很快，但是在使用PBO的时候，我们再glMapBufferRange拿到对应数据的指针后，使用memcpy()会复制得特别慢，官方文档对这个API的描述也说了，可能会拿到不可缓存的内存区域，所以在读取的时候，性能会无法得到保证。再加上上一条说的时间，综合起来甚至不如不适用PBO，真的略坑。后来反复查找资料，使用ARM架构的NEON优化来拷贝数据，针对这种不可缓存的内存，在c++中使用汇编。测试下来，性能提升了很多。需要在build.gradle中开启NEON。  
    在defaultConfig\{\}下添加。

externalNativeBuild {
                cmake {
                    cppFlags "-std=c++11 -frtti -fexceptions"
                    arguments '-DANDROID_ARM_NEON=TRUE'
                }
            }

复制数据的方法

void my_copy(volatile unsigned char *dst, volatile unsigned char *src, int sz)
    {
        if (sz & 63) {
            sz = (sz & -64) + 64;
        }
        asm volatile (
        "NEONCopyPLD: \n"
                " VLDM %[src]!,{d0-d7} \n"
                " VSTM %[dst]!,{d0-d7} \n"
                " SUBS %[sz],%[sz],#0x40 \n"
                " BGT NEONCopyPLD \n"
        : [dst]"+r"(dst), [src]"+r"(src), [sz]"+r"(sz) : : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "cc", "memory");
    }

读取数据方法

void PboRender::readPixels() {
    
        int size = mPboSize;
        char path[40];
        sprintf(path, "/mnt/sdcard/pixel/readPixel%d.rgba", picCount);
    //    picCount--;
        if (picCount <= 0) {
            return;
        }
        if (!cachePixel) {
            cachePixel = new byte[size];
            memset(cachePixel, 0, size);
        }
    //    if (access("/mnt/sdcard/pixel", 0)) {
        
    //        mkdir("/mnt/sdcard/pixel", S_IRUSR | S_IWUSR | S_IXUSR | S_IRWXG | S_IRWXO);
    //    }
    //    FILE *file = fopen(path, "wb");
        glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
    
        long long curTime = getCurrentTime();
        if (downloadPboType == NONE) {
            long long cc = getCurrentTime();
            byte *pixel = new byte[size];
            glReadPixels(0, 0, curPicWidth, curPicHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixel);
            LOGE("glReadPixels Time %lld", getCurrentTime() - cc);
            cc = getCurrentTime();
    //        fwrite(pixel, size, 1, file);
            memcpy(cachePixel, pixel, size);
            LOGE("内存复制耗时 %lld", getCurrentTime() - cc);
            delete[] pixel;
        } else if (downloadPboType == ONE) {
    
    
        } else if (downloadPboType == TWO) {
            index = (index + 1) % 2;
            nextIndex = (index + 1) % 2;
            glBindBuffer(GL_PIXEL_PACK_BUFFER, downloadPbos[index]);
            long long cc = getCurrentTime();
            glReadPixels(0, 0, curPicWidth, curPicHeight, GL_RGBA, GL_UNSIGNED_BYTE, 0);
            LOGE("glReadPixels Time %lld", getCurrentTime() - cc);
    
            if (readPixInit) {
                readPixInit = false;
                glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
                return;
            }
            glBindBuffer(GL_PIXEL_PACK_BUFFER, downloadPbos[nextIndex]);
            GLubyte *ptr = static_cast<GLubyte *>(glMapBufferRange(GL_PIXEL_PACK_BUFFER, 0,
                                                                   mPboSize,
                                                                   GL_MAP_READ_BIT));
            glUnmapBuffer(GL_PIXEL_PACK_BUFFER); // release pointer to mapping buffer
            cc = getCurrentTime();
            if (ptr) {
                my_copy(cachePixel,ptr,size);
    
    
            }
            glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
    
    //            fwrite(ptr, size, 1, file);
            LOGE("内存复制耗时 %lld", getCurrentTime() - cc);
    
        }
    //    fclose(file);
    
        LOGE("完成耗时%lld", getCurrentTime() - curTime);
    }

好了，文章就到这里了，不是特别长，代码逻辑也比较简单，但是在性能测试上真的花了不少时间，PBO确实可以在一定条件下大幅提升性能，如果项目需要还是可以尝试一下，当然我们还可以在GPU内把数据转成YUV422,这样读取的时候时间还可以减少一半。总的来说性能应该提升比较大的，就是PBO需要OpenGL ES 3.0，在手机版本上需要适配。

[源码][Link 1]

[https_blog.csdn.net_panda1234lee_article_details_51546502]: https://blog.csdn.net/panda1234lee/article/details/51546502
[Link 1]: https://github.com/TYGitHubPersonal/AndoridOpenGLCube