/*
* Copyright (C) 2016 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 "YUVConverter.h"

#include "DispatchTables.h"
#include "host-common/feature_control.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>

#define FATAL(fmt,...) do { \
    fprintf(stderr, "%s: FATAL: " fmt "\n", __func__, ##__VA_ARGS__); \
    assert(false); \
} while(0)

#define YUV_CONVERTER_DEBUG 0

#if YUV_CONVERTER_DEBUG
#define DDD(fmt, ...)                                                     \
    fprintf(stderr, "yuv-converter: %s:%d " fmt "\n", __func__, __LINE__, \
            ##__VA_ARGS__);
#else
#define DDD(fmt, ...)
#endif

enum YUVInterleaveDirection {
    YUVInterleaveDirectionVU = 0,
    YUVInterleaveDirectionUV = 1,
};

// getYUVOffsets(), given a YUV-formatted buffer that is arranged
// according to the spec
// https://developer.android.com/reference/android/graphics/ImageFormat.html#YUV
// In particular, Android YUV widths are aligned to 16 pixels.
// Inputs:
// |yv12|: the YUV-formatted buffer
// Outputs:
// |yoff|: offset into |yv12| of the start of the Y component
// |uoff|: offset into |yv12| of the start of the U component
// |voff|: offset into |yv12| of the start of the V component
static void getYUVOffsets(int width, int height, FrameworkFormat format,
                          uint32_t* yoff, uint32_t* uoff, uint32_t* voff,
                          uint32_t* alignwidth, uint32_t* alignwidthc) {
    uint32_t yStride, cStride, cHeight, cSize, align;
    switch (format) {
    case FRAMEWORK_FORMAT_YV12:
        // Luma stride is 32 bytes aligned.
        align = 32;
        yStride = (width + (align - 1)) & ~(align - 1);
        // Chroma stride is 16 bytes aligned.
        align = 16;
        cStride = (yStride / 2 + (align - 1)) & ~(align - 1);
        cHeight = height / 2;
        cSize = cStride * cHeight;
        *yoff = 0;
        *voff = yStride * height;
        *uoff = (*voff) + cSize;
        *alignwidth = yStride;
        *alignwidthc = cStride;
        break;
    case FRAMEWORK_FORMAT_YUV_420_888:
        if (feature_is_enabled(
                kFeature_YUV420888toNV21)) {
            align = 1;
            yStride = (width + (align - 1)) & ~(align - 1);
            cStride = yStride;
            cHeight = height / 2;
            *yoff = 0;
            *voff = yStride * height;
            *uoff = (*voff) + 1;
            *alignwidth = yStride;
            *alignwidthc = cStride / 2;
        } else {
            align = 1;
            yStride = (width + (align - 1)) & ~(align - 1);
            cStride = (yStride / 2 + (align - 1)) & ~(align - 1);
            cHeight = height / 2;
            cSize = cStride * cHeight;
            *yoff = 0;
            *uoff = yStride * height;
            *voff = (*uoff) + cSize;
            *alignwidth = yStride;
            *alignwidthc = cStride;
        }
        break;
    case FRAMEWORK_FORMAT_NV12:
        align = 1;
        yStride = width;
        cStride = yStride;
        cHeight = height / 2;
        cSize = cStride * cHeight;
        *yoff = 0;
        *uoff = yStride * height;
        *voff = (*uoff) + 1;
        *alignwidth = yStride;
        *alignwidthc = cStride / 2;
        break;
    case FRAMEWORK_FORMAT_GL_COMPATIBLE:
        FATAL("Input not a YUV format! (FRAMEWORK_FORMAT_GL_COMPATIBLE)");
    default:
        FATAL("Unknown format: 0x%x", format);
    }
}

// createYUVGLTex() allocates GPU memory that is enough
// to hold the raw data of the YV12 buffer.
// The memory is in the form of an OpenGL texture
// with one component (GL_LUMINANCE) and
// of type GL_UNSIGNED_BYTE.
// In order to process all Y, U, V components
// simultaneously in conversion, the simple thing to do
// is to use multiple texture units, hence
// the |texture_unit| argument.
// Returns a new OpenGL texture object in |texName_out|
// that is to be cleaned up by the caller.
void YUVConverter::createYUVGLTex(GLenum texture_unit,
                                  GLsizei width,
                                  GLsizei height,
                                  GLuint* texName_out,
                                  bool uvInterleaved) {
    assert(texName_out);

    s_gles2.glActiveTexture(texture_unit);
    s_gles2.glGenTextures(1, texName_out);
    s_gles2.glBindTexture(GL_TEXTURE_2D, *texName_out);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    s_gles2.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    GLint unprevAlignment = 0;
    s_gles2.glGetIntegerv(GL_UNPACK_ALIGNMENT, &unprevAlignment);
    s_gles2.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    if (uvInterleaved) {
        s_gles2.glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
                             width, height, 0,
                             GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
                             NULL);
    } else {
        s_gles2.glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,
                             width, height, 0,
                             GL_LUMINANCE, GL_UNSIGNED_BYTE,
                             NULL);
    }
    s_gles2.glPixelStorei(GL_UNPACK_ALIGNMENT, unprevAlignment);
    s_gles2.glActiveTexture(GL_TEXTURE0);
}

static void readYUVTex(GLuint tex, void* pixels, bool uvInterleaved) {
    GLuint prevTexture = 0;
    s_gles2.glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)&prevTexture);
    s_gles2.glBindTexture(GL_TEXTURE_2D, tex);
    GLint prevAlignment = 0;
    s_gles2.glGetIntegerv(GL_PACK_ALIGNMENT, &prevAlignment);
    s_gles2.glPixelStorei(GL_PACK_ALIGNMENT, 1);
    if (uvInterleaved) {
        if (s_gles2.glGetTexImage) {
            s_gles2.glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
                                  GL_UNSIGNED_BYTE, pixels);
        } else {
            DDD("empty glGetTexImage");
        }
    } else {
        if (s_gles2.glGetTexImage) {
            s_gles2.glGetTexImage(GL_TEXTURE_2D, 0, GL_LUMINANCE,
                                  GL_UNSIGNED_BYTE, pixels);
        } else {
            DDD("empty glGetTexImage");
        }
    }
    s_gles2.glPixelStorei(GL_PACK_ALIGNMENT, prevAlignment);
    s_gles2.glBindTexture(GL_TEXTURE_2D, prevTexture);
}

// subUpdateYUVGLTex() updates a given YUV texture
// at the coordinates (x, y, width, height),
// with the raw YUV data in |pixels|.
// We cannot view the result properly until
// after conversion; this is to be used only
// as input to the conversion shader.
static void subUpdateYUVGLTex(GLenum texture_unit,
                              GLuint tex,
                              int x, int y, int width, int height,
                              void* pixels, bool uvInterleaved) {
    s_gles2.glActiveTexture(texture_unit);
    s_gles2.glBindTexture(GL_TEXTURE_2D, tex);
    GLint unprevAlignment = 0;
    s_gles2.glGetIntegerv(GL_UNPACK_ALIGNMENT, &unprevAlignment);
    s_gles2.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    if (uvInterleaved) {
        s_gles2.glTexSubImage2D(GL_TEXTURE_2D, 0,
                                x, y, width, height,
                                GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
                                pixels);
    } else {
        s_gles2.glTexSubImage2D(GL_TEXTURE_2D, 0,
                                x, y, width, height,
                                GL_LUMINANCE, GL_UNSIGNED_BYTE,
                                pixels);
    }
    s_gles2.glPixelStorei(GL_UNPACK_ALIGNMENT, unprevAlignment);

    s_gles2.glActiveTexture(GL_TEXTURE0);
}

// createYUVGLShader() defines the vertex/fragment
// shader that does the actual work of converting
// YUV to RGB. The resulting program is stored in |program_out|.
static void createYUVGLShader(GLuint* program_out,
                              GLint* ywidthcutoffloc_out,
                              GLint* cwidthcutoffloc_out,
                              GLint* ysamplerloc_out,
                              GLint* usamplerloc_out,
                              GLint* vsamplerloc_out,
                              GLint* incoordloc_out,
                              GLint* posloc_out) {
    assert(program_out);

    static const char kVShader[] = R"(
precision highp float;
attribute mediump vec4 position;
attribute highp vec2 inCoord;
varying highp vec2 outCoord;
void main(void) {
  gl_Position = position;
  outCoord = inCoord;
}
    )";
    const GLchar* const kVShaders =
        static_cast<const GLchar*>(kVShader);

    // Based on:
    // http://stackoverflow.com/questions/11093061/yv12-to-rgb-using-glsl-in-ios-result-image-attached
    // + account for 16-pixel alignment using |yWidthCutoff| / |cWidthCutoff|
    // + use conversion matrix in
    // frameworks/av/media/libstagefright/colorconversion/ColorConverter.cpp (YUV420p)
    // + more precision from
    // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
    static const char kFShader[] = R"(
precision highp float;
varying highp vec2 outCoord;
uniform highp float yWidthCutoff;
uniform highp float cWidthCutoff;
uniform sampler2D ysampler;
uniform sampler2D usampler;
uniform sampler2D vsampler;
void main(void) {
    highp vec2 cutoffCoordsY;
    highp vec2 cutoffCoordsC;
    highp vec3 yuv;
    highp vec3 rgb;
    cutoffCoordsY.x = outCoord.x * yWidthCutoff;
    cutoffCoordsY.y = outCoord.y;
    cutoffCoordsC.x = outCoord.x * cWidthCutoff;
    cutoffCoordsC.y = outCoord.y;
    yuv[0] = texture2D(ysampler, cutoffCoordsY).r - 0.0625;
    yuv[1] = 0.96*(texture2D(usampler, cutoffCoordsC).r - 0.5);
    yuv[2] = texture2D(vsampler, cutoffCoordsC).r - 0.5;
    highp float yscale = 1.1643835616438356;
    rgb = mat3(yscale,                           yscale,            yscale,
               0,                  -0.39176229009491365, 2.017232142857143,
               1.5960267857142856, -0.8129676472377708,                  0) * yuv;
    gl_FragColor = vec4(rgb, 1);
}
    )";

    const GLchar* const kFShaders =
        static_cast<const GLchar*>(kFShader);

    GLuint vshader = s_gles2.glCreateShader(GL_VERTEX_SHADER);
    GLuint fshader = s_gles2.glCreateShader(GL_FRAGMENT_SHADER);

    const GLint vtextLen = strlen(kVShader);
    const GLint ftextLen = strlen(kFShaders);
    s_gles2.glShaderSource(vshader, 1, &kVShaders, &vtextLen);
    s_gles2.glShaderSource(fshader, 1, &kFShaders, &ftextLen);
    s_gles2.glCompileShader(vshader);
    s_gles2.glCompileShader(fshader);

    *program_out = s_gles2.glCreateProgram();
    s_gles2.glAttachShader(*program_out, vshader);
    s_gles2.glAttachShader(*program_out, fshader);
    s_gles2.glLinkProgram(*program_out);

    *ywidthcutoffloc_out = s_gles2.glGetUniformLocation(*program_out, "yWidthCutoff");
    *cwidthcutoffloc_out = s_gles2.glGetUniformLocation(*program_out, "cWidthCutoff");
    *ysamplerloc_out = s_gles2.glGetUniformLocation(*program_out, "ysampler");
    *usamplerloc_out = s_gles2.glGetUniformLocation(*program_out, "usampler");
    *vsamplerloc_out = s_gles2.glGetUniformLocation(*program_out, "vsampler");
    *posloc_out = s_gles2.glGetAttribLocation(*program_out, "position");
    *incoordloc_out = s_gles2.glGetAttribLocation(*program_out, "inCoord");

    s_gles2.glDeleteShader(vshader);
    s_gles2.glDeleteShader(fshader);
}

static void createYUVInterleavedGLShader(GLuint* program_out,
                                         GLint* ywidthcutoffloc_out,
                                         GLint* cwidthcutoffloc_out,
                                         GLint* ysamplerloc_out,
                                         GLint* vusamplerloc_out,
                                         GLint* incoordloc_out,
                                         GLint* posloc_out,
                                         YUVInterleaveDirection interleaveDir) {
    assert(program_out);

    static const char kVShader[] = R"(
precision highp float;
attribute mediump vec4 position;
attribute highp vec2 inCoord;
varying highp vec2 outCoord;
void main(void) {
  gl_Position = position;
  outCoord = inCoord;
}
    )";
    const GLchar* const kVShaders =
        static_cast<const GLchar*>(kVShader);

    // Based on:
    // https://stackoverflow.com/questions/22456884/how-to-render-androids-yuv-nv21-camera-image-on-the-background-in-libgdx-with-o
    // + account for 16-pixel alignment using |yWidthCutoff| / |cWidthCutoff|
    // + use conversion matrix in
    // frameworks/av/media/libstagefright/colorconversion/ColorConverter.cpp (YUV420p)
    // + more precision from
    // https://en.wikipedia.org/wiki/YCbCr#ITU-R_BT.601_conversion
    // UV texture is (width/2*height/2) in size (downsampled by 2 in
    // both dimensions, each pixel corresponds to 4 pixels of the Y channel)
    // and each pixel is two bytes. By setting GL_LUMINANCE_ALPHA, OpenGL
    // puts first byte (V) into R,G and B components and of the texture
    // and the second byte (U) into the A component of the texture. That's
    // why we find U and V at A and R respectively in the fragment shader code.
    // Note that we could have also found V at G or B as well.
    static const char kFShaderVu[] = R"(
precision highp float;
varying highp vec2 outCoord;
uniform highp float yWidthCutoff;
uniform highp float cWidthCutoff;
uniform sampler2D ysampler;
uniform sampler2D vusampler;
void main(void) {
    highp vec2 cutoffCoordsY;
    highp vec2 cutoffCoordsC;
    highp vec3 yuv;
    highp vec3 rgb;
    cutoffCoordsY.x = outCoord.x * yWidthCutoff;
    cutoffCoordsY.y = outCoord.y;
    cutoffCoordsC.x = outCoord.x * cWidthCutoff;
    cutoffCoordsC.y = outCoord.y;
    yuv[0] = texture2D(ysampler, cutoffCoordsY).r - 0.0625;
    yuv[1] = 0.96 * (texture2D(vusampler, cutoffCoordsC).a - 0.5);
    yuv[2] = texture2D(vusampler, cutoffCoordsC).r - 0.5;
    highp float yscale = 1.1643835616438356;
    rgb = mat3(yscale,                           yscale,            yscale,
               0,                  -0.39176229009491365, 2.017232142857143,
               1.5960267857142856, -0.8129676472377708,                  0) * yuv;
    gl_FragColor = vec4(rgb, 1);
}
    )";

    static const char kFShaderUv[] = R"(
precision highp float;
varying highp vec2 outCoord;
uniform highp float yWidthCutoff;
uniform highp float cWidthCutoff;
uniform sampler2D ysampler;
uniform sampler2D uvsampler;
void main(void) {
    highp vec2 cutoffCoordsY;
    highp vec2 cutoffCoordsC;
    highp vec3 yuv;
    highp vec3 rgb;
    cutoffCoordsY.x = outCoord.x * yWidthCutoff;
    cutoffCoordsY.y = outCoord.y;
    cutoffCoordsC.x = outCoord.x * cWidthCutoff;
    cutoffCoordsC.y = outCoord.y;
    yuv[0] = texture2D(ysampler, cutoffCoordsY).r - 0.0625;
    yuv[1] = 0.96 * (texture2D(uvsampler, cutoffCoordsC).r - 0.5);
    yuv[2] = (texture2D(uvsampler, cutoffCoordsC).a - 0.5);
    highp float yscale = 1.1643835616438356;
    rgb = mat3(yscale,                           yscale,            yscale,
               0,                  -0.39176229009491365, 2.017232142857143,
               1.5960267857142856, -0.8129676472377708,                  0) * yuv;
    gl_FragColor = vec4(rgb, 1);
}
    )";

    const GLchar* const kFShaders =
        interleaveDir == YUVInterleaveDirectionVU ? kFShaderVu : kFShaderUv;

    GLuint vshader = s_gles2.glCreateShader(GL_VERTEX_SHADER);
    GLuint fshader = s_gles2.glCreateShader(GL_FRAGMENT_SHADER);

    const GLint vtextLen = strlen(kVShader);
    const GLint ftextLen = strlen(kFShaders);
    s_gles2.glShaderSource(vshader, 1, &kVShaders, &vtextLen);
    s_gles2.glShaderSource(fshader, 1, &kFShaders, &ftextLen);
    s_gles2.glCompileShader(vshader);
    s_gles2.glCompileShader(fshader);

    *program_out = s_gles2.glCreateProgram();
    s_gles2.glAttachShader(*program_out, vshader);
    s_gles2.glAttachShader(*program_out, fshader);
    s_gles2.glLinkProgram(*program_out);

    *ywidthcutoffloc_out = s_gles2.glGetUniformLocation(*program_out, "yWidthCutoff");
    *cwidthcutoffloc_out = s_gles2.glGetUniformLocation(*program_out, "cWidthCutoff");
    *ysamplerloc_out = s_gles2.glGetUniformLocation(*program_out, "ysampler");
    *vusamplerloc_out = s_gles2.glGetUniformLocation(
            *program_out, YUVInterleaveDirectionVU ? "vusampler" : "uvsampler");
    *posloc_out = s_gles2.glGetAttribLocation(*program_out, "position");
    *incoordloc_out = s_gles2.glGetAttribLocation(*program_out, "inCoord");

    s_gles2.glDeleteShader(vshader);
    s_gles2.glDeleteShader(fshader);
}
// When converting YUV to RGB with shaders,
// we are using the OpenGL graphics pipeline to do compute,
// so we need to express the place to store the result
// with triangles and draw calls.
// createYUVGLFullscreenQuad() defines a fullscreen quad
// with position and texture coordinates.
// The quad will be textured with the resulting RGB colors,
// and we will read back the pixels from the framebuffer
// to retrieve our RGB result.
static void createYUVGLFullscreenQuad(GLuint* vbuf_out,
                                      GLuint* ibuf_out,
                                      int picture_width,
                                      int aligned_width) {
    assert(vbuf_out);
    assert(ibuf_out);

    s_gles2.glGenBuffers(1, vbuf_out);
    s_gles2.glGenBuffers(1, ibuf_out);

    static const float kVertices[] = {
        +1, -1, +0, +1, +0,
        +1, +1, +0, +1, +1,
        -1, +1, +0, +0, +1,
        -1, -1, +0, +0, +0,
    };

    static const GLubyte kIndices[] = { 0, 1, 2, 2, 3, 0 };

    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, *vbuf_out);
    s_gles2.glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices,
                         GL_STATIC_DRAW);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, *ibuf_out);
    s_gles2.glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(kIndices), kIndices,
                         GL_STATIC_DRAW);
}

// doYUVConversionDraw() does the actual work of setting up
// and submitting draw commands to the GPU.
// It uses the textures, shaders, and fullscreen quad defined above
// and executes the pipeline on them.
// Note, however, that it is up to the caller to dig out
// the result of the draw.
static void doYUVConversionDraw(GLuint program,
                                GLint yWidthCutoffLoc,
                                GLint cWidthCutoffLoc,
                                GLint ySamplerLoc,
                                GLint uSamplerLoc,
                                GLint vSamplerLoc,
                                GLint vuSamplerLoc,
                                GLint inCoordLoc,
                                GLint posLoc,
                                GLuint vbuf, GLuint ibuf,
                                int width, int ywidth,
                                int halfwidth, int cwidth,
                                float yWidthCutoff,
                                float cWidthCutoff,
                                bool uvInterleaved) {

    const GLsizei kVertexAttribStride = 5 * sizeof(GL_FLOAT);
    const GLvoid* kVertexAttribPosOffset = (GLvoid*)0;
    const GLvoid* kVertexAttribCoordOffset = (GLvoid*)(3 * sizeof(GL_FLOAT));

    s_gles2.glUseProgram(program);

    s_gles2.glUniform1f(yWidthCutoffLoc, yWidthCutoff);
    s_gles2.glUniform1f(cWidthCutoffLoc, cWidthCutoff);

    s_gles2.glUniform1i(ySamplerLoc, 0);
    if (uvInterleaved) {
        s_gles2.glUniform1i(vuSamplerLoc, 1);
    } else {
        s_gles2.glUniform1i(uSamplerLoc, 1);
        s_gles2.glUniform1i(vSamplerLoc, 2);
    }

    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, vbuf);
    s_gles2.glEnableVertexAttribArray(posLoc);
    s_gles2.glEnableVertexAttribArray(inCoordLoc);

    s_gles2.glVertexAttribPointer(posLoc, 3, GL_FLOAT, false,
                                  kVertexAttribStride,
                                  kVertexAttribPosOffset);
    s_gles2.glVertexAttribPointer(inCoordLoc, 2, GL_FLOAT, false,
                                  kVertexAttribStride,
                                  kVertexAttribCoordOffset);

    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf);
    s_gles2.glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);

    s_gles2.glDisableVertexAttribArray(posLoc);
    s_gles2.glDisableVertexAttribArray(inCoordLoc);
}

// initialize(): allocate GPU memory for YUV components,
// and create shaders and vertex data.
YUVConverter::YUVConverter(int width, int height, FrameworkFormat format)
    : mWidth(width),
      mHeight(height),
      mFormat(format),
      mCbFormat(format) {}

void YUVConverter::init(int width, int height, FrameworkFormat format) {
    uint32_t yoff, uoff, voff, ywidth, cwidth, cheight;
    getYUVOffsets(width, height, mFormat,
                  &yoff, &uoff, &voff,
                  &ywidth, &cwidth);
    cheight = height / 2;

    mWidth = width;
    mHeight = height;
    if (!mYtex)
        createYUVGLTex(GL_TEXTURE0, ywidth, height, &mYtex, false);
    switch (mFormat) {
        case FRAMEWORK_FORMAT_YV12:
            if (!mUtex)
                createYUVGLTex(GL_TEXTURE1, cwidth, cheight, &mUtex, false);
            if (!mVtex)
                createYUVGLTex(GL_TEXTURE2, cwidth, cheight, &mVtex, false);
            createYUVGLShader(&mProgram,
                              &mYWidthCutoffLoc,
                              &mCWidthCutoffLoc,
                              &mYSamplerLoc,
                              &mUSamplerLoc,
                              &mVSamplerLoc,
                              &mInCoordLoc,
                              &mPosLoc);
            break;
        case FRAMEWORK_FORMAT_YUV_420_888:
            if (feature_is_enabled(
                    kFeature_YUV420888toNV21)) {
                if (!mVUtex)
                    createYUVGLTex(GL_TEXTURE1, cwidth, cheight, &mVUtex, true);
                createYUVInterleavedGLShader(&mProgram,
                                             &mYWidthCutoffLoc,
                                             &mCWidthCutoffLoc,
                                             &mYSamplerLoc,
                                             &mVUSamplerLoc,
                                             &mInCoordLoc,
                                             &mPosLoc,
                                             YUVInterleaveDirectionVU);
            } else {
                if (!mUtex)
                    createYUVGLTex(GL_TEXTURE1, cwidth, cheight, &mUtex, false);
                if (!mVtex)
                    createYUVGLTex(GL_TEXTURE2, cwidth, cheight, &mVtex, false);
                createYUVGLShader(&mProgram,
                                  &mYWidthCutoffLoc,
                                  &mCWidthCutoffLoc,
                                  &mYSamplerLoc,
                                  &mUSamplerLoc,
                                  &mVSamplerLoc,
                                  &mInCoordLoc,
                                  &mPosLoc);
            }
            break;
        case FRAMEWORK_FORMAT_NV12:
            if (!mUVtex)
                createYUVGLTex(GL_TEXTURE1, cwidth, cheight, &mUVtex, true);
            createYUVInterleavedGLShader(&mProgram,
                                         &mYWidthCutoffLoc,
                                         &mCWidthCutoffLoc,
                                         &mYSamplerLoc,
                                         &mVUSamplerLoc,
                                         &mInCoordLoc,
                                         &mPosLoc,
                                         YUVInterleaveDirectionUV);
            break;
        default:
            FATAL("Unknown format: 0x%x", mFormat);
    }

    createYUVGLFullscreenQuad(&mVbuf, &mIbuf, width, ywidth);
}

void YUVConverter::saveGLState() {
    s_gles2.glGetFloatv(GL_VIEWPORT, mCurrViewport);
    s_gles2.glGetIntegerv(GL_ACTIVE_TEXTURE, &mCurrTexUnit);
    s_gles2.glGetIntegerv(GL_TEXTURE_BINDING_2D, &mCurrTexBind);
    s_gles2.glGetIntegerv(GL_CURRENT_PROGRAM, &mCurrProgram);
    s_gles2.glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &mCurrVbo);
    s_gles2.glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &mCurrIbo);
}

void YUVConverter::restoreGLState() {
    s_gles2.glViewport(mCurrViewport[0], mCurrViewport[1],
                       mCurrViewport[2], mCurrViewport[3]);
    s_gles2.glActiveTexture(mCurrTexUnit);
    s_gles2.glUseProgram(mCurrProgram);
    s_gles2.glBindBuffer(GL_ARRAY_BUFFER, mCurrVbo);
    s_gles2.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mCurrIbo);
}

uint32_t YUVConverter::getDataSize() {
    uint32_t align = (mFormat == FRAMEWORK_FORMAT_YV12) ? 16 : 1;
    uint32_t yStride = (mWidth + (align - 1)) & ~(align - 1);
    uint32_t uvStride = (yStride / 2 + (align - 1)) & ~(align - 1);
    uint32_t uvHeight = mHeight / 2;
    uint32_t dataSize = yStride * mHeight + 2 * (uvHeight * uvStride);
    return dataSize;
}

void YUVConverter::readPixels(uint8_t* pixels, uint32_t pixels_size) {
    int width = mWidth;
    int height = mHeight;

    DDD("calling %s %d\n texture: width %d height %d\n", __func__, __LINE__,
        width, height);
    {
        uint32_t align = (mFormat == FRAMEWORK_FORMAT_YV12) ? 16 : 1;
        uint32_t yStride = (width + (align - 1)) & ~(align - 1);
        uint32_t uvStride = (yStride / 2 + (align - 1)) & ~(align - 1);
        uint32_t uvHeight = height / 2;
        uint32_t dataSize = yStride * height + 2 * (uvHeight * uvStride);
        if (pixels_size != dataSize) {
            DDD("failed %s %d\n", __func__, __LINE__);
            return;
        }
        DDD("%s %d reading %d bytes\n", __func__, __LINE__, (int)dataSize);
    }

    uint32_t yoff, uoff, voff, ywidth, cwidth;
    getYUVOffsets(width, height, mFormat, &yoff, &uoff, &voff, &ywidth,
                  &cwidth);

    if (mFormat == FRAMEWORK_FORMAT_YUV_420_888) {
        if (feature_is_enabled(
                kFeature_YUV420888toNV21)) {
            readYUVTex(mVUtex, pixels + voff, true);
            DDD("done");
        } else {
            readYUVTex(mUtex, pixels + uoff, false);
            readYUVTex(mVtex, pixels + voff, false);
            DDD("done");
        }
    } else if (mFormat == FRAMEWORK_FORMAT_NV12) {
        readYUVTex(mUVtex, pixels + uoff, true);
        if (mCbFormat == FRAMEWORK_FORMAT_YUV_420_888) {
            // do a conversion here inplace: NV12 to YUV 420 888
            uint8_t* scrath_memory = pixels;
            NV12ToYUV420PlanarInPlaceConvert(width, height, pixels,
                                             scrath_memory);
            DDD("done");
        }
        DDD("done");
    } else if (mFormat == FRAMEWORK_FORMAT_YV12) {
            readYUVTex(mUtex, pixels + uoff, false);
            readYUVTex(mVtex, pixels + voff, false);
            DDD("done");
    }
    // read Y the last, because we can might used it as a scratch space
    readYUVTex(mYtex, pixels + yoff, false);
    DDD("done");
}

void YUVConverter::swapTextures(uint32_t type, uint32_t* textures) {
    if (type == FRAMEWORK_FORMAT_NV12) {
        mFormat = FRAMEWORK_FORMAT_NV12;
        std::swap(textures[0], mYtex);
        std::swap(textures[1], mUVtex);
    } else if (type == FRAMEWORK_FORMAT_YUV_420_888) {
        mFormat = FRAMEWORK_FORMAT_YUV_420_888;
        std::swap(textures[0], mYtex);
        std::swap(textures[1], mUtex);
        std::swap(textures[2], mVtex);
    } else {
        FATAL("Unknown format: 0x%x", type);
    }
}

// drawConvert: per-frame updates.
// Update YUV textures, then draw the fullscreen
// quad set up above, which results in a framebuffer
// with the RGB colors.
void YUVConverter::drawConvert(int x, int y,
                               int width, int height,
                               char* pixels) {
    saveGLState();
    if (pixels && (width != mWidth || height != mHeight)) {
        reset();
    }

    if (mProgram == 0) {
        init(width, height, mFormat);
    }
    s_gles2.glViewport(x, y, width, height);
    uint32_t yoff, uoff, voff, ywidth, cwidth, cheight;
    getYUVOffsets(width, height, mFormat, &yoff, &uoff, &voff, &ywidth,
                  &cwidth);
    cheight = height / 2;
    updateCutoffs(width, ywidth, width / 2, cwidth);

    if (!pixels) {
        // special case: draw from texture, only support NV12 for now
        // as cuvid's native format is NV12.
        // TODO: add more formats if there are such needs in the future.
        assert(mFormat == FRAMEWORK_FORMAT_NV12);
        s_gles2.glActiveTexture(GL_TEXTURE1);
        s_gles2.glBindTexture(GL_TEXTURE_2D, mUVtex);
        s_gles2.glActiveTexture(GL_TEXTURE0);
        s_gles2.glBindTexture(GL_TEXTURE_2D, mYtex);

        doYUVConversionDraw(mProgram, mYWidthCutoffLoc, mCWidthCutoffLoc,
                            mYSamplerLoc, mUSamplerLoc, mVSamplerLoc,
                            mVUSamplerLoc, mInCoordLoc, mPosLoc, mVbuf, mIbuf,
                            width, ywidth, width / 2, cwidth, mYWidthCutoff,
                            mCWidthCutoff, true);

        restoreGLState();
        return;
    }

    subUpdateYUVGLTex(GL_TEXTURE0, mYtex,
                      x, y, ywidth, height,
                      pixels + yoff, false);

    switch (mFormat) {
        case FRAMEWORK_FORMAT_YV12:
            subUpdateYUVGLTex(GL_TEXTURE1, mUtex,
                              x, y, cwidth, cheight,
                              pixels + uoff, false);
            subUpdateYUVGLTex(GL_TEXTURE2, mVtex,
                              x, y, cwidth, cheight,
                              pixels + voff, false);
            doYUVConversionDraw(mProgram,
                                mYWidthCutoffLoc,
                                mCWidthCutoffLoc,
                                mYSamplerLoc,
                                mUSamplerLoc,
                                mVSamplerLoc,
                                mVUSamplerLoc,
                                mInCoordLoc,
                                mPosLoc,
                                mVbuf, mIbuf,
                                width, ywidth,
                                width / 2, cwidth,
                                mYWidthCutoff,
                                mCWidthCutoff,
                                false);
            break;
        case FRAMEWORK_FORMAT_YUV_420_888:
            if (feature_is_enabled(
                    kFeature_YUV420888toNV21)) {
                subUpdateYUVGLTex(GL_TEXTURE1, mVUtex,
                                  x, y, cwidth, cheight,
                                  pixels + voff, true);
                doYUVConversionDraw(mProgram,
                                    mYWidthCutoffLoc,
                                    mCWidthCutoffLoc,
                                    mYSamplerLoc,
                                    mUSamplerLoc,
                                    mVSamplerLoc,
                                    mVUSamplerLoc,
                                    mInCoordLoc,
                                    mPosLoc,
                                    mVbuf, mIbuf,
                                    width, ywidth,
                                    width / 2, cwidth,
                                    mYWidthCutoff,
                                    mCWidthCutoff,
                                    true);
            } else {
                subUpdateYUVGLTex(GL_TEXTURE1, mUtex,
                                  x, y, cwidth, cheight,
                                  pixels + uoff, false);
                subUpdateYUVGLTex(GL_TEXTURE2, mVtex,
                                  x, y, cwidth, cheight,
                                  pixels + voff, false);
                doYUVConversionDraw(mProgram,
                                    mYWidthCutoffLoc,
                                    mCWidthCutoffLoc,
                                    mYSamplerLoc,
                                    mUSamplerLoc,
                                    mVSamplerLoc,
                                    mVUSamplerLoc,
                                    mInCoordLoc,
                                    mPosLoc,
                                    mVbuf, mIbuf,
                                    width, ywidth,
                                    width / 2, cwidth,
                                    mYWidthCutoff,
                                    mCWidthCutoff,
                                    false);
            }
            break;
        case FRAMEWORK_FORMAT_NV12:
            subUpdateYUVGLTex(GL_TEXTURE1, mUVtex,
                              x, y, cwidth, cheight,
                              pixels + uoff, true);
            doYUVConversionDraw(mProgram,
                                mYWidthCutoffLoc,
                                mCWidthCutoffLoc,
                                mYSamplerLoc,
                                mUSamplerLoc,
                                mVSamplerLoc,
                                mVUSamplerLoc,
                                mInCoordLoc,
                                mPosLoc,
                                mVbuf, mIbuf,
                                width, ywidth,
                                width / 2, cwidth,
                                mYWidthCutoff,
                                mCWidthCutoff,
                                true);
            break;
        default:
            FATAL("Unknown format: 0x%x", mFormat);
    }

    restoreGLState();
}

void YUVConverter::updateCutoffs(float width, float ywidth,
                                 float halfwidth, float cwidth) {
    switch (mFormat) {
    case FRAMEWORK_FORMAT_YV12:
        mYWidthCutoff = ((float)width) / ((float)ywidth);
        mCWidthCutoff = ((float)halfwidth) / ((float)cwidth);
        break;
    case FRAMEWORK_FORMAT_YUV_420_888:
        mYWidthCutoff = 1.0f;
        mCWidthCutoff = 1.0f;
        break;
    case FRAMEWORK_FORMAT_NV12:
        mYWidthCutoff = 1.0f;
        mCWidthCutoff = 1.0f;
        break;
    case FRAMEWORK_FORMAT_GL_COMPATIBLE:
        FATAL("Input not a YUV format!");
    }
}

void YUVConverter::reset() {
    if (mIbuf) s_gles2.glDeleteBuffers(1, &mIbuf);
    if (mVbuf) s_gles2.glDeleteBuffers(1, &mVbuf);
    if (mProgram) s_gles2.glDeleteProgram(mProgram);
    if (mYtex) s_gles2.glDeleteTextures(1, &mYtex);
    if (mUtex) s_gles2.glDeleteTextures(1, &mUtex);
    if (mVtex) s_gles2.glDeleteTextures(1, &mVtex);
    if (mVUtex) s_gles2.glDeleteTextures(1, &mVUtex);
    if (mUVtex) s_gles2.glDeleteTextures(1, &mUVtex);
    mIbuf = 0;
    mVbuf = 0;
    mProgram = 0;
    mYtex = 0;
    mUtex = 0;
    mVtex = 0;
    mVUtex = 0;
    mUVtex = 0;
}

YUVConverter::~YUVConverter() {
    reset();
}