m_blitter = TextureBlitter::create();

#include <texmap/TextureBlitter.h>

    RefPtr<TextureBlitter> m_blitter;

    GLPlatformSurface::destroy();

    GLPlatformSurface::destroy();

/*

 * Copyright (C) 2012 Intel Corporation. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#include "TextureBlitter.h"

#if USE(ACCELERATED_COMPOSITING)

#include "TextureMapperGL.h"

#include <opengl/GLPlatformContext.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

//#define SHADER_DEBUG

TextureBlitter* TextureBlitter::m_staticTextureBlitter = 0;

static const GLfloat vertices[] = { 1.0f, 1.0f, 0.0f, 1.0f,

                                    -1.0f, 1.0f, 0.0f, 1.0f,

                                    1.0f, -1.0f, 0.0f, 1.0f,

                                    -1.0f, -1.0f, 0.0f, 1.0f,

                                    -1.0f, -1.0f, 0.0f, 1.0f,  // Flip coordinates.

                                    1.0f, -1.0f, 0.0f, 1.0f,

                                    -1.0f, 1.0f, 0.0f, 1.0f,

                                    1.0f, 1.0f, 0.0f, 1.0f,

                                    0.0f, 1.0f,1.0f, 1.0f,   // Tex coordinates.

                                    0.0f, 0.0f,1.0f, 0.0f};

static const GLushort indexVertices[] = { 0, 1, 2, 3};

static const int vertexIndexSize = sizeof(indexVertices)/sizeof(indexVertices[0]);

static const int FLIPOFFSET = sizeof(float) * 4 * 4;

static const int TEXCOORDOFFSET = FLIPOFFSET * 2;

static const int VERTEXATTRIB = 0;

static const int TEXCOORDATTRIB = 1;

#if USE(OPENGL_ES_2)

static PFNGLBINDVERTEXARRAYOESPROC m_glBindVertexArray = 0;

static PFNGLDELETEVERTEXARRAYSOESPROC m_glDeleteVertexArrays = 0;

static PFNGLGENVERTEXARRAYSOESPROC m_glGenVertexArrays = 0;

static PFNGLISVERTEXARRAYOESPROC m_glIsVertexArray = 0;

static PFNGLBLITFRAMEBUFFERANGLEPROC m_frameBufferBlit = 0;

#else

static PFNGLBINDVERTEXARRAYPROC m_glBindVertexArray = 0;

static PFNGLDELETEVERTEXARRAYSPROC m_glDeleteVertexArrays = 0;

static PFNGLGENVERTEXARRAYSPROC m_glGenVertexArrays = 0;

static PFNGLISVERTEXARRAYPROC m_glIsVertexArray = 0;

static PFNGLBLITFRAMEBUFFEREXTPROC m_frameBufferBlit = 0;

#endif

static PFNGLSAMPLERPARAMETERIPROC m_glSamplerParameteri = 0;

static PFNGLGENSAMPLERSPROC m_glGenSamplers = 0;

static PFNGLBINDSAMPLERPROC m_glBindSampler = 0;

static void initializeGLBindings()

{

    static bool bindingsInitialized = false;

    if (bindingsInitialized)

        return;

    bindingsInitialized = true;

#if USE(OPENGL_ES_2) && USE(EGL)

    if (GLPlatformContext::supportsGLExtension("GL_ANGLE_framebuffer_blit"))

        m_frameBufferBlit = reinterpret_cast<PFNGLBLITFRAMEBUFFERANGLEPROC>(eglGetProcAddress("glBlitFramebufferANGLE"));

    if (m_frameBufferBlit)

        return;

    if (GLPlatformContext::supportsGLExtension("GL_OES_vertex_array_object")) {

        m_glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAYOESPROC>(eglGetProcAddress("glBindVertexArrayOES"));

        m_glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYSOESPROC>(eglGetProcAddress("glGenVertexArraysOES"));

        m_glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOESPROC>(eglGetProcAddress("glDeleteVertexArraysOES"));

        m_glIsVertexArray = reinterpret_cast<PFNGLISVERTEXARRAYOESPROC>(eglGetProcAddress("glIsVertexArrayOES"));

    }

#else

    bool supportsBlitExtension = GLPlatformContext::supportsGLExtension("GL_EXT_framebuffer_blit");

    bool supportsVAO = GLPlatformContext::supportsGLExtension("GL_ARB_vertex_array_object");

    // This ext is only available with desktop GL and is not supported by GLES2.0, support for the same has been added in GLES3.0.

    bool supportsSamplerObjects = GLPlatformContext::supportsGLExtension("GL_ARB_sampler_objects");

#if USE(GLX)

    if (supportsBlitExtension)

        m_frameBufferBlit = reinterpret_cast<PFNGLBLITFRAMEBUFFEREXTPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glBlitFramebufferEXT")));

    if (m_frameBufferBlit)

        return;

    if (supportsVAO) {

        m_glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAYPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glBindVertexArray")));

        m_glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYSPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glGenVertexArrays")));

        m_glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYSPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glDeleteVertexArrays")));

        m_glIsVertexArray = reinterpret_cast<PFNGLISVERTEXARRAYPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glIsVertexArray")));

    }

    if (supportsSamplerObjects) {

        m_glSamplerParameteri = reinterpret_cast<PFNGLSAMPLERPARAMETERIPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glSamplerParameteri")));

        m_glGenSamplers = reinterpret_cast<PFNGLGENSAMPLERSPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glGenSamplers")));

        m_glBindSampler = reinterpret_cast<PFNGLBINDSAMPLERPROC>(glXGetProcAddress(reinterpret_cast<const GLubyte*>("glBindSampler")));

    }

#elif USE(EGL)

    if (supportsBlitExtension)

        m_frameBufferBlit = reinterpret_cast<PFNGLBLITFRAMEBUFFEREXTPROC>(eglGetProcAddress("glBlitFramebufferEXT"));

    if (m_frameBufferBlit)

        return;

    if (supportsVAO) {

        m_glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAYPROC>(eglGetProcAddress("glBindVertexArray"));

        m_glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYSPROC>(eglGetProcAddress("glGenVertexArrays"));

        m_glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYSPROC>(eglGetProcAddress("glDeleteVertexArrays"));

        m_glIsVertexArray = reinterpret_cast<PFNGLISVERTEXARRAYPROC>(eglGetProcAddress("glIsVertexArray"));

    }

    if (supportsSamplerObjects) {

        m_glSamplerParameteri = reinterpret_cast<PFNGLSAMPLERPARAMETERIPROC>(eglGetProcAddress("glSamplerParameteri"));

        m_glGenSamplers = reinterpret_cast<PFNGLGENSAMPLERSPROC>(eglGetProcAddress("glGenSamplers"));

        m_glBindSampler = reinterpret_cast<PFNGLBINDSAMPLERPROC>(eglGetProcAddress("glBindSampler"));

    }

#endif

#endif

}

class ScopedToggleGLState

{

    WTF_MAKE_NONCOPYABLE(ScopedToggleGLState);

public:

    ScopedToggleGLState()

    {

        m_enableBlend = toggleState(GL_BLEND);

        m_enableCullFace = toggleState(GL_CULL_FACE);

        m_enableDepthTest = toggleState(GL_DEPTH_TEST);

        m_enableDitherTest = toggleState(GL_DITHER);

        m_enablePolygonOffsetFill = toggleState(GL_POLYGON_OFFSET_FILL);

        m_enableSampleAlpha = toggleState(GL_SAMPLE_ALPHA_TO_COVERAGE);

        m_enableSampleCoverage = toggleState(GL_SAMPLE_COVERAGE);

        m_enableStencilTest = toggleState(GL_STENCIL_TEST);

        m_enableScissorTest = toggleState(GL_SCISSOR_TEST);

    }

    ~ScopedToggleGLState()

    {

        if (m_enableBlend)

            ::glEnable(GL_BLEND);

        if (m_enableCullFace)

            ::glEnable(GL_CULL_FACE);

        if (m_enableDepthTest)

            ::glEnable(GL_DEPTH_TEST);

        if (m_enableDitherTest)

            ::glEnable(GL_DITHER);

        if (m_enablePolygonOffsetFill)

            ::glEnable(GL_POLYGON_OFFSET_FILL);

        if (m_enableSampleAlpha)

            ::glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);

        if (m_enableSampleCoverage)

            ::glEnable(GL_SAMPLE_COVERAGE);

        if (m_enableStencilTest)

            ::glEnable(GL_STENCIL_TEST);

        if (m_enableScissorTest)

            ::glEnable(GL_SCISSOR_TEST);

    }

private:

    bool toggleState(const GLenum capability)

    {

        bool enabled = ::glIsEnabled(capability);

        if (!enabled)

            return false;

        ::glDisable(capability);

        return true;

    }

    bool m_enableBlend :1;

    bool m_enableCullFace :1;

    bool m_enableDepthTest :1;

    bool m_enableDitherTest :1;

    bool m_enablePolygonOffsetFill :1;

    bool m_enableSampleAlpha :1;

    bool m_enableSampleCoverage :1;

    bool m_enableStencilTest :1;

    bool m_enableScissorTest :1;

};

class ScopedProgramBinding

{

    WTF_MAKE_NONCOPYABLE(ScopedProgramBinding);

public:

    ScopedProgramBinding(GLuint programId)

    {

        ::glGetIntegerv(GL_ACTIVE_TEXTURE, &m_boundTexUnit);

        ::glGetIntegerv(GL_CURRENT_PROGRAM, &m_boundProgram);

        ::glGetBooleanv(GL_COLOR_WRITEMASK, m_colorMask);

        ::glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        ::glGetIntegerv(GL_VIEWPORT, &m_currentViewport[0]);

        if (m_glGenVertexArrays)

#if USE(OPENGL_ES_2)

            ::glGetIntegerv(GL_VERTEX_ARRAY_BINDING_OES, &m_currentVertexArrayBinding);

#else

            ::glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &m_currentVertexArrayBinding);

#endif

        else {

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &m_attribEnabled);

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_SIZE, &m_attribSize);

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_STRIDE, &m_attribStride);

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_TYPE, &m_attribType);

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &m_attribNormalized);

            ::glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &m_attribBufferBinding);

            ::glGetVertexAttribPointerv(0, GL_VERTEX_ATTRIB_ARRAY_POINTER, &m_attribPointer);

            ::glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &m_currentArrayBufferBinding);

            ::glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &m_currentElementryArrayBufferBinding);

        }

        ::glUseProgram(programId);

        ::glActiveTexture(GL_TEXTURE0);

        if (!(m_glGenSamplers && m_glSamplerParameteri)) {

            ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

            ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

            ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

            ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        }

    }

    ~ScopedProgramBinding()

    {

        ::glViewport(m_currentViewport[0], m_currentViewport[1], m_currentViewport[2], m_currentViewport[3]);

        ::glColorMask(m_colorMask[0], m_colorMask[1], m_colorMask[2], m_colorMask[3]);

        if (m_glGenVertexArrays)

            m_glBindVertexArray(m_currentVertexArrayBinding);

        else {

            if (m_attribEnabled)

                ::glEnableVertexAttribArray(0);

            ::glBindBuffer(GL_ARRAY_BUFFER, m_attribBufferBinding);

            ::glVertexAttribPointer(0, m_attribSize, m_attribType, m_attribNormalized, m_attribStride, m_attribPointer);

            ::glBindBuffer(GL_ARRAY_BUFFER, m_currentArrayBufferBinding);

            ::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_currentElementryArrayBufferBinding);

        }

        ::glUseProgram(m_boundProgram);

        ::glActiveTexture(m_boundTexUnit);

    }

private:

    GLint m_boundTexUnit;

    GLint m_boundProgram;

    GLint m_currentArrayBufferBinding;

    GLint m_attribEnabled;

    GLint m_attribSize;

    GLint m_attribStride;

    GLint m_attribType;

    GLint m_attribNormalized;

    GLint m_attribBufferBinding;

    GLint m_currentViewport[4];

    GLint m_currentVertexArrayBinding;

    GLint m_currentElementryArrayBufferBinding;

    GLboolean m_colorMask[4];

    ScopedToggleGLState m_scopedToggleState;

    void* m_attribPointer;

};

#define STRINGIFY(...) #__VA_ARGS__

const char* GetShaderSource(GLenum type) {

    switch (type) {

    case GL_VERTEX_SHADER:

        return STRINGIFY(

                    attribute vec4 m_vPosition;

                attribute vec2 m_texCoord;

        varying vec2 m_vTexCoord;

        void main(void) {

            gl_Position = m_vPosition;

            m_vTexCoord = m_texCoord;

        });

    case GL_FRAGMENT_SHADER:

        return STRINGIFY(

                    uniform sampler2D u_texSampler;

                varying vec2 m_vTexCoord;

        void main(void) {

            gl_FragColor = texture2D(u_texSampler, m_vTexCoord.st);

        });

    default:

        return 0;

    }

}

TextureBlitter::TextureBlitter()

    : m_vertexHandle(0)

    , m_flipVertexHandle(0)

    , m_currentVertexHandle(0)

    , m_shaderProgram(0)

    , m_vertexBuffer(0)

    , m_indexBuffer(0)

    , m_fboId(0)

    , m_flip(false)

{

}

TextureBlitter::~TextureBlitter()

{

    clear();

}

void TextureBlitter::clear()

{

    if (m_shaderProgram) {

        ::glDeleteProgram(m_shaderProgram);

        m_shaderProgram = 0;

    }

    if (m_fboId) {

        ::glDeleteFramebuffers(1, &m_fboId);

        m_fboId = 0;

    }

    if (m_vertexHandle && m_glDeleteVertexArrays) {

        m_glDeleteVertexArrays(1, &m_vertexHandle);

        m_vertexHandle = 0;

    }

    if (m_flipVertexHandle && m_glDeleteVertexArrays) {

        m_glDeleteVertexArrays(1, &m_flipVertexHandle);

        m_flipVertexHandle = 0;

    }

    if (m_vertexBuffer) {

        ::glDeleteBuffers(1, &m_vertexBuffer);

        m_vertexBuffer = 0;

    }

    if (m_indexBuffer) {

        ::glDeleteBuffers(1, &m_indexBuffer);

        m_indexBuffer = 0;

    }

}

GLuint TextureBlitter::loadShader(GLenum type, const GLchar *shaderSrc)

{

    GLuint shader;

    GLint compiled;

    shader = glCreateShader(type);

    if (!shader) {

        LOG_ERROR("Failed to create shader.");

        return 0;

    }

    glShaderSource(shader, 1, &shaderSrc, 0);

    glCompileShader(shader);

    glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);

    if (!compiled) {

        glDeleteShader(shader);

        LOG_ERROR("Failed to compile shader.");

        return 0;

    }

    return shader;

}

void TextureBlitter::bindArrayBuffer()

{

    glEnableVertexAttribArray(VERTEXATTRIB);

    glEnableVertexAttribArray(TEXCOORDATTRIB);

    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);

    if (m_flip)

        glVertexAttribPointer(VERTEXATTRIB, 4, GL_FLOAT, GL_FALSE, 0, (void*)FLIPOFFSET);

    else

        glVertexAttribPointer(VERTEXATTRIB, 4, GL_FLOAT, GL_FALSE, 0, (void*)NULL);

    glVertexAttribPointer(TEXCOORDATTRIB, 2, GL_FLOAT, GL_FALSE, 0, (void*)TEXCOORDOFFSET);

}

void TextureBlitter::enableVertexArray()

{

    if (m_currentVertexHandle)

        m_glBindVertexArray(m_currentVertexHandle);

    else {

        bindArrayBuffer();

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);

    }

}

void TextureBlitter::disableVertexArray()

{

    if (m_currentVertexHandle)

        return;

    glDisableVertexAttribArray(VERTEXATTRIB);

    glDisableVertexAttribArray(TEXCOORDATTRIB);

}

bool TextureBlitter::linkProgram(const GLuint programId)

{

    glLinkProgram(programId);

#ifdef SHADER_DEBUG

    GLint linkStatus = 0;

    glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);

    if (!linkStatus) {

        LOG_ERROR("Failed to link program.");

        GLint infoLogLength(0);

        glGetProgramiv(m_shaderProgram, GL_INFO_LOG_LENGTH, &infoLogLength );

        if (infoLogLength > 0) {

            char* log = (char*) malloc(infoLogLength);

            if (log == NULL) {

                LOG_ERROR("Failed to allocate memory to write ProgamLog.");

                return false;

            }

            int written = 0;

            glGetProgramInfoLog(m_shaderProgram, infoLogLength, &written, log);

            LOG_ERROR("ProgramLog:(%s).\n", log);

        }

        return false;

    }

#endif

    return true;

}

void TextureBlitter::initializeVBO()

{

    if (m_glGenVertexArrays) {

        m_currentVertexHandle = m_flip ? m_flipVertexHandle : m_vertexHandle;

        if (m_currentVertexHandle)

            return;

    } else if (m_vertexBuffer)

        return;

    // bind buffers.

    GLuint temp[2];

    glGenBuffers(2, temp);

    m_vertexBuffer = temp[0];

    m_indexBuffer = temp[1];

    glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);

    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,

                 GL_STATIC_DRAW);

    // Create and set-up the vertex array object

    if (m_glGenVertexArrays && m_glBindVertexArray) {

        GLuint vertexHandle;

        m_glGenVertexArrays(1, &vertexHandle);

        m_glBindVertexArray(vertexHandle);

        bindArrayBuffer();

        if (m_flip)

            m_flipVertexHandle = vertexHandle;

        else

            m_vertexHandle = vertexHandle;

        m_currentVertexHandle = vertexHandle;

    }

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer);

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexVertices), indexVertices,

                 GL_STATIC_DRAW);

}

bool TextureBlitter::initializeProgram()

{

    if (m_shaderProgram)

        return true;

    // create shader.

    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, GetShaderSource(GL_VERTEX_SHADER));

    if (!vertexShader)

        return false;

    GLuint fragmentShader = loadShader(GL_FRAGMENT_SHADER, GetShaderSource(GL_FRAGMENT_SHADER));

    if (!fragmentShader) {

        glDeleteShader(vertexShader);

        return false;

    }

    m_shaderProgram = glCreateProgram();

    if (!m_shaderProgram) {

        LOG_ERROR("Failed to create program.");

        glDeleteShader(vertexShader);

        glDeleteShader(fragmentShader);

        return false;

    }

    glAttachShader(m_shaderProgram, vertexShader);

    glAttachShader(m_shaderProgram, fragmentShader);

    glBindAttribLocation(m_shaderProgram, VERTEXATTRIB, "m_vPosition");

    glBindAttribLocation(m_shaderProgram, TEXCOORDATTRIB, "m_texCoord");

    bool linked = linkProgram(m_shaderProgram);

    glDeleteShader(vertexShader);

    glDeleteShader(fragmentShader);

    if (!linked) {

        clear();

        return false;

    }

    GLuint samplerLocation = glGetUniformLocation(m_shaderProgram, "u_texSampler");

    GLuint sampler = 0;

    // Create and initialize sampler object. This would help us seperate the texture and sampler state.

    if (m_glGenSamplers && m_glSamplerParameteri) {

        m_glGenSamplers(1 , &sampler);

        m_glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

        m_glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        m_glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

        m_glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    }

    GLint boundProgram;

    ::glGetIntegerv(GL_CURRENT_PROGRAM, &boundProgram);

    glUseProgram(m_shaderProgram);

    glUniform1i(samplerLocation, 0);

    if (m_glBindSampler)

        m_glBindSampler(0 , sampler);

#ifdef SHADER_DEBUG

    glValidateProgram(m_shaderProgram);

    GLint status;

    glGetProgramiv(m_shaderProgram, GL_VALIDATE_STATUS, &status);

    if (GL_TRUE != status) {

        LOG_ERROR("Program validation failed.\n");

        return false;

    }

#endif

    glUniform1i(samplerLocation, 0);

    glUseProgram(boundProgram);

    return true;

}

bool TextureBlitter::drawTexture(const GLuint sourceTexture, const GLuint targetFboId, const IntRect& srcRect, const IntRect& destRect, bool flip, GLenum filter)

{

    initializeGLBindings();

    if (m_frameBufferBlit) {

        bool enableScissorTest = ::glIsEnabled(GL_SCISSOR_TEST);

        if (enableScissorTest)

            ::glDisable(GL_SCISSOR_TEST);

        if (!m_fboId)

            glGenFramebuffers(1, &m_fboId);

        ::glBindFramebuffer(Extensions3D::READ_FRAMEBUFFER, m_fboId);

        ::glBindTexture(GL_TEXTURE_2D, sourceTexture);

        ::glFramebufferTexture2D(Extensions3D::READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, sourceTexture, 0);

        ::glBindFramebuffer(Extensions3D::DRAW_FRAMEBUFFER, targetFboId);

        if (flip)

            m_frameBufferBlit(srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), destRect.x(), destRect.x() + destRect.height(), destRect.y() + destRect.width(), destRect.y(), GL_COLOR_BUFFER_BIT, filter);

        else

            m_frameBufferBlit(srcRect.x(), srcRect.y(), srcRect.width(), srcRect.height(), destRect.x(), destRect.y(), destRect.width(), destRect.height(), GL_COLOR_BUFFER_BIT, filter);

        ::glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);

        if (enableScissorTest)

            ::glEnable(GL_SCISSOR_TEST);

        return true;

    }

    if (!initializeProgram())

        return false;

    ScopedProgramBinding program(m_shaderProgram);

    m_flip = flip;

    initializeVBO();

    ::glBindFramebuffer(GL_FRAMEBUFFER, targetFboId);

    ::glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);

    ::glBindTexture(GL_TEXTURE_2D, sourceTexture);

    ::glViewport (destRect.x(), destRect.y(), destRect.width(), destRect.height());

    enableVertexArray();

    ::glDrawElements(GL_TRIANGLE_STRIP, vertexIndexSize, GL_UNSIGNED_SHORT, 0);

    disableVertexArray();

    return true;

}

bool TextureBlitter::copyTexture(const GLuint source, const GLuint destination, bool flip)

{

    initializeGLBindings();

    if (!initializeProgram())

        return false;

    if (!m_fboId)

        glGenFramebuffers(1, &m_fboId);

    ScopedProgramBinding program(m_shaderProgram);

    m_flip = flip;

    initializeVBO();

    ::glBindFramebuffer(GL_FRAMEBUFFER, m_fboId);

    ::glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);

    ::glBindTexture(GL_TEXTURE_2D, source);

    ::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, destination, 0);

    enableVertexArray();

    ::glDrawElements(GL_TRIANGLE_STRIP, vertexIndexSize, GL_UNSIGNED_SHORT, 0);

    disableVertexArray();

    ::glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);

    return true;

}

}

#endif

/*

 * Copyright (C) 2012 Intel Corporation. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef TextureBlitter_h

#define TextureBlitter_h

#if USE(ACCELERATED_COMPOSITING)

#include <opengl/GLDefs.h>

#include <wtf/Noncopyable.h>

#include <wtf/PassRefPtr.h>

#include <wtf/RefCounted.h>

namespace WebCore {

class TextureBlitter : public WTF::RefCountedBase {

    WTF_MAKE_NONCOPYABLE(TextureBlitter);

public:

    static PassRefPtr<TextureBlitter> create()

    {

        if (!m_staticTextureBlitter)

            m_staticTextureBlitter = new TextureBlitter();

        else

            m_staticTextureBlitter->ref();

        return adoptRef(m_staticTextureBlitter);

    }

    void deref()

    {

        if (derefBase()) {

            m_staticTextureBlitter = 0;

            delete this;

        }

    }

    TextureBlitter();

    ~TextureBlitter();

    bool copyTexture(const GLuint, const GLuint, bool = false);

    bool drawTexture(const GLuint, const GLuint, const IntRect&, const IntRect&, bool = false, GLenum = GraphicsContext3D::NEAREST);

    void clear();

private:

    static TextureBlitter* m_staticTextureBlitter;

    bool initializeProgram();

    void enableVertexArray();

    void disableVertexArray();

    void bindArrayBuffer();

    void initializeVBO();

    bool linkProgram(const GLuint programId);

    GLuint loadShader(GLenum type, const GLchar *shaderSrc);

    GLuint m_vertexHandle;

    GLuint m_flipVertexHandle;

    GLuint m_currentVertexHandle;

    GLuint m_shaderProgram;

    GLuint m_vertexBuffer;

    GLuint m_indexBuffer;

    GLuint m_fboId;

    bool m_flip :1;

};

}

#endif

#endif