作者：位元組流動

來源：

https://blog.csdn.net/Kennethdroid/article/details/103189489

penGL ES 相機預覽

相機開發是 OpenGL ES 的重要應用，利用 OpenGL 可以很友善地實作相機美顔、濾鏡、塑型以及一些動态特效，其性能顯著優于對應功能的 CPU 實作。

相機的預覽實作一般有 2 種方式，一種是基于 Android 原生 SurfaceTexture 的純 GPU 實作方式，另一種是通過相機的預覽回調接口擷取幀的 YUV 資料，利用 CPU 算法處理完成之後，傳入顯存，再利用 GPU 實作 YUV 轉 RGBA 進行渲染，即 CPU + GPU 的實作方式。

基于 Android 原生 SurfaceTexture 的純 GPU 實作方式，相機可以使用 SurfaceTexture 作為預覽載體，SurfaceTexture 可來自于 GLSurfaceView、TextureView 或 SurfaceView 這些獨立擁有 Surface 的封裝類，也可以自定義實作。

作為預覽載體的 SurfaceTexture 綁定的紋理需要是 OES 紋理，即

GLES11Ext.GL_TEXTURE_EXTERNAL_OES

紋理，來自于 GLES 的擴充

#extension GL_OES_EGL_image_external

中，使用 OES 紋理後，我們不需要在片段着色器中自己做 YUV to RGBA 的轉換，因為 OES 紋理可以直接接收 YUV 資料或者直接輸出 YUV 資料。

類似于普通 2D 紋理的建立，OES 紋理建立的實作如下：

private int createOESTexture(){
    int[] texture = new int[1];
    GLES20.glGenTextures(1, texture, 0);
    GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture[0]);
    GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
        GL10.GL_TEXTURE_MIN_FILTER,GL10.GL_LINEAR);
    GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
        GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
        GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
    GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
        GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
    return texture[0];
}

使用 OES 紋理需要修改片段着色器，在着色器腳本的頭部增加擴充紋理的聲明

#extension GL_OES_EGL_image_external : require

，并且紋理采樣器不再使用 sample2D ，需要換成 samplerExternalOES 作為紋理采樣器。

#version 300 es
#extension GL_OES_EGL_image_external : require
precision mediump float;
in vec2 v_texCoord;
uniform samplerExternalOES s_TexSampler;
void main() {
    gl_FragColor = texture(s_TexSampler, v_texCoord);
}

實際上當使用 TextureView 時，實際上也不需要自己去建立 OES 紋理，隻需要綁定相機，配置好變換矩陣後即可實作相機預覽。具體例子可直接參考

Android 官方的 Samples https://github.com/android/camera-samples

。

相機預覽基于 Android 原生 API 的純 GPU 實作方式，操作簡單，代碼量很少，原生 API 已經做了很多封裝，可以利用片段着色器輕易實作美顔濾鏡等相機特效，缺點是擴充性差，例如要使用傳統的 CPU 算法做一些濾鏡或者美顔特效就很不友善，圖像資料需要多次在記憶體與顯存之間拷貝，會造成性能和功耗問題。

本文主要介紹将圖像資料取出，傳入 Native 層，然後對資料做一些處理（可選），最後再做渲染的方式，這種方式相對複雜一些。相機預覽資料的常見格式是 YUV420P 或者 YUV420SP(NV21) ，需要将圖像資料對應 YUV 3 個分量使用 3 個紋理傳入顯存，在片段着色器中将 YUV 資料轉為 RGBA 。

相關原理可參考

NDK OpenGL ES 3.0 開發（三）：YUV 渲染

章節。

相機預覽資料擷取，以 Camera2 為例，主要是通過 ImageReader 實作，該類封裝了 Surface ：

private ImageReader.OnImageAvailableListener mOnPreviewImageAvailableListener = new ImageReader.OnImageAvailableListener() {
    @Override
    public void onImageAvailable(ImageReader reader) {
        Image image = reader.acquireLatestImage();
        if (image != null) {
            if (mCamera2FrameCallback != null) {
                mCamera2FrameCallback.onPreviewFrame(CameraUtil.YUV_420_888_data(image), image.getWidth(), image.getHeight());
            }
            image.close();
        }
    }
};

mPreviewImageReader = ImageReader.newInstance(mPreviewSize.getWidth(), mPreviewSize.getHeight(), ImageFormat.YUV_420_888, 2);
mPreviewImageReader.setOnImageAvailableListener(mOnPreviewImageAvailableListener, mBackgroundHandler);

CaptureRequest.Builder builder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
builder.addTarget(mPreviewImageReader.getSurface());

ession.setRepeatingRequest(mPreviewRequest, null, mBackgroundHandler);

//在自定義接口中擷取預覽資料，通過 JNI 傳入到 C++ 層
public void onPreviewFrame(byte[] data, int width, int height) {
    Log.d(TAG, "onPreviewFrame() called with: data = [" + data + "], width = [" + width + "], height = [" + height + "]");
    mByteFlowRender.setRenderFrame(IMAGE_FORMAT_I420, data, width, height);

    //每次傳入新資料，請求重新渲染
    mByteFlowRender.requestRender();
}

