Android OpenGL 以原始(小)分辨率渲染到 frameBuffer，然后将其缩放(viewPort)到屏幕尺寸-6ren

Android OpenGL 以原始(小)分辨率渲染到 frameBuffer，然后将其缩放(viewPort)到屏幕尺寸

转载作者：塔克拉玛干更新时间：2023-11-03 00:58:44

我有一个 NV21 (YUV420) 摄像机视频，我正在对其应用 fragment 着色器以获得一些滤镜效果以及 YUV 到 RGB 的转换。除了性能不佳外，一切正常。我的 fragment 着色器有点重，因为它有很多 textur2D() 调用。

原始帧分辨率为 480x640 像素，我注意到如果我将视口(viewport)设置为这个原始大小(而不是全屏大小)，它运行良好且流畅。

所以基本上我需要首先渲染帧并在 frameBuffer (FBO) 中以原始大小处理它，然后(在着色器工作完成后)使用视口(viewport)(主要是 1080x1920)将它缩放到全屏大小，这意味着“繁重”的处理工作将应用于更少的 fragment 。

我在这里找到了一些教程和类似的问题如何实现这一点，但不幸的是我没有运气。 (有一些黑屏或 GL_INVALID_OPERATION 等)...任何帮助将不胜感激。

此外，另一个我不知道如何处理(如果可能的话)的(可选的)性能调整是以某种方式将这 3 个纹理(Y_tex、U_tex 和 V_tex)组合成一个单一的纹理，该纹理统一到着色器作为单个采样器，然后我可以在着色器中调用一次 texture2D() 以获取当前 YUV 值并将它们转换为 RGB 值。

这是我的渲染器代码:

static class MyRenderer implements GLSurfaceView.Renderer
{
    int mTextureIds[] = new int[3];
    float[] mScaleMatrix = new float[16];

    private FloatBuffer mVertexBuffer;
    private FloatBuffer mTextureBuffer;
    private ShortBuffer mDrawListBuffer;

    boolean mVideoFitEnabled = true;
    boolean mVideoDisabled = false;

    // number of coordinates per vertex in this array
    static final int COORDS_PER_VERTEX = 3;
    static final int TEXTURECOORDS_PER_VERTEX = 2;

    static float mXYZCoords[] = {
            -1.0f, 1.0f, 0.0f, // top left
            -1.0f, -1.0f, 0.0f, // bottom left
            1.0f, -1.0f, 0.0f, // bottom right
            1.0f, 1.0f, 0.0f // top right
    };

    static float mUVCoords[] = {
            0, 0, // top left
            0, 1, // bottom left
            1, 1, // bottom right
            1, 0  // top right
    };

    private short mVertexIndex[] = {0, 1, 2, 0, 2, 3}; // order to draw vertices

    private final String vertexShaderCode =

              "uniform mat4 uMVPMatrix;"
            + "attribute vec4 aPosition;\n"
            + "attribute vec2 aTextureCoord;\n"
            + "varying vec2 vTextureCoord;\n"

            + "void main() {\n"
                + "  gl_Position = uMVPMatrix * aPosition;\n"
                + "  vTextureCoord = aTextureCoord;\n"
            + "}\n";


    private final String fragmentShaderCode =

              "precision mediump float;\n"
            + "uniform sampler2D Ytex;\n"
            + "uniform sampler2D Utex,Vtex;\n"
            + "varying vec2 vTextureCoord;\n"

            + "void main(void) {\n"
                + "  float nx,ny,r,g,b,y,u,v;\n"
                + "  mediump vec4 txl,ux,vx;"
                + "  nx=vTextureCoord[0];\n"
                + "  ny=vTextureCoord[1];\n"

                + "  y=texture2D(Ytex,vec2(nx,ny)).r;\n"
                + "  u=texture2D(Utex,vec2(nx,ny)).r;\n"
                + "  v=texture2D(Vtex,vec2(nx,ny)).r;\n"

                + "  y=1.1643*(y-0.0625);\n" 
                + "  u=u-0.5;\n"
                + "  v=v-0.5;\n"

                + "  r=y+1.5958*v;\n"
                + "  g=y-0.39173*u-0.81290*v;\n"
                + "  b=y+2.017*u;\n"

                // --> Bilateral blur filter code HERE <--

