/*
* Copyright (C) 2015 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.
*/

#include "TextureResize.h"

#include <stdio.h>
#include <string.h>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include <GLES2/gl2ext.h>

#include "OpenGLESDispatch/DispatchTables.h"
#include "aemu/base/synchronization/Lock.h"
#include "host-common/logging.h"
#include "host-common/misc.h"
#include "host-common/opengl/misc.h"

namespace gfxstream {
namespace gl {

// #define V(...)  VERBOSE_PRINT(gles,__VA_ARGS__)
#define V(...)
#define MAX_FACTOR_POWER 4

static const char kCommonShaderSource[] =
    "precision mediump float;\n"
    "varying vec2 vUV00, vUV01;\n"
    "#if FACTOR > 2\n"
    "varying vec2 vUV02, vUV03;\n"
    "#if FACTOR > 4\n"
    "varying vec2 vUV04, vUV05, vUV06, vUV07;\n"
    "#if FACTOR > 8\n"
    "varying vec2 vUV08, vUV09, vUV10, vUV11, vUV12, vUV13, vUV14, vUV15;\n"
    "#endif\n"
    "#endif\n"
    "#endif\n";

static const char kVertexShaderSource[] =
    "attribute vec2 aPosition;\n"

    "void main() {\n"
    "  gl_Position = vec4(aPosition, 0, 1);\n"
    "  vec2 uv = ((aPosition + 1.0) / 2.0) + 0.5 / kDimension;\n"
    "  vUV00 = uv;\n"
    "  #ifdef HORIZONTAL\n"
    "  vUV01 = uv + vec2( 1.0 / kDimension.x, 0);\n"
    "  #if FACTOR > 2\n"
    "  vUV02 = uv + vec2( 2.0 / kDimension.x, 0);\n"
    "  vUV03 = uv + vec2( 3.0 / kDimension.x, 0);\n"
    "  #if FACTOR > 4\n"
    "  vUV04 = uv + vec2( 4.0 / kDimension.x, 0);\n"
    "  vUV05 = uv + vec2( 5.0 / kDimension.x, 0);\n"
    "  vUV06 = uv + vec2( 6.0 / kDimension.x, 0);\n"
    "  vUV07 = uv + vec2( 7.0 / kDimension.x, 0);\n"
    "  #if FACTOR > 8\n"
    "  vUV08 = uv + vec2( 8.0 / kDimension.x, 0);\n"
    "  vUV09 = uv + vec2( 9.0 / kDimension.x, 0);\n"
    "  vUV10 = uv + vec2(10.0 / kDimension.x, 0);\n"
    "  vUV11 = uv + vec2(11.0 / kDimension.x, 0);\n"
    "  vUV12 = uv + vec2(12.0 / kDimension.x, 0);\n"
    "  vUV13 = uv + vec2(13.0 / kDimension.x, 0);\n"
    "  vUV14 = uv + vec2(14.0 / kDimension.x, 0);\n"
    "  vUV15 = uv + vec2(15.0 / kDimension.x, 0);\n"
    "  #endif\n"  // FACTOR > 8
    "  #endif\n"  // FACTOR > 4
    "  #endif\n"  // FACTOR > 2

    "  #else\n"
    "  vUV01 = uv + vec2(0,  1.0 / kDimension.y);\n"
    "  #if FACTOR > 2\n"
    "  vUV02 = uv + vec2(0,  2.0 / kDimension.y);\n"
    "  vUV03 = uv + vec2(0,  3.0 / kDimension.y);\n"
    "  #if FACTOR > 4\n"
    "  vUV04 = uv + vec2(0,  4.0 / kDimension.y);\n"
    "  vUV05 = uv + vec2(0,  5.0 / kDimension.y);\n"
    "  vUV06 = uv + vec2(0,  6.0 / kDimension.y);\n"
    "  vUV07 = uv + vec2(0,  7.0 / kDimension.y);\n"
    "  #if FACTOR > 8\n"
    "  vUV08 = uv + vec2(0,  8.0 / kDimension.y);\n"
    "  vUV09 = uv + vec2(0,  9.0 / kDimension.y);\n"
    "  vUV10 = uv + vec2(0, 10.0 / kDimension.y);\n"
    "  vUV11 = uv + vec2(0, 11.0 / kDimension.y);\n"
    "  vUV12 = uv + vec2(0, 12.0 / kDimension.y);\n"
    "  vUV13 = uv + vec2(0, 13.0 / kDimension.y);\n"
    "  vUV14 = uv + vec2(0, 14.0 / kDimension.y);\n"
    "  vUV15 = uv + vec2(0, 15.0 / kDimension.y);\n"
    "  #endif\n"  // FACTOR > 8
    "  #endif\n"  // FACTOR > 4
    "  #endif\n"  // FACTOR > 2
    "  #endif\n"  // HORIZONTAL/VERTICAL
    "}\n";

const char kFragmentShaderSource[] =
    "uniform sampler2D uTexture;\n"