主要的 JNI ：

public abstract class ByteFlowRender {
    public static final int GL_RENDER_TYPE = 0;
    public static final int CL_RENDER_TYPE = 1;

    public static final int IMAGE_FORMAT_RGBA = 0x01;
    public static final int IMAGE_FORMAT_NV21 = 0x02;
    public static final int IMAGE_FORMAT_NV12 = 0x03;
    public static final int IMAGE_FORMAT_I420 = 0x04;

    public static final int PARAM_TYPE_SET_SHADER_INDEX = 201;

    static {
        System.loadLibrary("byteflow_render");
    }

    private long mNativeContextHandle;

    protected native void native_CreateContext(int renderType);

    protected native void native_DestroyContext();

    protected native int native_Init(int initType);

    protected native int native_UnInit();

    protected native void native_UpdateFrame(int format, byte[] data, int width, int height);

    protected native void native_LoadFilterData(int index, int format, int width, int height, byte[] bytes);

    protected native void native_LoadShaderScript(int shaderIndex, String scriptStr);

    protected native void native_SetTransformMatrix(float translateX, float translateY, float scaleX, float scaleY, int degree, int mirror);

    protected native void native_SetParamsInt(int paramType, int value);

    protected native int native_GetParamsInt(int paramType);

    protected native void native_OnSurfaceCreated();

    protected native void native_OnSurfaceChanged(int width, int height);

    protected native void native_OnDrawFrame();
}

渲染 YUV 資料用到的着色器腳本，主要是将 3 個紋理對應的 YUV 分量，分别采樣後轉成 RGBA ：

//頂點着色器
#version 100
varying vec2 v_texcoord;
attribute vec4 position;
attribute vec2 texcoord;
uniform mat4 MVP;
void main() {
    v_texcoord = texcoord;
    gl_Position = MVP*position;
}

//片段着色器
#version 100
precision highp float;
varying vec2 v_texcoord;
uniform lowp sampler2D s_textureY;
uniform lowp sampler2D s_textureU;
uniform lowp sampler2D s_textureV;
void main() {
    float y, u, v, r, g, b;
    y = texture2D(s_textureY, v_texcoord).r;
    u = texture2D(s_textureU, v_texcoord).r;
    v = texture2D(s_textureV, v_texcoord).r;
    u = u - 0.5;
    v = v - 0.5;
    r = y + 1.403 * v;
    g = y - 0.344 * u - 0.714 * v;
    b = y + 1.770 * u;
    gl_FragColor = vec4(r, g, b, 1.0);
}

C++ 層的主要實作：

//編譯連結着色器
int GLByteFlowRender::CreateProgram(const char *pVertexShaderSource, const char *pFragShaderSource)
{
    m_Program = GLUtils::CreateProgram(pVertexShaderSource, pFragShaderSource, m_VertexShader,
                                       m_FragShader);
    if (!m_Program)
    {
        GLUtils::CheckGLError("Create Program");
        LOGCATE("GLByteFlowRender::CreateProgram Could not create program.");
        return 0;
    }

    m_YTextureHandle = glGetUniformLocation(m_Program, "s_textureY");
    m_UTextureHandle = glGetUniformLocation(m_Program, "s_textureU");
    m_VTextureHandle = glGetUniformLocation(m_Program, "s_textureV");

    m_VertexCoorHandle = (GLuint) glGetAttribLocation(m_Program, "position");
    m_TextureCoorHandle = (GLuint) glGetAttribLocation(m_Program, "texcoord");
    m_MVPHandle = glGetUniformLocation(m_Program, "MVP");

    return m_Program;
}

//建立 YUV 分量對應的 3 個紋理
bool GLByteFlowRender::CreateTextures()
{
    LOGCATE("GLByteFlowRender::CreateTextures");
    GLsizei yWidth = static_cast<GLsizei>(m_RenderFrame.width);
    GLsizei yHeight = static_cast<GLsizei>(m_RenderFrame.height);

    glActiveTexture(GL_TEXTURE0);
    glGenTextures(1, &m_YTextureId);
    glBindTexture(GL_TEXTURE_2D, m_YTextureId);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, yWidth, yHeight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
                 NULL);

    if (!m_YTextureId)
    {
        GLUtils::CheckGLError("Create Y texture");
        return false;
    }

    GLsizei uWidth = static_cast<GLsizei>(m_RenderFrame.width / 2);
    GLsizei uHeight = yHeight / 2;

    glActiveTexture(GL_TEXTURE1);
    glGenTextures(1, &m_UTextureId);
    glBindTexture(GL_TEXTURE_2D, m_UTextureId);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, uWidth, uHeight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
                 NULL);

    if (!m_UTextureId)
    {
        GLUtils::CheckGLError("Create U texture");
        return false;
    }

    GLsizei vWidth = static_cast<GLsizei>(m_RenderFrame.width / 2);
    GLsizei vHeight = (GLsizei) yHeight / 2;

    glActiveTexture(GL_TEXTURE2);
    glGenTextures(1, &m_VTextureId);
    glBindTexture(GL_TEXTURE_2D, m_VTextureId);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, vWidth, vHeight, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
                 NULL);

    if (!m_VTextureId)
    {
        GLUtils::CheckGLError("Create V texture");
        return false;
    }

    return true;
}

