xref: /frameworks/av/cmds/screenrecord/Program.cpp

/*
 * Copyright 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "ScreenRecord"
//#define LOG_NDEBUG 0
#include <utils/Log.h>

#include "Program.h"

#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>

#include <assert.h>

using namespace android;

// 4x4 identity matrix
const float Program::kIdentity[] = {
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
};

// Simple vertex shader.  Texture coord calc includes matrix for GLConsumer
// transform.
static const char* kVertexShader =
        "uniform mat4 uMVPMatrix;\n"
        "uniform mat4 uGLCMatrix;\n"
        "attribute vec4 aPosition;\n"
        "attribute vec4 aTextureCoord;\n"
        "varying vec2 vTextureCoord;\n"
        "void main() {\n"
        "    gl_Position = uMVPMatrix * aPosition;\n"
        "    vTextureCoord = (uGLCMatrix * aTextureCoord).xy;\n"
        "}\n";

// Trivial fragment shader for external texture.
static const char* kExtFragmentShader =
        "#extension GL_OES_EGL_image_external : require\n"
        "precision mediump float;\n"
        "varying vec2 vTextureCoord;\n"
        "uniform samplerExternalOES uTexture;\n"
        "void main() {\n"
        "    gl_FragColor = texture2D(uTexture, vTextureCoord);\n"
        "}\n";

// Trivial fragment shader for mundane texture.
static const char* kFragmentShader =
        "precision mediump float;\n"
        "varying vec2 vTextureCoord;\n"
        "uniform sampler2D uTexture;\n"
        "void main() {\n"
        "    gl_FragColor = texture2D(uTexture, vTextureCoord);\n"
        //"    gl_FragColor = vec4(0.2, 1.0, 0.2, 1.0);\n"
        "}\n";

status_t Program::setup(ProgramType type) {
    ALOGV("Program::setup type=%d", type);
    status_t err;

    mProgramType = type;

    GLuint program;
    if (type == PROGRAM_TEXTURE_2D) {
        err = createProgram(&program, kVertexShader, kFragmentShader);
    } else {
        err = createProgram(&program, kVertexShader, kExtFragmentShader);
    }
    if (err != NO_ERROR) {
        return err;
    }
    assert(program != 0);

    maPositionLoc = glGetAttribLocation(program, "aPosition");
    maTextureCoordLoc = glGetAttribLocation(program, "aTextureCoord");
    muMVPMatrixLoc = glGetUniformLocation(program, "uMVPMatrix");
    muGLCMatrixLoc = glGetUniformLocation(program, "uGLCMatrix");
    muTextureLoc = glGetUniformLocation(program, "uTexture");
    if ((maPositionLoc | maTextureCoordLoc | muMVPMatrixLoc |
            muGLCMatrixLoc | muTextureLoc) == -1) {
        ALOGE("Attrib/uniform lookup failed: %#x", glGetError());
        glDeleteProgram(program);
        return UNKNOWN_ERROR;
    }

    mProgram = program;
    return NO_ERROR;
}

void Program::release() {
    ALOGV("Program::release");
    if (mProgram != 0) {
        glDeleteProgram(mProgram);
        mProgram = 0;
    }
}

status_t Program::createProgram(GLuint* outPgm, const char* vertexShader,
        const char* fragmentShader) {
    GLuint vs, fs;
    status_t err;

    err = compileShader(GL_VERTEX_SHADER, vertexShader, &vs);
    if (err != NO_ERROR) {
        return err;
    }
    err = compileShader(GL_FRAGMENT_SHADER, fragmentShader, &fs);
    if (err != NO_ERROR) {
        glDeleteShader(vs);
        return err;
    }

    GLuint program;
    err = linkShaderProgram(vs, fs, &program);
    glDeleteShader(vs);
    glDeleteShader(fs);
    if (err == NO_ERROR) {
        *outPgm = program;
    }
    return err;
}

status_t Program::compileShader(GLenum shaderType, const char* src,
        GLuint* outShader) {
    GLuint shader = glCreateShader(shaderType);
    if (shader == 0) {
        ALOGE("glCreateShader error: %#x", glGetError());
        return UNKNOWN_ERROR;
    }

    glShaderSource(shader, 1, &src, NULL);
    glCompileShader(shader);

    GLint compiled = 0;
    glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
    if (!compiled) {
        ALOGE("Compile of shader type %d failed", shaderType);
        GLint infoLen = 0;
        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen) {
            char* buf = new char[infoLen];
            if (buf) {
                glGetShaderInfoLog(shader, infoLen, NULL, buf);
                ALOGE("Compile log: %s", buf);
                delete[] buf;
            }
        }
        glDeleteShader(shader);
        return UNKNOWN_ERROR;
    }
    *outShader = shader;
    return NO_ERROR;
}

status_t Program::linkShaderProgram(GLuint vs, GLuint fs, GLuint* outPgm) {
    GLuint program = glCreateProgram();
    if (program == 0) {
        ALOGE("glCreateProgram error: %#x", glGetError());
        return UNKNOWN_ERROR;
    }

    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    GLint linkStatus = GL_FALSE;
    glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
    if (linkStatus != GL_TRUE) {
        ALOGE("glLinkProgram failed");
        GLint bufLength = 0;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
        if (bufLength) {
            char* buf = new char[bufLength];
            if (buf) {
                glGetProgramInfoLog(program, bufLength, NULL, buf);
                ALOGE("Link log: %s", buf);
                delete[] buf;
            }
        }
        glDeleteProgram(program);
        return UNKNOWN_ERROR;
    }

    *outPgm = program;
    return NO_ERROR;
}



status_t Program::blit(GLuint texName, const float* texMatrix,
        int32_t x, int32_t y, int32_t w, int32_t h, bool invert) const {
    ALOGV("Program::blit %d xy=%d,%d wh=%d,%d", texName, x, y, w, h);

    const float pos[] = {
        float(x),   float(y+h),
        float(x+w), float(y+h),
        float(x),   float(y),
        float(x+w), float(y),
    };
    const float uv[] = {
        0.0f, 0.0f,
        1.0f, 0.0f,
        0.0f, 1.0f,
        1.0f, 1.0f,
    };
    status_t err;

    err = beforeDraw(texName, texMatrix, pos, uv, invert);
    if (err == NO_ERROR) {
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
        err = afterDraw();
    }
    return err;
}

status_t Program::drawTriangles(GLuint texName, const float* texMatrix,
        const float* vertices, const float* texes, size_t count) const {
    ALOGV("Program::drawTriangles texName=%d", texName);

    status_t err;

    err = beforeDraw(texName, texMatrix, vertices, texes, false);
    if (err == NO_ERROR) {
        glDrawArrays(GL_TRIANGLES, 0, count);
        err = afterDraw();
    }
    return err;
}

status_t Program::beforeDraw(GLuint texName, const float* texMatrix,
        const float* vertices, const float* texes, bool invert) const {
    // Create an orthographic projection matrix based on viewport size.
    GLint vp[4];
    glGetIntegerv(GL_VIEWPORT, vp);
    float screenToNdc[16] = {
        2.0f/float(vp[2]),  0.0f,               0.0f,   0.0f,
        0.0f,               -2.0f/float(vp[3]), 0.0f,   0.0f,
        0.0f,               0.0f,               1.0f,   0.0f,
        -1.0f,              1.0f,               0.0f,   1.0f,
    };
    if (invert) {
        screenToNdc[5] = -screenToNdc[5];
        screenToNdc[13] = -screenToNdc[13];
    }

    glUseProgram(mProgram);

    glVertexAttribPointer(maPositionLoc, 2, GL_FLOAT, GL_FALSE, 0, vertices);
    glVertexAttribPointer(maTextureCoordLoc, 2, GL_FLOAT, GL_FALSE, 0, texes);
    glEnableVertexAttribArray(maPositionLoc);
    glEnableVertexAttribArray(maTextureCoordLoc);

    glUniformMatrix4fv(muMVPMatrixLoc, 1, GL_FALSE, screenToNdc);
    glUniformMatrix4fv(muGLCMatrixLoc, 1, GL_FALSE, texMatrix);

    glActiveTexture(GL_TEXTURE0);

    switch (mProgramType) {
    case PROGRAM_EXTERNAL_TEXTURE:
        glBindTexture(GL_TEXTURE_EXTERNAL_OES, texName);
        break;
    case PROGRAM_TEXTURE_2D:
        glBindTexture(GL_TEXTURE_2D, texName);
        break;
    default:
        ALOGE("unexpected program type %d", mProgramType);
        return UNKNOWN_ERROR;
    }

    glUniform1i(muTextureLoc, 0);

    GLenum glErr;
    if ((glErr = glGetError()) != GL_NO_ERROR) {
        ALOGE("GL error before draw: %#x", glErr);
        glDisableVertexAttribArray(maPositionLoc);
        glDisableVertexAttribArray(maTextureCoordLoc);
        return UNKNOWN_ERROR;
    }

    return NO_ERROR;
}

status_t Program::afterDraw() const {
    glDisableVertexAttribArray(maPositionLoc);
    glDisableVertexAttribArray(maTextureCoordLoc);

    GLenum glErr;
    if ((glErr = glGetError()) != GL_NO_ERROR) {
        ALOGE("GL error after draw: %#x", glErr);
        return UNKNOWN_ERROR;
    }

    return NO_ERROR;
}