                + "  gl_FragColor=vec4(r,g,b,1.0);\n"
            + "}\n";



    ReentrantLock mFrameLock = new ReentrantLock();
    Frame mCurrentFrame;

    private int mProgram;
    private int mTextureWidth;
    private int mTextureHeight;
    private int mViewportWidth;
    private int mViewportHeight;

    public MyRenderer()
    {
        ByteBuffer bb = ByteBuffer.allocateDirect(mXYZCoords.length * 4);
        bb.order(ByteOrder.nativeOrder());
        mVertexBuffer = bb.asFloatBuffer();
        mVertexBuffer.put(mXYZCoords);
        mVertexBuffer.position(0);

        ByteBuffer tb = ByteBuffer.allocateDirect(mUVCoords.length * 4);
        tb.order(ByteOrder.nativeOrder());
        mTextureBuffer = tb.asFloatBuffer();
        mTextureBuffer.put(mUVCoords);
        mTextureBuffer.position(0);

        ByteBuffer dlb = ByteBuffer.allocateDirect(mVertexIndex.length * 2);
        dlb.order(ByteOrder.nativeOrder());
        mDrawListBuffer = dlb.asShortBuffer();
        mDrawListBuffer.put(mVertexIndex);
        mDrawListBuffer.position(0);
    }

    @Override public void onSurfaceCreated(GL10 gl, EGLConfig config)
    {
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        mProgram = GLES20.glCreateProgram(); // create empty OpenGL ES Program
        GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program
        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
        GLES20.glLinkProgram(mProgram);

        int positionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
        int textureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");

        GLES20.glVertexAttribPointer(positionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, COORDS_PER_VERTEX * 4, mVertexBuffer);
        GLES20.glEnableVertexAttribArray(positionHandle);
        GLES20.glVertexAttribPointer(textureHandle, TEXTURECOORDS_PER_VERTEX, GLES20.GL_FLOAT, false, TEXTURECOORDS_PER_VERTEX * 4, mTextureBuffer);
        GLES20.glEnableVertexAttribArray(textureHandle);
        GLES20.glUseProgram(mProgram);

        int i = GLES20.glGetUniformLocation(mProgram, "Ytex");                                     //            GLES20.glUniform3i(i, 0, 1, 2);
        GLES20.glUniform1i(i, 0); /* Bind Ytex to texture unit 0 */

        i = GLES20.glGetUniformLocation(mProgram, "Utex");
        GLES20.glUniform1i(i, 1); /* Bind Utex to texture unit 1 */

        i = GLES20.glGetUniformLocation(mProgram, "Vtex");
        GLES20.glUniform1i(i, 2); /* Bind Vtex to texture unit 2 */

        mTextureWidth = 0;
        mTextureHeight = 0;
    }

