Move Camera Java/Native source into Gallery2

Change-Id: I968efe4d656e88a7760d3c0044f65b4adac2ddd1

10 files changed, 1086 insertions, 0 deletions

diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.cpp b/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.cpp
new file mode 100755
index 000000000..a956f23b7
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.cpp
@@ -0,0 +1,98 @@
+#include "FrameBuffer.h"
+
+FrameBuffer::FrameBuffer()
+{
+    Reset();
+}
+
+FrameBuffer::~FrameBuffer() {
+}
+
+void FrameBuffer::Reset() {
+    mFrameBufferName = -1;
+    mTextureName = -1;
+    mWidth = 0;
+    mHeight = 0;
+    mFormat = -1;
+}
+
+bool FrameBuffer::InitializeGLContext() {
+    Reset();
+    return CreateBuffers();
+}
+
+bool FrameBuffer::Init(int width, int height, GLenum format) {
+    if (mFrameBufferName == (GLuint)-1) {
+        if (!CreateBuffers()) {
+            return false;
+        }
+    }
+    glBindFramebuffer(GL_FRAMEBUFFER, mFrameBufferName);
+    glBindTexture(GL_TEXTURE_2D, mTextureName);
+
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 format,
+                 width,
+                 height,
+                 0,
+                 format,
+                 GL_UNSIGNED_BYTE,
+                 NULL);
+    if (!checkGlError("bind/teximage")) {
+        return false;
+    }
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    // This is necessary to work with user-generated frame buffers with
+    // dimensions that are NOT powers of 2.
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    // Attach texture to frame buffer.
+    glFramebufferTexture2D(GL_FRAMEBUFFER,
+                           GL_COLOR_ATTACHMENT0,
+                           GL_TEXTURE_2D,
+                           mTextureName,
+                           0);
+    checkFramebufferStatus("FrameBuffer.cpp");
+    checkGlError("framebuffertexture2d");
+
+    if (!checkGlError("texture setup")) {
+        return false;
+    }
+    mWidth = width;
+    mHeight = height;
+    mFormat = format;
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    return true;
+}
+
+bool FrameBuffer::CreateBuffers() {
+    glGenFramebuffers(1, &mFrameBufferName);
+    glGenTextures(1, &mTextureName);
+    if (!checkGlError("texture generation")) {
+        return false;
+    }
+    return true;
+}
+
+GLuint FrameBuffer::GetTextureName() const {
+    return mTextureName;
+}
+
+GLuint FrameBuffer::GetFrameBufferName() const {
+    return mFrameBufferName;
+}
+
+GLenum FrameBuffer::GetFormat() const {
+    return mFormat;
+}
+
+int FrameBuffer::GetWidth() const {
+    return mWidth;
+}
+
+int FrameBuffer::GetHeight() const {
+    return mHeight;
+}
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.h b/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.h
new file mode 100755
index 000000000..314b12622
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/FrameBuffer.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#define checkGlError(op)  checkGLErrorDetail(__FILE__, __LINE__, (op))
+
+extern bool checkGLErrorDetail(const char* file, int line, const char* op);
+extern void checkFramebufferStatus(const char* name);
+
+class FrameBuffer {
+  public:
+    FrameBuffer();
+    virtual ~FrameBuffer();
+
+    bool InitializeGLContext();
+    bool Init(int width, int height, GLenum format);
+    GLuint GetTextureName() const;
+    GLuint GetFrameBufferName() const;
+    GLenum GetFormat() const;
+
+    int GetWidth() const;
+    int GetHeight() const;
+
+ private:
+    void Reset();
+    bool CreateBuffers();
+    GLuint mFrameBufferName;
+    GLuint mTextureName;
+    int mWidth;
+    int mHeight;
+    GLenum mFormat;
+};
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.cpp b/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.cpp
new file mode 100755
index 000000000..b9938eb6b
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.cpp
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2011 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 "Renderer.h"
+
+#include "mosaic/Log.h"
+#define LOG_TAG "Renderer"
+
+#include <GLES2/gl2ext.h>
+
+Renderer::Renderer()
+      : mGlProgram(0),
+        mInputTextureName(-1),
+        mInputTextureWidth(0),
+        mInputTextureHeight(0),
+        mSurfaceWidth(0),
+        mSurfaceHeight(0)
+{
+    InitializeGLContext();
+}
+
+Renderer::~Renderer() {
+}
+
+GLuint Renderer::loadShader(GLenum shaderType, const char* pSource) {
+    GLuint shader = glCreateShader(shaderType);
+    if (shader) {
+        glShaderSource(shader, 1, &pSource, NULL);
+        glCompileShader(shader);
+        GLint compiled = 0;
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+        if (!compiled) {
+            GLint infoLen = 0;
+            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+            if (infoLen) {
+                char* buf = (char*) malloc(infoLen);
+                if (buf) {
+                    glGetShaderInfoLog(shader, infoLen, NULL, buf);
+                    LOGE("Could not compile shader %d:\n%s\n",
+                            shaderType, buf);
+                    free(buf);
+                }
+                glDeleteShader(shader);
+                shader = 0;
+            }
+        }
+    }
+    return shader;
+}
+
+GLuint Renderer::createProgram(const char* pVertexSource, const char* pFragmentSource)
+{
+    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
+    if (!vertexShader)
+    {
+        return 0;
+    }
+
+    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
+    if (!pixelShader)
+    {
+        return 0;
+    }
+
+    GLuint program = glCreateProgram();
+    if (program)
+    {
+        glAttachShader(program, vertexShader);
+        checkGlError("glAttachShader");
+        glAttachShader(program, pixelShader);
+        checkGlError("glAttachShader");
+
+        glLinkProgram(program);
+        GLint linkStatus = GL_FALSE;
+        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+
+        LOGI("Program Linked (%d)!", program);
+
+        if (linkStatus != GL_TRUE)
+        {
+            GLint bufLength = 0;
+            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
+            if (bufLength)
+            {
+                char* buf = (char*) malloc(bufLength);
+                if (buf)
+                {
+                    glGetProgramInfoLog(program, bufLength, NULL, buf);
+                    LOGE("Could not link program:\n%s\n", buf);
+                    free(buf);
+                }
+            }
+            glDeleteProgram(program);
+            program = 0;
+        }
+    }
+    return program;
+}
+
+// Set this renderer to use the default frame-buffer (screen) and
+// set the viewport size to be the given width and height (pixels).
+bool Renderer::SetupGraphics(int width, int height)
+{
+    bool succeeded = false;
+    do {
+        if (mGlProgram == 0)
+        {
+            if (!InitializeGLProgram())
+            {
+              break;
+            }
+        }
+        glUseProgram(mGlProgram);
+        if (!checkGlError("glUseProgram")) break;
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+        mFrameBuffer = NULL;
+        mSurfaceWidth = width;
+        mSurfaceHeight = height;
+
+        glViewport(0, 0, mSurfaceWidth, mSurfaceHeight);
+        if (!checkGlError("glViewport")) break;
+        succeeded = true;
+    } while (false);
+
+    return succeeded;
+}
+
+
+// Set this renderer to use the specified FBO and
+// set the viewport size to be the width and height of this FBO.
+bool Renderer::SetupGraphics(FrameBuffer* buffer)
+{
+    bool succeeded = false;
+    do {
+        if (mGlProgram == 0)
+        {
+            if (!InitializeGLProgram())
+            {
+              break;
+            }
+        }
+        glUseProgram(mGlProgram);
+        if (!checkGlError("glUseProgram")) break;
+
+        glBindFramebuffer(GL_FRAMEBUFFER, buffer->GetFrameBufferName());
+
+        mFrameBuffer = buffer;
+        mSurfaceWidth = mFrameBuffer->GetWidth();
+        mSurfaceHeight = mFrameBuffer->GetHeight();
+
+        glViewport(0, 0, mSurfaceWidth, mSurfaceHeight);
+        if (!checkGlError("glViewport")) break;
+        succeeded = true;
+    } while (false);
+
+    return succeeded;
+}
+
+bool Renderer::Clear(float r, float g, float b, float a)
+{
+    bool succeeded = false;
+    do {
+        bool rt = (mFrameBuffer == NULL)?
+                SetupGraphics(mSurfaceWidth, mSurfaceHeight) :
+                SetupGraphics(mFrameBuffer);
+
+        if(!rt)
+            break;
+
+        glClearColor(r, g, b, a);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        succeeded = true;
+    } while (false);
+    return succeeded;
+
+}
+
+void Renderer::InitializeGLContext()
+{
+    if(mFrameBuffer != NULL)
+    {
+        delete mFrameBuffer;
+        mFrameBuffer = NULL;
+    }
+
+    mInputTextureName = -1;
+    mInputTextureType = GL_TEXTURE_2D;
+    mGlProgram = 0;
+}
+
+int Renderer::GetTextureName()
+{
+    return mInputTextureName;
+}
+
+void Renderer::SetInputTextureName(GLuint textureName)
+{
+    mInputTextureName = textureName;
+}
+
+void Renderer::SetInputTextureType(GLenum textureType)
+{
+    mInputTextureType = textureType;
+}
+
+void Renderer::SetInputTextureDimensions(int width, int height)
+{
+    mInputTextureWidth = width;
+    mInputTextureHeight = height;
+}
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.h b/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.h
new file mode 100755
index 000000000..a43e8028e
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/Renderer.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include "FrameBuffer.h"
+
+#include <GLES2/gl2.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class Renderer {
+  public:
+    Renderer();
+    virtual ~Renderer();
+
+    // Initialize OpenGL resources
+    // @return true if successful
+    virtual bool InitializeGLProgram() = 0;
+
+    bool SetupGraphics(FrameBuffer* buffer);
+    bool SetupGraphics(int width, int height);
+
+    bool Clear(float r, float g, float b, float a);
+
+    int GetTextureName();
+    void SetInputTextureName(GLuint textureName);
+    void SetInputTextureDimensions(int width, int height);
+    void SetInputTextureType(GLenum textureType);
+
+    void InitializeGLContext();
+
+  protected:
+
+    GLuint loadShader(GLenum shaderType, const char* pSource);
+    GLuint createProgram(const char*, const char* );
+
+    int SurfaceWidth() const { return mSurfaceWidth; }
+    int SurfaceHeight() const { return mSurfaceHeight; }
+
+    // Source code for shaders.
+    virtual const char* VertexShaderSource() const = 0;
+    virtual const char* FragmentShaderSource() const = 0;
+
+    // Redefine this to use special texture types such as
+    // GL_TEXTURE_EXTERNAL_OES.
+    GLenum InputTextureType() const { return mInputTextureType; }
+
+    GLuint mGlProgram;
+    GLuint mInputTextureName;
+    GLenum mInputTextureType;
+    int mInputTextureWidth;
+    int mInputTextureHeight;
+
+    // Attribute locations
+    GLint  mScalingtransLoc;
+    GLint maPositionHandle;
+    GLint maTextureHandle;
+
+
+    int mSurfaceWidth;      // Width of target surface.
+    int mSurfaceHeight;     // Height of target surface.
+
+    FrameBuffer *mFrameBuffer;
+};
+
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.cpp b/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.cpp
new file mode 100755
index 000000000..88aac3626
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.cpp
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2011 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 "SurfaceTextureRenderer.h"
+
+#include <GLES2/gl2ext.h>
+const GLfloat g_vVertices[] = {
+    -1.f, -1.f, 0.0f, 1.0f,  // Position 0
+    0.0f,  0.0f,         // TexCoord 0
+     1.f, -1.f, 0.0f, 1.0f, // Position 1
+    1.0f,  0.0f,         // TexCoord 1
+    -1.f,  1.f, 0.0f, 1.0f, // Position 2
+    0.0f,  1.0f,         // TexCoord 2
+    1.f,   1.f, 0.0f, 1.0f, // Position 3
+    1.0f,  1.0f          // TexCoord 3
+};
+GLushort g_iIndices2[] = { 0, 1, 2, 3 };
+
+const int GL_TEXTURE_EXTERNAL_OES_ENUM = 0x8D65;
+
+const int VERTEX_STRIDE = 6 * sizeof(GLfloat);
+
+SurfaceTextureRenderer::SurfaceTextureRenderer() : Renderer() {
+    memset(mSTMatrix, 0.0, 16*sizeof(float));
+    mSTMatrix[0] = 1.0f;
+    mSTMatrix[5] = 1.0f;
+    mSTMatrix[10] = 1.0f;
+    mSTMatrix[15] = 1.0f;
+}
+
+SurfaceTextureRenderer::~SurfaceTextureRenderer() {
+}
+
+void SurfaceTextureRenderer::SetViewportMatrix(int w, int h, int W, int H)
+{
+    for(int i=0; i<16; i++)
+    {
+        mViewportMatrix[i] = 0.0f;
+    }
+
+    mViewportMatrix[0] = float(w)/float(W);
+    mViewportMatrix[5] = float(h)/float(H);
+    mViewportMatrix[10] = 1.0f;
+    mViewportMatrix[12] = -1.0f + float(w)/float(W);
+    mViewportMatrix[13] = -1.0f + float(h)/float(H);
+    mViewportMatrix[15] = 1.0f;
+}
+
+void SurfaceTextureRenderer::SetScalingMatrix(float xscale, float yscale)
+{
+    for(int i=0; i<16; i++)
+    {
+        mScalingMatrix[i] = 0.0f;
+    }
+
+    mScalingMatrix[0] = xscale;
+    mScalingMatrix[5] = yscale;
+    mScalingMatrix[10] = 1.0f;
+    mScalingMatrix[15] = 1.0f;
+}
+
+void SurfaceTextureRenderer::SetSTMatrix(float *stmat)
+{
+    memcpy(mSTMatrix, stmat, 16*sizeof(float));
+}
+
+
+bool SurfaceTextureRenderer::InitializeGLProgram()
+{
+    bool succeeded = false;
+    do {
+        GLuint glProgram;
+        glProgram = createProgram(VertexShaderSource(),
+                FragmentShaderSource());
+        if (!glProgram) {
+            break;
+        }
+
+        glUseProgram(glProgram);
+        if (!checkGlError("glUseProgram")) break;
+
+        maPositionHandle = glGetAttribLocation(glProgram, "aPosition");
+        checkGlError("glGetAttribLocation aPosition");
+        maTextureHandle = glGetAttribLocation(glProgram, "aTextureCoord");
+        checkGlError("glGetAttribLocation aTextureCoord");
+        muSTMatrixHandle = glGetUniformLocation(glProgram, "uSTMatrix");
+        checkGlError("glGetUniformLocation uSTMatrix");
+        mScalingtransLoc = glGetUniformLocation(glProgram, "u_scalingtrans");
+
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        mGlProgram = glProgram;
+        succeeded = true;
+    } while (false);
+
+    if (!succeeded && (mGlProgram != 0))
+    {
+        glDeleteProgram(mGlProgram);
+        checkGlError("glDeleteProgram");
+        mGlProgram = 0;
+    }
+    return succeeded;
+}
+
+bool SurfaceTextureRenderer::DrawTexture(GLfloat *affine)
+{
+    bool succeeded = false;
+    do {
+        bool rt = (mFrameBuffer == NULL)?
+            SetupGraphics(mSurfaceWidth, mSurfaceHeight) :
+            SetupGraphics(mFrameBuffer);
+
+        if(!rt)
+            break;
+
+        glDisable(GL_BLEND);
+
+        glActiveTexture(GL_TEXTURE0);
+        if (!checkGlError("glActiveTexture")) break;
+
+        const GLenum texture_type = InputTextureType();
+        glBindTexture(texture_type, mInputTextureName);
+        if (!checkGlError("glBindTexture")) break;
+
+        glUniformMatrix4fv(mScalingtransLoc, 1, GL_FALSE, mScalingMatrix);
+        glUniformMatrix4fv(muSTMatrixHandle, 1, GL_FALSE, mSTMatrix);
+
+        // Load the vertex position
+        glVertexAttribPointer(maPositionHandle, 4, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, g_vVertices);
+        glEnableVertexAttribArray(maPositionHandle);
+        // Load the texture coordinate
+        glVertexAttribPointer(maTextureHandle, 2, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, &g_vVertices[4]);
+        glEnableVertexAttribArray(maTextureHandle);
+
+        // And, finally, execute the GL draw command.
+        glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, g_iIndices2);
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        succeeded = true;
+    } while (false);
+    return succeeded;
+}
+
+const char* SurfaceTextureRenderer::VertexShaderSource() const
+{
+    static const char gVertexShader[] =
+        "uniform mat4 uSTMatrix;\n"
+        "uniform mat4 u_scalingtrans;  \n"
+        "attribute vec4 aPosition;\n"
+        "attribute vec4 aTextureCoord;\n"
+        "varying vec2 vTextureNormCoord;\n"
+        "void main() {\n"
+        "  gl_Position = u_scalingtrans * aPosition;\n"
+        "  vTextureNormCoord = (uSTMatrix * aTextureCoord).xy;\n"
+        "}\n";
+
+    return gVertexShader;
+}
+
+const char* SurfaceTextureRenderer::FragmentShaderSource() const
+{
+    static const char gFragmentShader[] =
+        "#extension GL_OES_EGL_image_external : require\n"
+        "precision mediump float;\n"
+        "varying vec2 vTextureNormCoord;\n"
+        "uniform samplerExternalOES sTexture;\n"
+        "void main() {\n"
+        "  gl_FragColor = texture2D(sTexture, vTextureNormCoord);\n"
+        "}\n";
+
+    return gFragmentShader;
+}
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.h b/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.h
new file mode 100755
index 000000000..ea2b81ade
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/SurfaceTextureRenderer.h
@@ -0,0 +1,44 @@
+#pragma once
+
+#include "FrameBuffer.h"
+#include "Renderer.h"
+
+#include <GLES2/gl2.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class SurfaceTextureRenderer: public Renderer {
+  public:
+    SurfaceTextureRenderer();
+    virtual ~SurfaceTextureRenderer();
+
+    // Initialize OpenGL resources
+    // @return true if successful
+    bool InitializeGLProgram();
+
+    bool DrawTexture(GLfloat *affine);
+
+    void SetViewportMatrix(int w, int h, int W, int H);
+    void SetScalingMatrix(float xscale, float yscale);
+    void SetSTMatrix(float *stmat);
+
+ private:
+    // Source code for shaders.
+    const char* VertexShaderSource() const;
+    const char* FragmentShaderSource() const;
+
+    // Attribute locations
+    GLint  mScalingtransLoc;
+    GLint muSTMatrixHandle;
+    GLint maPositionHandle;
+    GLint maTextureHandle;
+
+    GLfloat mViewportMatrix[16];
+    GLfloat mScalingMatrix[16];
+
+    GLfloat mSTMatrix[16];
+
+};
+
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.cpp b/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.cpp
new file mode 100755
index 000000000..af6779a3f
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2011 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 "WarpRenderer.h"
+
+#include <GLES2/gl2ext.h>
+
+const GLfloat g_vVertices[] = {
+    -1.f, 1.f, 0.0f, 1.0f,  // Position 0
+    0.0f,  1.0f,         // TexCoord 0
+     1.f, 1.f, 0.0f, 1.0f, // Position 1
+    1.0f,  1.0f,         // TexCoord 1
+    -1.f, -1.f, 0.0f, 1.0f, // Position 2
+    0.0f,  0.0f,         // TexCoord 2
+    1.f,  -1.f, 0.0f, 1.0f, // Position 3
+    1.0f,  0.0f          // TexCoord 3
+};
+
+const int VERTEX_STRIDE = 6 * sizeof(GLfloat);
+
+GLushort g_iIndices[] = { 0, 1, 2, 3 };
+
+WarpRenderer::WarpRenderer() : Renderer()
+{
+}
+
+WarpRenderer::~WarpRenderer() {
+}
+
+void WarpRenderer::SetViewportMatrix(int w, int h, int W, int H)
+{
+    for(int i=0; i<16; i++)
+    {
+        mViewportMatrix[i] = 0.0f;
+    }
+
+    mViewportMatrix[0] = float(w)/float(W);
+    mViewportMatrix[5] = float(h)/float(H);
+    mViewportMatrix[10] = 1.0f;
+    mViewportMatrix[12] = -1.0f + float(w)/float(W);
+    mViewportMatrix[13] = -1.0f + float(h)/float(H);
+    mViewportMatrix[15] = 1.0f;
+}
+
+void WarpRenderer::SetScalingMatrix(float xscale, float yscale)
+{
+    for(int i=0; i<16; i++)
+    {
+        mScalingMatrix[i] = 0.0f;
+    }
+
+    mScalingMatrix[0] = xscale;
+    mScalingMatrix[5] = yscale;
+    mScalingMatrix[10] = 1.0f;
+    mScalingMatrix[15] = 1.0f;
+}
+
+bool WarpRenderer::InitializeGLProgram()
+{
+    bool succeeded = false;
+    do {
+        GLuint glProgram;
+        glProgram = createProgram(VertexShaderSource(),
+                FragmentShaderSource());
+        if (!glProgram) {
+            break;
+        }
+
+        glUseProgram(glProgram);
+        if (!checkGlError("glUseProgram")) break;
+
+        // Get attribute locations
+        mPositionLoc     = glGetAttribLocation(glProgram, "a_position");
+        mAffinetransLoc  = glGetUniformLocation(glProgram, "u_affinetrans");
+        mViewporttransLoc = glGetUniformLocation(glProgram, "u_viewporttrans");
+        mScalingtransLoc = glGetUniformLocation(glProgram, "u_scalingtrans");
+        mTexCoordLoc     = glGetAttribLocation(glProgram, "a_texCoord");
+
+        // Get sampler location
+        mSamplerLoc      = glGetUniformLocation(glProgram, "s_texture");
+
+        mGlProgram = glProgram;
+        succeeded = true;
+    } while (false);
+
+    if (!succeeded && (mGlProgram != 0))
+    {
+        glDeleteProgram(mGlProgram);
+        checkGlError("glDeleteProgram");
+        mGlProgram = 0;
+    }
+    return succeeded;
+}
+
+bool WarpRenderer::DrawTexture(GLfloat *affine)
+{
+    bool succeeded = false;
+    do {
+        bool rt = (mFrameBuffer == NULL)?
+                SetupGraphics(mSurfaceWidth, mSurfaceHeight) :
+                SetupGraphics(mFrameBuffer);
+
+        if(!rt)
+            break;
+
+        glDisable(GL_BLEND);
+
+        glActiveTexture(GL_TEXTURE0);
+        if (!checkGlError("glActiveTexture")) break;
+
+        const GLenum texture_type = InputTextureType();
+        glBindTexture(texture_type, mInputTextureName);
+        if (!checkGlError("glBindTexture")) break;
+
+        // Set the sampler texture unit to 0
+        glUniform1i(mSamplerLoc, 0);
+
+        // Load the vertex position
+        glVertexAttribPointer(mPositionLoc, 4, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, g_vVertices);
+
+        // Load the texture coordinate
+        glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, &g_vVertices[4]);
+
+        glEnableVertexAttribArray(mPositionLoc);
+        glEnableVertexAttribArray(mTexCoordLoc);
+
+        // pass matrix information to the vertex shader
+        glUniformMatrix4fv(mAffinetransLoc, 1, GL_FALSE, affine);
+        glUniformMatrix4fv(mViewporttransLoc, 1, GL_FALSE, mViewportMatrix);
+        glUniformMatrix4fv(mScalingtransLoc, 1, GL_FALSE, mScalingMatrix);
+
+        // And, finally, execute the GL draw command.
+        glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, g_iIndices);
+
+        checkGlError("glDrawElements");
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        succeeded = true;
+    } while (false);
+    return succeeded;
+}
+
+const char* WarpRenderer::VertexShaderSource() const
+{
+    static const char gVertexShader[] =
+        "uniform mat4 u_affinetrans;  \n"
+        "uniform mat4 u_viewporttrans;  \n"
+        "uniform mat4 u_scalingtrans;  \n"
+        "attribute vec4 a_position;   \n"
+        "attribute vec2 a_texCoord;   \n"
+        "varying vec2 v_texCoord;     \n"
+        "void main()                  \n"
+        "{                            \n"
+        "   gl_Position = u_scalingtrans * u_viewporttrans * u_affinetrans * a_position; \n"
+        "   v_texCoord = a_texCoord;  \n"
+        "}                            \n";
+
+    return gVertexShader;
+}
+
+const char* WarpRenderer::FragmentShaderSource() const
+{
+    static const char gFragmentShader[] =
+        "precision mediump float;                            \n"
+        "varying vec2 v_texCoord;                            \n"
+        "uniform sampler2D s_texture;                        \n"
+        "void main()                                         \n"
+        "{                                                   \n"
+        "  vec4 color;                                       \n"
+        "  color = texture2D(s_texture, v_texCoord);       \n"
+        "  gl_FragColor = color;                             \n"
+        "}                                                   \n";
+
+    return gFragmentShader;
+}
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.h b/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.h
new file mode 100755
index 000000000..8e9a694ec
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/WarpRenderer.h
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "FrameBuffer.h"
+#include "Renderer.h"
+
+#include <GLES2/gl2.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class WarpRenderer: public Renderer {
+  public:
+    WarpRenderer();
+    virtual ~WarpRenderer();
+
+    // Initialize OpenGL resources
+    // @return true if successful
+    bool InitializeGLProgram();
+
+    void SetViewportMatrix(int w, int h, int W, int H);
+    void SetScalingMatrix(float xscale, float yscale);
+
+    bool DrawTexture(GLfloat *affine);
+
+ private:
+    // Source code for shaders.
+    const char* VertexShaderSource() const;
+    const char* FragmentShaderSource() const;
+
+    GLuint mTexHandle;                  // Handle to s_texture.
+    GLuint mTexCoordHandle;             // Handle to a_texCoord.
+    GLuint mTriangleVerticesHandle;     // Handle to vPosition.
+
+    // Attribute locations
+    GLint  mPositionLoc;
+    GLint  mAffinetransLoc;
+    GLint  mViewporttransLoc;
+    GLint  mScalingtransLoc;
+    GLint  mTexCoordLoc;
+
+    GLfloat mViewportMatrix[16];
+    GLfloat mScalingMatrix[16];
+
+    // Sampler location
+    GLint mSamplerLoc;
+};
+
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.cpp b/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.cpp
new file mode 100755
index 000000000..f7dcf6f61
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.cpp
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2011 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 "YVURenderer.h"
+
+#include <GLES2/gl2ext.h>
+
+const GLfloat g_vVertices[] = {
+    -1.f, 1.f, 0.0f, 1.0f,  // Position 0
+    0.0f,  1.0f,         // TexCoord 0
+     1.f, 1.f, 0.0f, 1.0f, // Position 1
+    1.0f,  1.0f,         // TexCoord 1
+    -1.f, -1.f, 0.0f, 1.0f, // Position 2
+    0.0f,  0.0f,         // TexCoord 2
+    1.f,  -1.f, 0.0f, 1.0f, // Position 3
+    1.0f,  0.0f          // TexCoord 3
+};
+
+const int VERTEX_STRIDE = 6 * sizeof(GLfloat);
+
+GLushort g_iIndices3[] = { 0, 1, 2, 3 };
+
+YVURenderer::YVURenderer() : Renderer()
+                   {
+}
+
+YVURenderer::~YVURenderer() {
+}
+
+bool YVURenderer::InitializeGLProgram()
+{
+    bool succeeded = false;
+    do {
+        GLuint glProgram;
+        glProgram = createProgram(VertexShaderSource(),
+                FragmentShaderSource());
+        if (!glProgram) {
+            break;
+        }
+
+        glUseProgram(glProgram);
+        if (!checkGlError("glUseProgram")) break;
+
+        // Get attribute locations
+        mPositionLoc     = glGetAttribLocation(glProgram, "a_Position");
+        mTexCoordLoc     = glGetAttribLocation(glProgram, "a_texCoord");
+
+        // Get sampler location
+        mSamplerLoc      = glGetUniformLocation(glProgram, "s_texture");
+
+        mGlProgram = glProgram;
+        succeeded = true;
+    } while (false);
+
+    if (!succeeded && (mGlProgram != 0))
+    {
+        glDeleteProgram(mGlProgram);
+        checkGlError("glDeleteProgram");
+        mGlProgram = 0;
+    }
+    return succeeded;
+}
+
+bool YVURenderer::DrawTexture()
+{
+    bool succeeded = false;
+    do {
+        bool rt = (mFrameBuffer == NULL)?
+                SetupGraphics(mSurfaceWidth, mSurfaceHeight) :
+                SetupGraphics(mFrameBuffer);
+
+        if(!rt)
+            break;
+
+        glDisable(GL_BLEND);
+
+        glActiveTexture(GL_TEXTURE0);
+        if (!checkGlError("glActiveTexture")) break;
+
+        const GLenum texture_type = InputTextureType();
+        glBindTexture(texture_type, mInputTextureName);
+        if (!checkGlError("glBindTexture")) break;
+
+        // Set the sampler texture unit to 0
+        glUniform1i(mSamplerLoc, 0);
+
+        // Load the vertex position
+        glVertexAttribPointer(mPositionLoc, 4, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, g_vVertices);
+
+        // Load the texture coordinate
+        glVertexAttribPointer(mTexCoordLoc, 2, GL_FLOAT,
+                GL_FALSE, VERTEX_STRIDE, &g_vVertices[4]);
+
+        glEnableVertexAttribArray(mPositionLoc);
+        glEnableVertexAttribArray(mTexCoordLoc);
+
+        // And, finally, execute the GL draw command.
+        glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, g_iIndices3);
+
+        checkGlError("glDrawElements");
+
+        glBindFramebuffer(GL_FRAMEBUFFER, 0);
+        succeeded = true;
+    } while (false);
+    return succeeded;
+}
+
+const char* YVURenderer::VertexShaderSource() const
+{
+    // All this really does is copy the coordinates into
+    // variables for the fragment shader to pick up.
+    static const char gVertexShader[] =
+        "attribute vec4 a_Position;\n"
+        "attribute vec2 a_texCoord;\n"
+        "varying vec2 v_texCoord;\n"
+        "void main() {\n"
+        "  gl_Position = a_Position;\n"
+        "  v_texCoord = a_texCoord;\n"
+        "}\n";
+
+    return gVertexShader;
+}
+
+const char* YVURenderer::FragmentShaderSource() const
+{
+    static const char gFragmentShader[] =
+        "precision mediump float;\n"
+        "uniform sampler2D s_texture;\n"
+        "const vec4 coeff_y = vec4(0.257, 0.594, 0.098, 0.063);\n"
+        "const vec4 coeff_v = vec4(0.439, -0.368, -0.071, 0.500);\n"
+        "const vec4 coeff_u = vec4(-0.148, -0.291, 0.439, 0.500);\n"
+        "varying vec2 v_texCoord;\n"
+        "void main() {\n"
+        "  vec4 p;\n"
+        "  p = texture2D(s_texture, v_texCoord);\n"
+        "  gl_FragColor[0] = dot(p, coeff_y);\n"
+        "  p = texture2D(s_texture, v_texCoord);\n"
+        "  gl_FragColor[1] = dot(p, coeff_v);\n"
+        "  p = texture2D(s_texture, v_texCoord);\n"
+        "  gl_FragColor[2] = dot(p, coeff_u);\n"
+        "  p = texture2D(s_texture, v_texCoord);\n"
+        "  gl_FragColor[3] = dot(p, coeff_y);\n"
+        "}\n";
+
+    return gFragmentShader;
+}
diff --git a/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.h b/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.h
new file mode 100755
index 000000000..d14a4b990
--- /dev/null
+++ b/jni_mosaic/feature_mos/src/mosaic_renderer/YVURenderer.h
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "FrameBuffer.h"
+#include "Renderer.h"
+
+#include <GLES2/gl2.h>
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+class YVURenderer: public Renderer {
+  public:
+    YVURenderer();
+    virtual ~YVURenderer();
+
+    // Initialize OpenGL resources
+    // @return true if successful
+    bool InitializeGLProgram();
+
+    bool DrawTexture();
+
+ private:
+    // Source code for shaders.
+    const char* VertexShaderSource() const;
+    const char* FragmentShaderSource() const;
+
+    // Attribute locations
+    GLint  mPositionLoc;
+    GLint  mTexCoordLoc;
+
+    // Sampler location
+    GLint mSamplerLoc;
+};
+