    "vec3 read(vec2 uv) {\n"
    "  vec3 r = texture2D(uTexture, uv).rgb;\n"
    "  #ifdef HORIZONTAL\n"
    "  r.rgb = pow(r.rgb, vec3(2.2));\n"
    "  #endif\n"
    "  return r;\n"
    "}\n"

    "void main() {\n"
    "  vec3 sum = read(vUV00) + read(vUV01);\n"
    "  #if FACTOR > 2\n"
    "  sum += read(vUV02) + read(vUV03);\n"
    "  #if FACTOR > 4\n"
    "  sum += read(vUV04) + read(vUV05) + read(vUV06) + read(vUV07);\n"
    "  #if FACTOR > 8\n"
    "  sum += read(vUV08) + read(vUV09) + read(vUV10) + read(vUV11) +"
    "      read(vUV12) + read(vUV13) + read(vUV14) + read(vUV15);\n"
    "  #endif\n"
    "  #endif\n"
    "  #endif\n"
    "  sum /= float(FACTOR);\n"
    "  #ifdef VERTICAL\n"
    "  sum.rgb = pow(sum.rgb, vec3(1.0 / 2.2));\n"
    "  #endif\n"
    "  gl_FragColor = vec4(sum.rgb, 1.0);\n"
    "}\n";

// Vertex shader for anti-aliasing - doesn't do anything special.
const char kGenericVertexShaderSource[] = R"(
    attribute vec2 position;
    attribute vec2 inCoord;
    varying vec2 outCoord;
    void main(void) {
        gl_Position = vec4(position.x, position.y, 0.0, 1.0);
        outCoord = inCoord;
    })";

// Fragment shader
const char kGenericFragmentShaderSource[] = R"(
    precision mediump float;
    uniform sampler2D texSampler;
    varying vec2 outCoord;
    void main(void) {
        gl_FragColor = texture2D(texSampler, outCoord);
    }
)";

static const float kVertexData[] = {-1, -1, 3, -1, -1, 3};
static android::base::Lock s_postContextResources;
static std::vector<GLuint> s_programsToRelease;
static std::vector<GLuint> s_framebuffersToRelease;

static GLuint createShader(GLenum type, std::initializer_list<const char*> source) {
    GLint success, infoLength;

    GLuint shader = s_gles2.glCreateShader(type);
    if (shader) {
        s_gles2.glShaderSource(shader, source.size(), source.begin(), nullptr);
        s_gles2.glCompileShader(shader);
        s_gles2.glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
        if (success == GL_FALSE) {
            s_gles2.glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLength);
            std::string infoLog(infoLength + 1, '\0');
            s_gles2.glGetShaderInfoLog(shader, infoLength, nullptr, &infoLog[0]);
            ERR("%s shader compile failed:\n%s\n",
                    (type == GL_VERTEX_SHADER) ? "Vertex" : "Fragment",
                    infoLog.c_str());
            s_gles2.glDeleteShader(shader);
            shader = 0;
        }
    }
    return shader;
}

static void attachShaders(TextureResize::Framebuffer* fb, const char* factorDefine,
        const char* dimensionDefine, GLuint width, GLuint height) {

    std::ostringstream dimensionConst;
    dimensionConst << "const vec2 kDimension = vec2(" << width << ", " << height << ");\n";

    GLuint vShader = createShader(GL_VERTEX_SHADER, {
            factorDefine, dimensionDefine,
            kCommonShaderSource, dimensionConst.str().c_str(), kVertexShaderSource
    });
    GLuint fShader = createShader(GL_FRAGMENT_SHADER, {
        factorDefine, dimensionDefine, kCommonShaderSource, kFragmentShaderSource
    });

    if (!vShader || !fShader) {
        return;
    }
    if (!fb->program) {
        fb->program = s_gles2.glCreateProgram();
    }
    s_gles2.glAttachShader(fb->program, vShader);
    s_gles2.glAttachShader(fb->program, fShader);
    s_gles2.glLinkProgram(fb->program);
    s_gles2.glDeleteShader(vShader);
    s_gles2.glDeleteShader(fShader);

    fb->aPosition = s_gles2.glGetAttribLocation(fb->program, "aPosition");
    fb->uTexture = s_gles2.glGetUniformLocation(fb->program, "uTexture");
}