    static void initializeTexture(int name, int id, int width, int height)
    {
        GLES20.glActiveTexture(name);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, id);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE, width, height, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, null);
    }

    void setupTextures(Frame frame)
    {
        if (mTextureIds[0] != 0)
        {
            GLES20.glDeleteTextures(3, mTextureIds, 0);
        }

        GLES20.glGenTextures(3, mTextureIds, 0);

        int w = frame.getWidth();
        int h = frame.getHeight();
        int hw = (w + 1) >> 1;
        int hh = (h + 1) >> 1;

        initializeTexture(GLES20.GL_TEXTURE0, mTextureIds[0], w, h);
        initializeTexture(GLES20.GL_TEXTURE1, mTextureIds[1], hw, hh);
        initializeTexture(GLES20.GL_TEXTURE2, mTextureIds[2], hw, hh);

        mTextureWidth = frame.getWidth();
        mTextureHeight = frame.getHeight();
    }

    void updateTextures(Frame frame)
    {
        int width = frame.getWidth();
        int height = frame.getHeight();
        int half_width = (width + 1) >> 1;
        int half_height = (height + 1) >> 1;
        int y_size = width * height;
        int uv_size = half_width * half_height;

        ByteBuffer bb = frame.getBuffer();
        bb.clear();  // If we are reusing this frame, make sure we reset position and limit

        if (bb.remaining() == y_size + uv_size * 2)
        {
            bb.position(0);

            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
            GLES20.glPixelStorei(GLES20.GL_PACK_ALIGNMENT, 1);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[0]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, width, height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);

            bb.position(y_size);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[1]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, half_width, half_height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);

            bb.position(y_size + uv_size);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE2);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[2]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, half_width, half_height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);



            int i = GLES20.glGetUniformLocation(mProgram, "width");
            GLES20.glUniform1f(i, (float) mTextureWidth);

            i = GLES20.glGetUniformLocation(mProgram, "height");
            GLES20.glUniform1f(i, (float) mTextureHeight);
        }

        else
        {
            mTextureWidth = 0;
            mTextureHeight = 0;
        }
    }

    @Override public void onSurfaceChanged(GL10 gl, int width, int height)
    {
        GLES20.glViewport(0, 0, width, height);
        mViewportWidth = width;
        mViewportHeight = height;
    }

    @Override public void onDrawFrame(GL10 gl)
    {
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

        mFrameLock.lock();

        if (mCurrentFrame != null && !mVideoDisabled)
        {
            GLES20.glUseProgram(mProgram);

            if (mTextureWidth != mCurrentFrame.getWidth()    ||    mTextureHeight != mCurrentFrame.getHeight())
            {
                setupTextures(mCurrentFrame);
            }

            updateTextures(mCurrentFrame);

            Matrix.setIdentityM(mScaleMatrix, 0);
            float scaleX = 1.0f, scaleY = 1.0f;
            float ratio = (float) mCurrentFrame.getWidth() / mCurrentFrame.getHeight();
            float vratio = (float) mViewportWidth / mViewportHeight;

            if (mVideoFitEnabled)
            {
                if (ratio > vratio)
                {
                    scaleY = vratio / ratio;
                }

                else
                {
                    scaleX = ratio / vratio;
                }
            }

            else
            {
                if (ratio < vratio)
                {
                    scaleY = vratio / ratio;
                }

                else
                {
                    scaleX = ratio / vratio;
                }
            }

            Matrix.scaleM(mScaleMatrix, 0, scaleX * (mCurrentFrame.isMirroredX() ? -1.0f : 1.0f), scaleY, 1);

            int mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
            GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mScaleMatrix, 0);

            GLES20.glDrawElements(GLES20.GL_TRIANGLES, mVertexIndex.length, GLES20.GL_UNSIGNED_SHORT, mDrawListBuffer);
        }

        mFrameLock.unlock();
    }

    public void displayFrame(Frame frame)
    {
        mFrameLock.lock();
        if (this.mCurrentFrame != null)
        {
            this.mCurrentFrame.recycle();
        }

        this.mCurrentFrame = frame;
        mFrameLock.unlock();
    }

    public static int loadShader(int type, String shaderCode)
    {
        int shader = GLES20.glCreateShader(type);

        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);

        return shader;
    }

    public void disableVideo(boolean b)
    {
        mFrameLock.lock();

        mVideoDisabled = b;

        if (mVideoDisabled)
        {
            if (this.mCurrentFrame != null)
            {
                this.mCurrentFrame.recycle();
            }

            this.mCurrentFrame = null;
        }

        mFrameLock.unlock();
    }

    public void enableVideoFit(boolean enableVideoFit)
    {
        mVideoFitEnabled = enableVideoFit;
    }
}

最佳答案

感谢一位非常有才华的人帮助我，我终于弄明白了。这是我的渲染器类，它现在有一个带有 2 个渲染 channel 的 frameBuffer:

static class MyRenderer implements GLSurfaceView.Renderer
{
    int mTextureIds[] = new int[4];
    float[] mScaleMatrix = new float[16];
    float[] mFilterScaleMatrix = new float[16];

    private FloatBuffer mVertexBuffer;
    private FloatBuffer mTextureBuffer;
    private ShortBuffer mDrawListBuffer;

    private IntBuffer frameBuffer;

    boolean mVideoFitEnabled = true;
    boolean mVideoDisabled = false;

    // number of coordinates per vertex in this array
    static final int COORDS_PER_VERTEX = 3;
    static final int TEXTURECOORDS_PER_VERTEX = 2;

    static float mXYZCoords[] = {
            -1.0f, 1.0f, 0.0f, // top left
            -1.0f, -1.0f, 0.0f, // bottom left
            1.0f, -1.0f, 0.0f, // bottom right
            1.0f, 1.0f, 0.0f // top right
    };

