#define USE_TEXTUREMAPPERGL 1

    , m_restoreNeeded(true)

    , m_fboId(0)

    m_blitter = TextureBlitter::create();

#include <surfaces/TextureBlitter.h>

#include "TextureMapper.h"

#include "TextureMapperGL.h"

    RefPtr<TextureBlitter> m_blitter;

    OwnPtr<TextureMapperGL> m_texBlitter;

    bool m_restoreNeeded :1;

    IntRect m_rect;

    GLuint m_fboId;

    TextureMapperGL::Flags m_flags;

/*

 * 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,

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

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

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

#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;

#else

static PFNGLBINDVERTEXARRAYPROC m_glBindVertexArray = 0;

static PFNGLDELETEVERTEXARRAYSPROC m_glDeleteVertexArrays = 0;

static PFNGLGENVERTEXARRAYSPROC m_glGenVertexArrays = 0;

#endif

#if USE(OPENGL_ES_2)

static void initializeGLBindings()

{

    static bool bindingsInitialized = false;

    if (bindingsInitialized)

        return;

    bindingsInitialized = true;

    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"));

    }

}

#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);

    }

    ~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);

    }

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;

};

class ScopedStateSaver

{

    WTF_MAKE_NONCOPYABLE(ScopedStateSaver);

public:

    ScopedStateSaver()

    {

        ::glGetIntegerv(GL_ACTIVE_TEXTURE, &m_boundTexUnit);

        ::glGetIntegerv(GL_CURRENT_PROGRAM, &m_boundProgram);

        ::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);

        }

        ::glActiveTexture(GL_TEXTURE0);

    }

    ~ScopedStateSaver()

    {

        if (m_boundProgram && !glIsProgram(m_boundProgram))

            m_boundProgram = 0;

        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);

        }

        ::glUseProgram(m_boundProgram);

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

        ::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;

    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_currentVertexHandle(0)

    , m_shaderProgram(0)

    , m_vertexBuffer(0)

    , m_fboId(0)

{

}

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_vertexBuffer) {

        ::glDeleteBuffers(1, &m_vertexBuffer);

        m_vertexBuffer = 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(m_vertexAttr);

    ::glEnableVertexAttribArray(m_textureCoordinatesAttr);

    ::glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);

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

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

}

void TextureBlitter::enableVertexArray()

{

    if (m_currentVertexHandle)

        m_glBindVertexArray(m_currentVertexHandle);

    else

        bindArrayBuffer();

}

void TextureBlitter::disableVertexArray()

{

    if (m_currentVertexHandle)

        return;

    ::glDisableVertexAttribArray(m_vertexAttr);

    ::glDisableVertexAttribArray(m_textureCoordinatesAttr);

}

bool TextureBlitter::linkProgram(const GLuint programId)

{

    ::glLinkProgram(programId);

    GLint linkStatus = 0;

    ::glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);

    if (!linkStatus)

        return false;

    return true;

}

void TextureBlitter::initializeVBO()

{

    if (m_glGenVertexArrays) {

        m_currentVertexHandle = m_vertexHandle;

        if (m_currentVertexHandle)

            return;

    } else if (m_vertexBuffer)

        return;

    // bind buffers.

    ::glGenBuffers(1, &m_vertexBuffer);

    ::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();

        m_vertexHandle = vertexHandle;

        m_currentVertexHandle = vertexHandle;

    }

}

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 || (m_shaderProgram && !glIsProgram(m_shaderProgram))) {

        LOG_ERROR("Failed to create program.");

        ::glDeleteShader(vertexShader);

        ::glDeleteShader(fragmentShader);

        return false;

    }

    ::glAttachShader(m_shaderProgram, vertexShader);

    ::glAttachShader(m_shaderProgram, fragmentShader);

    bool linked = linkProgram(m_shaderProgram);

    ::glDeleteShader(vertexShader);

    ::glDeleteShader(fragmentShader);

    if (!linked) {

        clear();

        return false;

    }

    GLint currentProgram;

    ::glGetIntegerv(GL_CURRENT_PROGRAM, &currentProgram);

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

    m_vertexAttr = ::glGetAttribLocation(m_shaderProgram, "m_vPosition");

    m_textureCoordinatesAttr = ::glGetAttribLocation(m_shaderProgram, "m_texCoord");

    ::glUseProgram(m_shaderProgram);

    ::glUniform1i(samplerLocation, 0);

    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    ::glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    ::glUseProgram(currentProgram);

    return true;

}

#if USE(OPENGL_ES_2)

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

{

    initializeGLBindings();

      if (!initializeProgram())

          return false;

      ScopedStateSaver stateSaver;

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

      ::glBindFramebuffer(GL_FRAMEBUFFER, targetFboId);

      ::glClear(GL_COLOR_BUFFER_BIT);

      ::glUseProgram(m_shaderProgram);

      ::glBindBuffer(GL_ARRAY_BUFFER, 0);

      ::glBindTexture(GL_TEXTURE_2D, sourceTexture);

      ::glColorMask(true, true, true, true);

      initializeVBO();

      enableVertexArray();

      ::glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

      ::glFlush();

      disableVertexArray();

      return true;

}

#else

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

{

   if (!m_fboId)

        glGenFramebuffers(1, &m_fboId);

    glBindFramebuffer(GL_READ_FRAMEBUFFER, m_fboId);

    glBindTexture(GL_TEXTURE_2D, sourceTexture);

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

    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, targetFboId);

    glBlitFramebuffer(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);

    return true;

}

#endif

}

#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 drawTexture(const GLuint, const GLuint, const IntRect&, const IntRect&, 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_currentVertexHandle;

    GLuint m_shaderProgram;

    GLuint m_vertexBuffer;

    GLuint m_fboId;

    GLuint m_vertexAttr;

    GLuint m_textureCoordinatesAttr;

    GLuint m_textureUniform;

};

}

#endif

#endif