TextureResize::TextureResize(GLuint width, GLuint height) :
        mWidth(width),
        mHeight(height),
        mFactor(1),
        mFBWidth({0,}),
        mFBHeight({0,}),
        // Use unsigned byte as the default since it has the most support
        // and is the input/output format in the end
        // (TODO) until HDR is common on both guest and host, and we'll
        // cross that bridge when we get there.
        mTextureDataType(GL_UNSIGNED_BYTE) {

    // Fix color banding by trying to use a texture type with a high precision.
    const char* exts = (const char*)s_gles2.glGetString(GL_EXTENSIONS);

    bool hasColorBufferFloat =
        emugl::getRenderer() == SELECTED_RENDERER_HOST ||
        emugl::hasExtension(exts, "GL_EXT_color_buffer_float");
    bool hasColorBufferHalfFloat =
        emugl::hasExtension(exts, "GL_EXT_color_buffer_half_float");
    bool hasTextureFloat =
        emugl::hasExtension(exts, "GL_OES_texture_float");
    bool hasTextureHalfFloat =
        emugl::hasExtension(exts, "GL_OES_texture_half_float");
    bool hasTextureFloatLinear =
        emugl::hasExtension(exts, "GL_OES_texture_float_linear");

    if (hasColorBufferFloat && hasTextureFloat) {
        mTextureDataType = GL_FLOAT;
    } else if (hasColorBufferHalfFloat && hasTextureHalfFloat) {
        mTextureDataType = GL_HALF_FLOAT_OES;
    }

    if (hasTextureFloat || hasTextureHalfFloat) {
        mTextureFilteringMode =
            hasTextureFloatLinear ? GL_LINEAR : GL_NEAREST;
    }

    s_gles2.glGenTextures(1, &mFBWidth.texture);
    s_gles2.glBindTexture(GL_TEXTURE_2D, mFBWidth.texture);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    s_gles2.glGenTextures(1, &mFBHeight.texture);
    s_gles2.glBindTexture(GL_TEXTURE_2D, mFBHeight.texture);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mTextureFilteringMode);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, mTextureFilteringMode);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    s_gles2.glGenBuffers(1, &mVertexBuffer);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
    s_gles2.glBufferData(GL_ARRAY_BUFFER, sizeof(kVertexData), kVertexData, GL_STATIC_DRAW);

    // Clear bindings.
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, 0);
}

TextureResize::~TextureResize() {
    GLuint tex[2] = {mFBWidth.texture, mFBHeight.texture};
    s_gles2.glDeleteTextures(2, tex);
    s_gles2.glDeleteBuffers(1, &mVertexBuffer);
    // b/242245912
    // There seems to be a mesa bug that we have to delete the
    // program in the post thread.
    android::base::AutoLock lock(s_postContextResources);
    s_programsToRelease.push_back(mFBWidth.program);
    s_programsToRelease.push_back(mFBHeight.program);
    // b/285421327
    // We should create, use and destroy framebuffers in the same context.
    // Framebuffer ownership is driver-dependent.
    s_framebuffersToRelease.push_back(mFBWidth.framebuffer);
    s_framebuffersToRelease.push_back(mFBHeight.framebuffer);
}