    static float mUVCoords[] = {
            0, 0, // top left
            0, 1, // bottom left
            1, 1, // bottom right
            1, 0  // top right
    };

    private short mVertexIndex[] = {0, 1, 2, 0, 2, 3}; // order to draw vertices

    private final String vertexShaderCode =

              "uniform mat4 uMVPMatrix;"
            + "attribute vec4 aPosition;\n"
            + "attribute vec2 aTextureCoord;\n"
            + "varying vec2 vTextureCoord;\n"

            + "void main() {\n"
                + "  gl_Position = uMVPMatrix * aPosition;\n"
                + "  vTextureCoord = aTextureCoord;\n"
            + "}\n";


    private final String fragmentShaderCode =

              "YUV to RGB Conversion shader HERE";



    private final String frameBufferShader =

                "MY filter effect shader HERE";



    ReentrantLock mFrameLock = new ReentrantLock();
    Frame mCurrentFrame;

    private int mProgram;
    private int mProgramFilter;
    private int mTextureWidth;
    private int mTextureHeight;
    private int mViewportWidth;
    private int mViewportHeight;

    public MyRenderer()
    {
        ByteBuffer bb = ByteBuffer.allocateDirect(mXYZCoords.length * 4);
        bb.order(ByteOrder.nativeOrder());
        mVertexBuffer = bb.asFloatBuffer();
        mVertexBuffer.put(mXYZCoords);
        mVertexBuffer.position(0);

        ByteBuffer tb = ByteBuffer.allocateDirect(mUVCoords.length * 4);
        tb.order(ByteOrder.nativeOrder());
        mTextureBuffer = tb.asFloatBuffer();
        mTextureBuffer.put(mUVCoords);
        mTextureBuffer.position(0);

        ByteBuffer dlb = ByteBuffer.allocateDirect(mVertexIndex.length * 2);
        dlb.order(ByteOrder.nativeOrder());
        mDrawListBuffer = dlb.asShortBuffer();
        mDrawListBuffer.put(mVertexIndex);
        mDrawListBuffer.position(0);

        frameBuffer = IntBuffer.allocate(1);
    }