//每傳入一幀新資料後，更新紋理
bool GLByteFlowRender::UpdateTextures()
{
    LOGCATE("GLByteFlowRender::UpdateTextures");
    if (m_RenderFrame.ppPlane[0] == NULL)
    {
        return false;
    }

    if (!m_YTextureId && !m_UTextureId && !m_VTextureId && !CreateTextures())
    {
        return false;
    }

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_YTextureId);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, (GLsizei) m_RenderFrame.width,
                 (GLsizei) m_RenderFrame.height, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, m_RenderFrame.ppPlane[0]);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, m_UTextureId);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, (GLsizei) m_RenderFrame.width >> 1,
                 (GLsizei) m_RenderFrame.height >> 1, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, m_RenderFrame.ppPlane[1]);

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, m_VTextureId);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, (GLsizei) m_RenderFrame.width >> 1,
                 (GLsizei) m_RenderFrame.height >> 1, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, m_RenderFrame.ppPlane[2]);

    return true;
}

//綁定紋理到着色器，傳入頂點和紋理坐标資料
GLuint GLByteFlowRender::UseProgram()
{
    LOGCATE("GLByteFlowRender::UseProgram");
    ByteFlowLock lock(&m_ShaderBufLock);
    if (m_IsShaderChanged)
    {
        GLUtils::DeleteProgram(m_Program);
        CreateProgram(kVertexShader, m_pFragShaderBuf);
        m_IsShaderChanged = false;
        m_IsProgramChanged = true;
    }


    if (!m_Program)
    {
        LOGCATE("GLByteFlowRender::UseProgram Could not use program.");
        return 0;
    }

    if (m_IsProgramChanged)
    {
        glUseProgram(m_Program);
        GLUtils::CheckGLError("GLByteFlowRender::UseProgram");

        glVertexAttribPointer(m_VertexCoorHandle, 2, GL_FLOAT, GL_FALSE, 2 * 4, VERTICES_COORS);
        glEnableVertexAttribArray(m_VertexCoorHandle);

        glUniform1i(m_YTextureHandle, 0);
        glUniform1i(m_UTextureHandle, 1);
        glUniform1i(m_VTextureHandle, 2);

        glVertexAttribPointer(m_TextureCoorHandle, 2, GL_FLOAT, GL_FALSE, 2 * 4, TEXTURE_COORS);
        glEnableVertexAttribArray(m_TextureCoorHandle);

        m_IsProgramChanged = false;
    }
    return m_Program;
}

//渲染預覽圖像
void GLByteFlowRender::OnDrawFrame()
{
    LOGCATE("GLByteFlowRender::OnDrawFrame");
    glViewport(0, 0, m_ViewportWidth, m_ViewportHeight);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glDisable(GL_CULL_FACE);

    if (!UpdateTextures() || !UseProgram())
    {
        LOGCATE("GLByteFlowRender::OnDrawFrame skip frame");
        return;
    }
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

後面文章會基于該預覽實作添加一些濾鏡效果。

聯系與交流

技術交流/擷取源碼可以添加我的微信：Byte-Flow

「視訊雲技術」你最值得關注的音視訊技術公衆号，每周推送來自阿裡雲一線的實踐技術文章，在這裡與音視訊領域一流工程師交流切磋。

NDK OpenGL ES 3.0 開發（十六）：相機預覽penGL ES 相機預覽聯系與交流

penGL ES 相機預覽

聯系與交流

繼續閱讀

CSMA/CD1． CSMA/CD的概述2． CSMA 的工作原理3． CSMA/CD控制規程及特點4． CSMA/CD協定5． CSMA/CD的優點6．結束語

Windows下VS開發環境環境安裝工程項目設定關于Debug和Release的提示

一文看懂字元串的加減乘除

極大似然法(ML)與最大期望法(EM)

C++ 第十五周報告1--《冒泡法排序》

C++實作簡單順序表

筆試面試題目：滑動視窗(二)

資料結構與算法（27）——排序（二）

Android電視機（機頂盒）初次開發的一些經驗分享

Dijkstra--簡易版（最短路徑）

C經典書籍筆記——C陷阱與缺陷②(文法陷阱之優先級)一、錯誤案列二、優先級規律

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

線性表之順序表的實作

C++判斷素數、求最大公約數代碼判斷一個數是否為素數求兩個數的最大公約數

SequoiaDB巨杉資料庫C++驅動概述

hdu7108哈希