GLuint TextureResize::update(GLuint texture) {
    // Store the viewport. The viewport is clobbered due to the framebuffers.
    GLint vport[4] = { 0, };
    s_gles2.glGetIntegerv(GL_VIEWPORT, vport);
    GLint prevFbo = 0;
    s_gles2.glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &prevFbo);
    // Correctly deal with rotated screens.
    GLint tWidth = vport[2], tHeight = vport[3];
    if ((mWidth < mHeight) != (tWidth < tHeight)) {
        std::swap(tWidth, tHeight);
    }

    // Compute the scaling factor needed to get an image just larger than the target viewport.
    unsigned int factor = 1;
    for (int i = 0, w = mWidth / 2, h = mHeight / 2;
        i < MAX_FACTOR_POWER && w >= tWidth && h >= tHeight;
        i++, w /= 2, h /= 2, factor *= 2) {
    }

    // No resizing needed if factor == 1
    if (factor == 1) {
        return texture;
    }

    s_gles2.glGetError(); // Clear any GL errors.
    setupFramebuffers(factor);
    resize(texture);
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, prevFbo);
    s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]); // Restore the viewport.
    // If there was an error while resizing, just use the unscaled texture.
    GLenum error = s_gles2.glGetError();
    if (error != GL_NO_ERROR) {
        V("GL error while resizing: 0x%x (ignored)\n", error);
        return texture;
    }

    return mFBHeight.texture;
}

GLuint TextureResize::update(GLuint texture, int width, int height, int rotation) {
    if (mGenericResizer.get() == nullptr) {
        mGenericResizer.reset(new TextureResize::GenericResizer());
    }
    return mGenericResizer->draw(texture, width, height, rotation);
}

void TextureResize::setupFramebuffers(unsigned int factor) {
    if (factor == mFactor) {
        // The factor hasn't changed, no need to update the framebuffers.
        return;
    }

    // Update the framebuffer sizes to match the new factor.
    s_gles2.glBindTexture(GL_TEXTURE_2D, mFBWidth.texture);
    s_gles2.glTexImage2D(
        GL_TEXTURE_2D, 0, GL_RGB, mWidth / factor, mHeight, 0, GL_RGB,
                mTextureDataType, nullptr);
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);

    s_gles2.glBindTexture(GL_TEXTURE_2D, mFBHeight.texture);
    s_gles2.glTexImage2D(
        GL_TEXTURE_2D, 0, GL_RGB, mWidth / factor, mHeight / factor, 0, GL_RGB,
                mTextureDataType, nullptr);
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);

    // Update the shaders to the new factor.
    std::ostringstream factorDefine;
    factorDefine << "#define FACTOR " << factor << '\n';
    const std::string factorDefineStr = factorDefine.str();
    attachShaders(&mFBWidth, factorDefineStr.c_str(), "#define HORIZONTAL\n", mWidth, mHeight);
    attachShaders(&mFBHeight, factorDefineStr.c_str(), "#define VERTICAL\n", mWidth, mHeight);

    mFactor = factor;

    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);
}

void TextureResize::resize(GLuint texture) {
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
    s_gles2.glActiveTexture(GL_TEXTURE0);

    if (!mFBWidth.framebuffer) {
        s_gles2.glGenFramebuffers(1, &mFBWidth.framebuffer);
    }
    if (!mFBHeight.framebuffer) {
        s_gles2.glGenFramebuffers(1, &mFBHeight.framebuffer);
    }

    // First scale the horizontal dimension by rendering the input texture to a scaled framebuffer.
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, mFBWidth.framebuffer);
    s_gles2.glFramebufferTexture2D(
        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mFBWidth.texture, 0);
    s_gles2.glClear(GL_COLOR_BUFFER_BIT);
    s_gles2.glViewport(0, 0, mWidth / mFactor, mHeight);
    s_gles2.glUseProgram(mFBWidth.program);
    s_gles2.glEnableVertexAttribArray(mFBWidth.aPosition);
    s_gles2.glVertexAttribPointer(mFBWidth.aPosition, 2, GL_FLOAT, GL_FALSE, 0, 0);
    s_gles2.glBindTexture(GL_TEXTURE_2D, texture);

    // Store the current texture filters and set to nearest for scaling.
    GLint mag_filter, min_filter;
    s_gles2.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &mag_filter);
    s_gles2.glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &min_filter);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    s_gles2.glUniform1i(mFBWidth.uTexture, 0);
    s_gles2.glDrawArrays(GL_TRIANGLES, 0, sizeof(kVertexData) / (2 * sizeof(float)));

    // Restore the previous texture filters.
    s_gles2.glDisableVertexAttribArray(mFBWidth.aPosition);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
    s_gles2.glFramebufferTexture2D(
        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
    // Secondly, scale the vertical dimension using the second framebuffer.
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, mFBHeight.framebuffer);
    s_gles2.glFramebufferTexture2D(
        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mFBHeight.texture, 0);
    s_gles2.glClear(GL_COLOR_BUFFER_BIT);
    s_gles2.glViewport(0, 0, mWidth / mFactor, mHeight / mFactor);
    s_gles2.glUseProgram(mFBHeight.program);
    s_gles2.glEnableVertexAttribArray(mFBHeight.aPosition);
    s_gles2.glVertexAttribPointer(mFBHeight.aPosition, 2, GL_FLOAT, GL_FALSE, 0, 0);
    s_gles2.glBindTexture(GL_TEXTURE_2D, mFBWidth.texture);
    s_gles2.glUniform1i(mFBHeight.uTexture, 0);
    s_gles2.glDrawArrays(GL_TRIANGLES, 0, sizeof(kVertexData) / (2 * sizeof(float)));
    s_gles2.glFramebufferTexture2D(
        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
    // Clear the bindings. (Viewport restored outside)
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, 0);
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);
    s_gles2.glDisableVertexAttribArray(mFBHeight.aPosition);
    s_gles2.glUseProgram(0);
    android::base::AutoLock lock(s_postContextResources);
    while (s_programsToRelease.size()) {
        s_gles2.glDeleteProgram(s_programsToRelease.back());
        s_programsToRelease.pop_back();
    }
    if (s_framebuffersToRelease.size()) {
        s_gles2.glDeleteFramebuffers(s_framebuffersToRelease.size(),
                                     s_framebuffersToRelease.data());
        s_framebuffersToRelease.clear();
    }
}