    @Override public void onSurfaceCreated(GL10 gl, EGLConfig config)
    {
        GLES20.glDisable(GLES20.GL_DEPTH_TEST);

        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);
        int filterVertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int filterFragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, frameBufferShader);


        mProgram = GLES20.glCreateProgram(); // create empty OpenGL ES Program
        GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program
        GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program
        GLES20.glLinkProgram(mProgram);

        mProgramFilter = GLES20.glCreateProgram(); // create empty OpenGL ES Program
        GLES20.glAttachShader(mProgramFilter, filterVertexShader); // add the vertex shader to program
        GLES20.glAttachShader(mProgramFilter, filterFragmentShader); // add the fragment shader to program
        GLES20.glLinkProgram(mProgramFilter);

        int positionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
        int textureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");

        GLES20.glVertexAttribPointer(positionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, COORDS_PER_VERTEX * 4, mVertexBuffer);
        GLES20.glEnableVertexAttribArray(positionHandle);
        GLES20.glVertexAttribPointer(textureHandle, TEXTURECOORDS_PER_VERTEX, GLES20.GL_FLOAT, false, TEXTURECOORDS_PER_VERTEX * 4, mTextureBuffer);
        GLES20.glEnableVertexAttribArray(textureHandle);

        GLES20.glUseProgram(mProgram);

        int i = GLES20.glGetUniformLocation(mProgram, "Ytex");
        GLES20.glUniform1i(i, 3); /* Bind Ytex to texture unit 0 */

        i = GLES20.glGetUniformLocation(mProgram, "Utex");
        GLES20.glUniform1i(i, 1); /* Bind Utex to texture unit 1 */

        i = GLES20.glGetUniformLocation(mProgram, "Vtex");
        GLES20.glUniform1i(i, 2); /* Bind Vtex to texture unit 2 */


        GLES20.glUseProgram(mProgramFilter);
        i = GLES20.glGetUniformLocation(mProgramFilter, "Ytex");
        GLES20.glUniform1i(i, 0);

        mTextureWidth = 0;
        mTextureHeight = 0;
    }

    static void initializeTexture(int name, int id, int width, int height)
    {
        GLES20.glActiveTexture(name);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, id);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_LUMINANCE, width, height, 0, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, null);
    }

    void setupTextures(Frame frame)
    {
        if (mTextureIds[0] != 0)
        {
            GLES20.glDeleteTextures(4, mTextureIds, 0);
        }

        GLES20.glGenTextures(4, mTextureIds, 0);

        int w = frame.getWidth();
        int h = frame.getHeight();
        int hw = (w + 1) >> 1;
        int hh = (h + 1) >> 1;

        initializeTexture(GLES20.GL_TEXTURE0, mTextureIds[0], w, h);
        initializeTexture(GLES20.GL_TEXTURE1, mTextureIds[1], hw, hh);
        initializeTexture(GLES20.GL_TEXTURE2, mTextureIds[2], hw, hh);

        GLES20.glGenFramebuffers(1, frameBuffer);
        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, frameBuffer.get(0));

        GLES20.glActiveTexture(GLES20.GL_TEXTURE3);
        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[3]);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
        GLES20.glTexImage2D(GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, w, h, 0, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null);
        GLES20.glFramebufferTexture2D(GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0, GLES20.GL_TEXTURE_2D, mTextureIds[3], 0);

        GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

        mTextureWidth = frame.getWidth();
        mTextureHeight = frame.getHeight();



        GLES20.glUseProgram(mProgramFilter);

        int i = GLES20.glGetUniformLocation(mProgramFilter, "width");
        GLES20.glUniform1f(i, (float) mTextureWidth);

        i = GLES20.glGetUniformLocation(mProgramFilter, "height");
        GLES20.glUniform1f(i, (float) mTextureHeight);
    }

    void updateTextures(Frame frame)
    {
        int width = frame.getWidth();
        int height = frame.getHeight();
        int half_width = (width + 1) >> 1;
        int half_height = (height + 1) >> 1;
        int y_size = width * height;
        int uv_size = half_width * half_height;

        ByteBuffer bb = frame.getBuffer();
        bb.clear();  // If we are reusing this frame, make sure we reset position and limit

        if (bb.remaining() == y_size + uv_size * 2)
        {
            bb.position(0);

            GLES20.glPixelStorei(GLES20.GL_UNPACK_ALIGNMENT, 1);
            GLES20.glPixelStorei(GLES20.GL_PACK_ALIGNMENT, 1);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[0]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, width, height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);

            bb.position(y_size);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE1);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[1]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, half_width, half_height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);

            bb.position(y_size + uv_size);

            GLES20.glActiveTexture(GLES20.GL_TEXTURE2);
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureIds[2]);
            GLES20.glTexSubImage2D(GLES20.GL_TEXTURE_2D, 0, 0, 0, half_width, half_height, GLES20.GL_LUMINANCE, GLES20.GL_UNSIGNED_BYTE, bb);
        }

        else
        {
            mTextureWidth = 0;
            mTextureHeight = 0;
        }
    }

    @Override public void onSurfaceChanged(GL10 gl, int width, int height)
    {
        /// GLES20.glViewport(0, 0, width, height);
        mViewportWidth = width;
        mViewportHeight = height;
    }

    @Override public void onDrawFrame(GL10 gl)
    {
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);

        mFrameLock.lock();

        if (mCurrentFrame != null && !mVideoDisabled)
        {
            if (mTextureWidth != mCurrentFrame.getWidth()    ||    mTextureHeight != mCurrentFrame.getHeight())
            {
                setupTextures(mCurrentFrame);
            }

            updateTextures(mCurrentFrame);


            /// Step 1: Smoothing Filter - Render to FrameBuffer [pass 1]
            Matrix.setIdentityM(mFilterScaleMatrix, 0);
            GLES20.glViewport(0, 0, mTextureWidth, mTextureHeight);

            GLES20.glUseProgram(mProgramFilter);

            int mMVPFilterMatrixHandle = GLES20.glGetUniformLocation(mProgramFilter, "uMVPMatrix");
            GLES20.glUniformMatrix4fv(mMVPFilterMatrixHandle, 1, false, mFilterScaleMatrix, 0);

            GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, frameBuffer.get(0));

            GLES20.glDrawElements(GLES20.GL_TRIANGLES, mVertexIndex.length, GLES20.GL_UNSIGNED_SHORT, mDrawListBuffer);



            /// Step 2: Draw + RGB Conversion - Render to screen [pass 2]
            Matrix.setIdentityM(mScaleMatrix, 0);

            float scaleX = 1.0f, scaleY = 1.0f;
            float ratio = (float) mCurrentFrame.getWidth() / mCurrentFrame.getHeight();
            float vratio = (float) mViewportWidth / mViewportHeight;

            if (mVideoFitEnabled)
            {
                if (ratio > vratio)
                {
                    scaleY = vratio / ratio;
                }

                else
                {
                    scaleX = ratio / vratio;
                }
            }

            else
            {
                if (ratio < vratio)
                {
                    scaleY = vratio / ratio;
                }

                else
                {
                    scaleX = ratio / vratio;
                }
            }

            Matrix.scaleM(mScaleMatrix, 0, scaleX * (mCurrentFrame.isMirroredX() ? -1.0f : 1.0f), scaleY, 1);

            GLES20.glUseProgram(mProgram);

            GLES20.glViewport(0, 0, mViewportWidth, mViewportHeight);

            GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);

            int mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
            GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mScaleMatrix, 0);

            GLES20.glDrawElements(GLES20.GL_TRIANGLES, mVertexIndex.length, GLES20.GL_UNSIGNED_SHORT, mDrawListBuffer);
        }

        mFrameLock.unlock();
    }

    public void displayFrame(Frame frame)
    {
        mFrameLock.lock();
        if (this.mCurrentFrame != null)
        {
            this.mCurrentFrame.recycle();
        }

        this.mCurrentFrame = frame;
        mFrameLock.unlock();
    }

    public static int loadShader(int type, String shaderCode)
    {
        int shader = GLES20.glCreateShader(type);

        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);

        return shader;
    }

    public void disableVideo(boolean b)
    {
        mFrameLock.lock();

        mVideoDisabled = b;

        if (mVideoDisabled)
        {
            if (this.mCurrentFrame != null)
            {
                this.mCurrentFrame.recycle();
            }

            this.mCurrentFrame = null;
        }

        mFrameLock.unlock();
    }

    public void enableVideoFit(boolean enableVideoFit)
    {
        mVideoFitEnabled = enableVideoFit;
    }
}

关于Android OpenGL 以原始(小)分辨率渲染到 frameBuffer，然后将其缩放(viewPort)到屏幕尺寸，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/37163166/

文章推荐： c++ - 如何实现 array::max_size()？

文章推荐： Linux 使用 'nested' 字段排序

文章推荐： c++ - gcc 堆栈优化

Javafx获取作为媒体加载的视频的宽度和高度(分辨率)
我正在使用 JavaFX 开发视频播放器。我正在将视频从本地文件系统加载到 JavaFX 类媒体中。然后我想获取宽度和高度，以便我可以将场景的尺寸设置为该大小: Media media = new M
python - 减小已保存视频的大小/分辨率
我是OpenCV的新手，正在尝试解决这个问题。我有一个.mp4文件保存在从网络摄像头流式传输的磁盘上。现在，我需要制作视频的低分辨率版本，以上传到Web服务器(这个想法是，低分辨率预览实时或多或少地上
java - 如何提高jfree图表的质量(分辨率)
我在我的应用程序中使用 jfree 图表(折线图)...创建时我的图表看起来很模糊...我怎样才能获得高清晰度图像。我使用过:ChartUtilities.writeScaledChartAsPNG
Java BufferedImage 分辨率
我正在用 Java 编写一个工具来处理我网站上上传的文件。我想以特定的方式管理图像:如果尺寸大于限制，我想首先调整图像的尺寸，然后再次检查尺寸。当然，我不想做无用的工作，所以我想在调整图像大小之前估计
c# - 如何在多显示器设置中获取所有显示器的尺寸(分辨率)
是否有一种纯 WPF 方法来获取有关所有可用显示器大小(分辨率)的信息。我知道我可以使用 Screen.AllScreens 来获取它们，但在我的遗留项目中我无法添加新的引用(内置 WPF 程序集除外
android - android中的按钮和背景大小/分辨率
看了Developer文档，部分理解了LDPI,HDPI,MDPI,XHDPI类比，网上到处找也没有找到具体答案。我有两部手机，一部是小屏幕，一部是平板电脑。我希望我的小屏幕手机上的按钮看起来很小，
css - 基于网页布局的图像大小/分辨率
对于下面给定的网页， xyz {% load staticfiles %} html, body {
Java:JFrame 分辨率？
我在 Mac 上使用多个 JFrames 制作了一个程序，分辨率还可以，一切都适合屏幕。但是，当我在我的 PC 上运行该程序时，JFrames 太大并且会立即离开屏幕。我的问题是:是否可以在 JFr
c++ - 如何获得每个显示器的尺寸(分辨率)？
我需要有关如何检索屏幕分辨率的帮助，如下图所示。我找到了 this documentation这真的很有帮助。这是我根据这些文档尝试的代码: int numberOfScreens = GetSys
resolution - Kindle:更改屏幕边界/分辨率
有什么方法可以更改分辨率或为亚马逊 Kindle 键盘上的屏幕设置不同的边界？我的屏幕有一部分出现裂纹，我想解决这个问题。我试过在文件系统中乱搞(通过 WiFi 连接)，但我的所有属性更改都没有任何
libgdx 分辨率/密度缩放 Assets
快速提问，我正在开发 libgdx 中的游戏，但遇到了问题。我正在尝试扩展我的 Assets ，我正在使用 Gdx.graphics.getDensity() 来获取密度，然后使用它作为乘数来设置我
iphone - 我应该使用什么尺寸的图像才能支持两种 iPhone 分辨率？
我有一些关于屏幕分辨率的问题，我不清楚。这些问题假设我的应用程序将在 iOS 4.0 及更高版本以及 iPhone 3GS 或 iPhone 4 上运行。启动图像 (default.png) 的大小
Ipad 上的 Iphone 分辨率
我们有一个应用程序在审核过程中被 Apple 应用程序审核人员拒绝。拒绝的原因是应用程序在 Ipad 上运行时无法正确缩放。该应用程序本来就不是要在 Ipad 上运行的，但与他们争论这一点似乎没有意
delphi - 无需解码图像即可获取 JPEG 分辨率
我试图在不解码文件的情况下获取 JPEG 图像的分辨率。我从互联网上获得了几个样本，但没有一个可以正常工作。似乎是这样，因为许多 JPEG 文件不是标准的，尽管任何图形应用程序(Irfan、PSP、F
image - C#EmguCV调整Mat大小但保持边界/分辨率
我尝试了很多事情，但是所有尝试都失败了。我需要将灰度图像(2560x1440)调整为更低或更高的分辨率，然后我需要将边界设置为原始大小(2560x1440)，但将调整后的图像保持在中心。我使用的是
java - 如何绘制比设备分辨率更大的 GLSurfaceView 分辨率？
我正在使用 GLSulfaceView 开发一个静音相机应用程序，该应用程序从预览中捕获图片。为了捕捉图片，我使用 GLES20.glReadPixels(0, 0, surfaceWidth, s
npm 相当于 yarn 分辨率？
是否有相当于 yarn resolutions 的 npm功能？ npm package.json docs 中没有提及它. 例如，我想在 3.3.2 上安装 lerna@3.3.2 及其依赖项之一
java - 将视频缩放至 24x15 分辨率
我制作了一个在 Arduino 上运行的 24x15 LED 显示屏，去年我在内存中放入了 32KB 的图形例程，这很酷。但现在我已经升级到 Arduino Mega，具有 256KB 内存，并且有
c - 网络接收定时器以 ms 分辨率
我的场景是，我正在收集网络数据包，如果数据包与网络过滤器匹配，我想记录连续数据包之间的时间差，最后一部分是不起作用的部分。我的问题是，无论我使用什么 C 定时器函数，我都无法获得准确的亚秒级测量。我尝
使用 C 中的结构和指针更改图像大小/分辨率
我们一直在学校布置一项任务，需要更改图像(反转颜色、切换颜色、旋转 90 度、双倍大小、放大图像)，现在我正在尝试通过将分辨率加倍来使其大小加倍，但无法弄清楚如何访问该地址并更改它。我们得到了两个函数

塔克拉玛干

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

Android OpenGL 以原始(小)分辨率渲染到 frameBuffer，然后将其缩放(viewPort)到屏幕尺寸