struct Vertex {
    float pos[2];
    float coord[2];
};

TextureResize::GenericResizer::GenericResizer() :
        mProgram(0),
        mVertexBuffer(0),
        mIndexBuffer(0),
        mWidth(0),
        mHeight(0) {
    GLuint vertex_shader =
            createShader(GL_VERTEX_SHADER, {kGenericVertexShaderSource});
    GLuint fragment_shader =
            createShader(GL_FRAGMENT_SHADER, {kGenericFragmentShaderSource});

    mProgram = s_gles2.glCreateProgram();
    s_gles2.glAttachShader(mProgram, vertex_shader);
    s_gles2.glAttachShader(mProgram, fragment_shader);
    s_gles2.glLinkProgram(mProgram);

    // Shader objects no longer needed.
    s_gles2.glDeleteShader(vertex_shader);
    s_gles2.glDeleteShader(fragment_shader);

    // Check for errors.
    GLint success;
    s_gles2.glGetProgramiv(mProgram, GL_LINK_STATUS, &success);
    if (success == GL_FALSE) {
        GLchar infolog[256];
        s_gles2.glGetProgramInfoLog(mProgram, sizeof(infolog), 0, infolog);
        fprintf(stderr, "Could not create/link program: %s\n", infolog);
        return;
    }

    // Get all the attributes and uniforms.
    mPositionAttribLocation =
            s_gles2.glGetAttribLocation(mProgram, "position");
    mInCoordAttribLocation =
            s_gles2.glGetAttribLocation(mProgram, "inCoord");
    mInputUniformLocation =
            s_gles2.glGetUniformLocation(mProgram, "texSampler");

    // Create vertex buffers.
    static const Vertex kVertices[] = {
        // 0 degree
        {{ +1, -1 }, { +1, +0 }},
        {{ +1, +1 }, { +1, +1 }},
        {{ -1, +1 }, { +0, +1 }},
        {{ -1, -1 }, { +0, +0 }},
        // 90 degree clock-wise
        {{ +1, -1 }, { +0, +0 }},
        {{ +1, +1 }, { +1, +0 }},
        {{ -1, +1 }, { +1, +1 }},
        {{ -1, -1 }, { +0, +1 }},
        // 180 degree clock-wise
        {{ +1, -1 }, { +0, +1 }},
        {{ +1, +1 }, { +0, +0 }},
        {{ -1, +1 }, { +1, +0 }},
        {{ -1, -1 }, { +1, +1 }},
        // 270 degree clock-wise
        {{ +1, -1 }, { +1, +1 }},
        {{ +1, +1 }, { +0, +1 }},
        {{ -1, +1 }, { +0, +0 }},
        {{ -1, -1 }, { +1, +0 }},
    };
    s_gles2.glGenBuffers(1, &mVertexBuffer);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
    s_gles2.glBufferData(GL_ARRAY_BUFFER,
                         sizeof(kVertices),
                         kVertices,
                         GL_STATIC_DRAW);

    // indices for predefined rotation angles.
    static const GLubyte kIndices[] = {
        0, 1, 2, 2, 3, 0,      // 0
        4, 5, 6, 6, 7, 4,      // 90
        8, 9, 10, 10, 11, 8,   // 180
        12, 13, 14, 14, 15, 12, // 270
    };
    s_gles2.glGenBuffers(1, &mIndexBuffer);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
    s_gles2.glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                         sizeof(kIndices),
                         kIndices,
                         GL_STATIC_DRAW);

    s_gles2.glGenTextures(1, &mFrameBuffer.texture);
    s_gles2.glBindTexture(GL_TEXTURE_2D, mFrameBuffer.texture);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    s_gles2.glGenFramebuffers(1, &mFrameBuffer.framebuffer);

    // Clear bindings.
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, 0);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}

GLuint TextureResize::GenericResizer::draw(GLuint texture, int width, int height,
                                           int rotation) {
    if (mWidth != width || mHeight != height) {
        // update the framebuffer to match the new resolution
        mWidth = width;
        mHeight = height;
        s_gles2.glBindTexture(GL_TEXTURE_2D, mFrameBuffer.texture);
        s_gles2.glTexImage2D(
            GL_TEXTURE_2D, 0, GL_RGB, mWidth, mHeight, 0, GL_RGB,
            GL_UNSIGNED_BYTE, nullptr);
        s_gles2.glBindTexture(GL_TEXTURE_2D, 0);

    }

    // Store the viewport.
    GLint vport[4] = { 0, };
    s_gles2.glGetIntegerv(GL_VIEWPORT, vport);

    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, mFrameBuffer.framebuffer);
    s_gles2.glFramebufferTexture2D(
        GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mFrameBuffer.texture, 0);
    s_gles2.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    s_gles2.glViewport(0, 0, mWidth, mHeight);
    s_gles2.glUseProgram(mProgram);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
    s_gles2.glEnableVertexAttribArray(mPositionAttribLocation);
    s_gles2.glVertexAttribPointer(mPositionAttribLocation,
                                  2, // components per attrib
                                  GL_FLOAT,
                                  GL_FALSE,
                                  sizeof(Vertex), // stride
                                  0); // offset
    s_gles2.glEnableVertexAttribArray(mInCoordAttribLocation);
    s_gles2.glVertexAttribPointer(mInCoordAttribLocation,
                                  2,
                                  GL_FLOAT,
                                  GL_FALSE,
                                  sizeof(Vertex),
                                  reinterpret_cast<GLvoid*>(sizeof(float) * 2));
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
    s_gles2.glActiveTexture(GL_TEXTURE0);
    s_gles2.glBindTexture(GL_TEXTURE_2D, texture);
    s_gles2.glUniform1i(mInputUniformLocation, 0);
    intptr_t indexShift;
    switch(rotation) {
    case SKIN_ROTATION_0:
        indexShift = 0;
        break;
    case SKIN_ROTATION_90:
        indexShift = 6;
        break;
    case SKIN_ROTATION_180:
        indexShift = 12;
        break;
    case SKIN_ROTATION_270:
        indexShift = 18;
        break;
    default:
        indexShift = 0;
    }
    s_gles2.glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, (const GLvoid*)indexShift);

    // Clear the bindings.
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, 0);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    s_gles2.glBindFramebuffer(GL_FRAMEBUFFER, 0);
    s_gles2.glBindTexture(GL_TEXTURE_2D, 0);
    s_gles2.glDisableVertexAttribArray(mPositionAttribLocation);
    s_gles2.glDisableVertexAttribArray(mInCoordAttribLocation);

    // Restore the viewport.
    s_gles2.glViewport(vport[0], vport[1], vport[2], vport[3]);

    return mFrameBuffer.texture;
}

TextureResize::GenericResizer::~GenericResizer() {
    s_gles2.glDeleteFramebuffers(1, &mFrameBuffer.framebuffer);
    s_gles2.glDeleteTextures(1, &mFrameBuffer.texture);
    s_gles2.glUseProgram(0);
    s_gles2.glDeleteProgram(mProgram);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, 0);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    s_gles2.glDeleteBuffers(1, &mVertexBuffer);
    s_gles2.glDeleteBuffers(1, &mIndexBuffer);
}

}  // namespace gl
}  // namespace gfxstream