/*

     File: Imaging.c

 Abstract: 

  Version: 1.3

 Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple

 Inc. ("Apple") in consideration of your agreement to the following

 terms, and your use, installation, modification or redistribution of

 this Apple software constitutes acceptance of these terms.  If you do

 not agree with these terms, please do not use, install, modify or

 redistribute this Apple software.

 In consideration of your agreement to abide by the following terms, and

 subject to these terms, Apple grants you a personal, non-exclusive

 license, under Apple's copyrights in this original Apple software (the

 "Apple Software"), to use, reproduce, modify and redistribute the Apple

 Software, with or without modifications, in source and/or binary forms;

 provided that if you redistribute the Apple Software in its entirety and

 without modifications, you must retain this notice and the following

 text and disclaimers in all such redistributions of the Apple Software.

 Neither the name, trademarks, service marks or logos of Apple Inc. may

 be used to endorse or promote products derived from the Apple Software

 without specific prior written permission from Apple.  Except as

 expressly stated in this notice, no other rights or licenses, express or

 implied, are granted by Apple herein, including but not limited to any

 patent rights that may be infringed by your derivative works or by other

 works in which the Apple Software may be incorporated.

 The Apple Software is provided by Apple on an "AS IS" basis.  APPLE

 MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION

 THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS

 FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND

 OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.

 IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL

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

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

 INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,

 MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED

 AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),

 STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE

 POSSIBILITY OF SUCH DAMAGE.

 Copyright (C) 2014 Apple Inc. All Rights Reserved.

 */

//

//  Simple 2D image processing using OpenGL ES1.1

//

//  The key concepts here are described at

//  http://www.graficaobscura.com/interp/index.html

//  http://www.graficaobscura.com/matrix/index.html

//

//  The only tricky part is how to process inputs outside of [0..1] in the fixed-function pipeline.

//  Simple algebra provides a solution for extrapolation to  [0..2]:

//

//  lerp = Src*t + Dst*(1-t), where (Src, Dst, t) [0..1]

//  if t = 2, then

//  lerp = Src*(2t) + Dst*(1-2t)

//       = 2(Src*t  + Dst*(0.5-t))

//

//  Now, the inputs (Src, Dst, t) are inside [0..1], and the final multiply by 2 can be done with

//  TexEnv. Extrapolation by values larger than 2 can be handled by iteration.

//

//  With that solved, the rest of the problem is simply mapping math operations to TexEnv state.

//  Equations that are too complex to fit in the available texture units have to be broken apart

//  into multiple passes. In that case, a scratch FBO is used to store intermediate results.

//

//  This sample demonstrates mapping simple filters like Brightness, Contrast, Saturation,

//  Hue rotation, and Sharpness to TexEnv. Additional filters such as Convolution, Invert,

//  Sepia, etc can be similarly implemented.

//

//  For details on the available TexEnv COMBINE operators, see the ES1.1 specification, or

//  the equivalent desktop GL extensions:

//  http://www.opengl.org/registry/specs/ARB/texture_env_combine.txt

//  http://www.opengl.org/registry/specs/ARB/texture_env_dot3.txt

//

//  Note: the PowerVR MBX does not support all possible COMBINE state permutations. A debug utility

//  is used here to validate the TexEnv state against known hardware errata.

//

#include <sys/time.h>

#include <math.h>

#include <stdio.h>

#include <string.h>

#include "Texture.h"

// Information about the GL renderer

RendererInfo renderer;

// Framebuffer objects

GLuint SystemFBO, DegenFBO, ScratchFBO;

// Images used for filtering

Image Input, Half, Degen, Scratch;

// Geometry for a fullscreen quad

V2fT2f fullquad[4] = {

    { 0, 0, 0, 0 },

    { 1, 0, 1, 0 },

    { 0, 1, 0, 1 },

    { 1, 1, 1, 1 },

};

// Geometry for a fullscreen quad, flipping texcoords upside down

V2fT2f flipquad[4] = {

    { 0, 0, 0, 1 },

    { 1, 0, 1, 1 },

    { 0, 1, 0, 0 },

    { 1, 1, 1, 0 },

};

// The following filters change the TexEnv state in various ways.

// To reduce state change overhead, the convention adopted here is

// that each filter is responsible for setting up common state, and

// restoring uncommon state to the default.

//

// Common state for this application is defined as:

// GL_TEXTURE_ENV_MODE

// GL_COMBINE_RGB, GL_COMBINE_ALPHA

// GL_SRC[012]_RGB, GL_SRC[012]_ALPHA

// GL_TEXTURE_ENV_COLOR

//

// Uncommon state for this application is defined as:

// GL_OPERAND[012]_RGB, GL_OPERAND[012]_ALPHA

// GL_RGB_SCALE, GL_ALPHA_SCALE

//

// For all filters, the texture's alpha channel is passed through unchanged.

// If you need the alpha channel for compositing purposes, be mindful of

// premultiplication that may have been performed by your image loader.

static void brightness(V2fT2f *quad, float t)   // t [0..2]

{

    // One pass using one unit:

    // brightness < 1.0 biases towards black

    // brightness > 1.0 biases towards white

    //

    // Note: this additive definition of brightness is

    // different than what matrix-based adjustment produces,

    // where the brightness factor is a scalar multiply.

    //

    // A +/-1 bias will produce the full range from black to white,

    // whereas the scalar multiply can never reach full white.

    glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    if (t > 1.0f)

    {

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_ADD);

        glColor4f(t-1, t-1, t-1, t-1);

    }

    else

    {

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_SUBTRACT);

        glColor4f(1-t, 1-t, 1-t, 1-t);

    }

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

}

static void contrast(V2fT2f *quad, float t) // t [0..2]

{

    GLfloat h = t*0.5f;

    // One pass using two units:

    // contrast < 1.0 interpolates towards grey

    // contrast > 1.0 extrapolates away from grey

    //

    // Here, the general extrapolation 2*(Src*t + Dst*(0.5-t))

    // can be simplified, because Dst is a constant (grey).

    // That results in: 2*(Src*t + 0.25 - 0.5*t)

    //

    // Unit0 calculates Src*t

    // Unit1 adds 0.25 - 0.5*t

    // Since 0.5*t will be in [0..0.5], it can be biased up and the addition done in signed space.

    glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_MODULATE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

    glActiveTexture(GL_TEXTURE1);

    glEnable(GL_TEXTURE_2D);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_ADD_SIGNED);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_PREVIOUS);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB,     GL_SRC_ALPHA);

    glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,        2);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PREVIOUS);

    glColor4f(h, h, h, 0.75 - 0.5 * h); // 2x extrapolation

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Restore state

    glDisable(GL_TEXTURE_2D);

    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB,     GL_SRC_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,        1);

    glActiveTexture(GL_TEXTURE0);

}

static void greyscale(V2fT2f *quad, float t)    // t = 1 for standard perceptual weighting

{

    GLfloat lerp[4] = { 1.0, 1.0, 1.0, 0.5 };

    GLfloat avrg[4] = { .667, .667, .667, 0.5 };    // average

    GLfloat prcp[4] = { .646, .794, .557, 0.5 };    // perceptual NTSC

    GLfloat dot3[4] = { prcp[0]*t+avrg[0]*(1-t), prcp[1]*t+avrg[1]*(1-t), prcp[2]*t+avrg[2]*(1-t), 0.5 };

    // One pass using two units:

    // Unit 0 scales and biases into [0.5..1.0]

    // Unit 1 dot products with perceptual weights

    glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_CONSTANT);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_CONSTANT);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

    glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR, lerp);

    // Note: we prefer to dot product with primary color, because

    // the constant color is stored in limited precision on MBX

    glActiveTexture(GL_TEXTURE1);

    glEnable(GL_TEXTURE_2D);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_DOT3_RGB);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_PREVIOUS);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PREVIOUS);

    glColor4f(dot3[0], dot3[1], dot3[2], dot3[3]);

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Restore state

    glDisable(GL_TEXTURE_2D);

    glActiveTexture(GL_TEXTURE0);

}

static void extrapolate(V2fT2f *quad, float t)  // t [0..2]

{

    int i;

    // t < 1.0 interpolates towards degenerate image

    // t > 1.0 extrapolates away from degenerate image

    //

    // Unlike the simpler filters, extrapolation from an arbitrary image

    // requires two passes to implement 2*(Src*t + Dst(0.5-t)).

    //

    // The extrapolation works in both directions, but when t <= 1.0f,

    // the interpolation can be done in a single pass, which is faster.

    //

    // The degenerate image to extrapolate from is generated

    // outside of this function. It can be cached for a static image,

    // or regenerated every frame for dynamic content.

    if (t <= 1.0f)

    {

        // One pass using two units:

        // Unit 0 samples the input image

        // Unit 1 interpolates towards the degenerate image

        glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

        glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_REPLACE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

        glClientActiveTexture(GL_TEXTURE1);

        glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

        glEnableClientState(GL_TEXTURE_COORD_ARRAY);

        glActiveTexture(GL_TEXTURE1);

        glBindTexture(GL_TEXTURE_2D, Degen.texID);

        glEnable(GL_TEXTURE_2D);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PREVIOUS);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_PRIMARY_COLOR);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PREVIOUS);

        glColor4f(0.0, 0.0, 0.0, 1.0f-t);

        validateTexEnv();

        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        // Restore state

        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

        glClientActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, Half.texID);

        glDisable(GL_TEXTURE_2D);

        glActiveTexture(GL_TEXTURE0);

    }

    else

    {

        GLint fbo, tex, viewport[4], blend;

        float h = t*0.5f;

        V2fT2f flipquad[4];

        for (i = 0; i < 4; i++)

        {

            flipquad[i].s = quad[i].s;

            flipquad[i].t = quad[3-i].t;

        }

        // Push state

        glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, &fbo);

        glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);

        glGetIntegerv(GL_VIEWPORT, viewport);

        glGetIntegerv(GL_BLEND, &blend);

        glBindFramebufferOES(GL_FRAMEBUFFER_OES, ScratchFBO);

        glViewport(0, 0, Scratch.wide*Scratch.s, Scratch.high*Scratch.t);

        glClear(GL_COLOR_BUFFER_BIT);

        glDisable(GL_BLEND);

        glBindTexture(GL_TEXTURE_2D, Degen.texID);

        glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

        glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &flipquad[0].s);

        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_MODULATE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

        // Note: we prefer to sample 0.5 from a texture, because

        // the constant color is stored in limited precision on MBX

        glActiveTexture(GL_TEXTURE1);

        glEnable(GL_TEXTURE_2D);

        glBindTexture(GL_TEXTURE_2D, Half.texID);

        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

        if (h < 0.5)

        {

            float bias = 0.5-h;

            // First pass: 0.5 + degenerate * bias;

            glColor4f(bias, bias, bias, 1.0);

            glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD);

        }

        else

        {

            float bias = h-0.5;

            // First pass: 0.5 - degenerate * bias;

            glColor4f(bias, bias, bias, 1.0);

            glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_SUBTRACT);

        }

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PREVIOUS);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PREVIOUS);

        validateTexEnv();

        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        // Second pass: 2.0 * (Src * h + first - 0.5)

        glBindFramebufferOES(GL_FRAMEBUFFER_OES, fbo);

        glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);

        if (blend) glEnable(GL_BLEND);

        glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

        glClientActiveTexture(GL_TEXTURE1);

        glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

        glEnableClientState(GL_TEXTURE_COORD_ARRAY);

        glBindTexture(GL_TEXTURE_2D, Scratch.texID);

        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,    GL_PREVIOUS);

        glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,    GL_TEXTURE);

        glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,   2);

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, tex);

        glColor4f(h, h, h, 1.0);

        validateTexEnv();

        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        // Restore state

        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

        glClientActiveTexture(GL_TEXTURE0);

        glActiveTexture(GL_TEXTURE1);

        glTexEnvi(GL_TEXTURE_ENV, GL_RGB_SCALE,   1);

        glBindTexture(GL_TEXTURE_2D, Half.texID);

        glDisable(GL_TEXTURE_2D);

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, tex);

    }

}

// Matrix Utilities for Hue rotation

static void matrixmult(float a[4][4], float b[4][4], float c[4][4])

{

    int x, y;

    float temp[4][4];

    for(y=0; y<4; y++)

        for(x=0; x<4; x++)

            temp[y][x] = b[y][0] * a[0][x] + b[y][1] * a[1][x] + b[y][2] * a[2][x] + b[y][3] * a[3][x];

    for(y=0; y<4; y++)

        for(x=0; x<4; x++)

            c[y][x] = temp[y][x];

}

static void xrotatemat(float mat[4][4], float rs, float rc)

{

    mat[0][0] = 1.0;

    mat[0][1] = 0.0;

    mat[0][2] = 0.0;

    mat[0][3] = 0.0;

    mat[1][0] = 0.0;

    mat[1][1] = rc;

    mat[1][2] = rs;

    mat[1][3] = 0.0;

    mat[2][0] = 0.0;

    mat[2][1] = -rs;

    mat[2][2] = rc;

    mat[2][3] = 0.0;

    mat[3][0] = 0.0;

    mat[3][1] = 0.0;

    mat[3][2] = 0.0;

    mat[3][3] = 1.0;

 }

static void yrotatemat(float mat[4][4], float rs, float rc)

{

    mat[0][0] = rc;

    mat[0][1] = 0.0;

    mat[0][2] = -rs;

    mat[0][3] = 0.0;

    mat[1][0] = 0.0;

    mat[1][1] = 1.0;

    mat[1][2] = 0.0;

    mat[1][3] = 0.0;

    mat[2][0] = rs;

    mat[2][1] = 0.0;

    mat[2][2] = rc;

    mat[2][3] = 0.0;

    mat[3][0] = 0.0;

    mat[3][1] = 0.0;

    mat[3][2] = 0.0;

    mat[3][3] = 1.0;

}

static void zrotatemat(float mat[4][4], float rs, float rc)

{

    mat[0][0] = rc;

    mat[0][1] = rs;

    mat[0][2] = 0.0;

    mat[0][3] = 0.0;

    mat[1][0] = -rs;

    mat[1][1] = rc;

    mat[1][2] = 0.0;

    mat[1][3] = 0.0;

    mat[2][0] = 0.0;

    mat[2][1] = 0.0;

    mat[2][2] = 1.0;

    mat[2][3] = 0.0;

    mat[3][0] = 0.0;

    mat[3][1] = 0.0;

    mat[3][2] = 0.0;

    mat[3][3] = 1.0;

}

static void huematrix(GLfloat mat[4][4], float angle)

{

    float mag, rot[4][4];

    float xrs, xrc;

    float yrs, yrc;

    float zrs, zrc;

    // Rotate the grey vector into positive Z

    mag = sqrt(2.0);

    xrs = 1.0/mag;

    xrc = 1.0/mag;

    xrotatemat(mat, xrs, xrc);

    mag = sqrt(3.0);

    yrs = -1.0/mag;

    yrc = sqrt(2.0)/mag;

    yrotatemat(rot, yrs, yrc);

    matrixmult(rot, mat, mat);

    // Rotate the hue

    zrs = sin(angle);

    zrc = cos(angle);

    zrotatemat(rot, zrs, zrc);

    matrixmult(rot, mat, mat);

    // Rotate the grey vector back into place

    yrotatemat(rot, -yrs, yrc);

    matrixmult(rot,  mat, mat);

    xrotatemat(rot, -xrs, xrc);

    matrixmult(rot,  mat, mat);

}

static void hue(V2fT2f *quad, float t)  // t [0..2] == [-180..180] degrees

{

    GLfloat mat[4][4];

    GLfloat lerp[4] = { 1.0, 1.0, 1.0, 0.5 };

    // Color matrix rotation can be expressed as three dot products

    // Each DOT3 needs inputs prescaled to [0.5..1.0]

    // Construct 3x3 matrix

    huematrix(mat, (t-1.0)*M_PI);

    // Prescale matrix weights

    mat[0][0] *= 0.5; mat[0][0] += 0.5;

    mat[0][1] *= 0.5; mat[0][1] += 0.5;

    mat[0][2] *= 0.5; mat[0][2] += 0.5;

    mat[0][3] = 1.0;

    mat[1][0] *= 0.5; mat[1][0] += 0.5;

    mat[1][1] *= 0.5; mat[1][1] += 0.5;

    mat[1][2] *= 0.5; mat[1][2] += 0.5;

    mat[1][3] = 1.0;

    mat[2][0] *= 0.5; mat[2][0] += 0.5;

    mat[2][1] *= 0.5; mat[2][1] += 0.5;

    mat[2][2] *= 0.5; mat[2][2] += 0.5;

    mat[2][3] = 1.0;

    glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_CONSTANT);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_CONSTANT);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_TEXTURE);

    glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR, lerp);

    // Note: we prefer to dot product with primary color, because

    // the constant color is stored in limited precision on MBX

    glActiveTexture(GL_TEXTURE1);

    glEnable(GL_TEXTURE_2D);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_DOT3_RGB);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_PREVIOUS);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PREVIOUS);

    // Red channel

    glColorMask(1,0,0,0);

    glColor4f(mat[0][0], mat[0][1], mat[0][2], mat[0][3]);

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Green channel

    glColorMask(0,1,0,0);

    glColor4f(mat[1][0], mat[1][1], mat[1][2], mat[1][3]);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Blue channel

    glColorMask(0,0,1,0);

    glColor4f(mat[2][0], mat[2][1], mat[2][2], mat[2][3]);

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Restore state

    glDisable(GL_TEXTURE_2D);

    glActiveTexture(GL_TEXTURE0);

    glColorMask(1,1,1,1);

}

static void blur(V2fT2f *quad, float t) // t = 1

{

    GLint tex;

    V2fT2f tmpquad[4];

    float offw = t / Input.wide;

    float offh = t / Input.high;

    int i;

    glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);

    // Three pass small blur, using rotated pattern to sample 17 texels:

    //

    // .\/.. 

    // ./\\/ 

    // \/X/\   rotated samples filter across texel corners

    // /\\/. 

    // ../\. 

    // Pass one: center nearest sample

    glVertexPointer  (2, GL_FLOAT, sizeof(V2fT2f), &quad[0].x);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &quad[0].s);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    glColor4f(1.0/5, 1.0/5, 1.0/5, 1.0);

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Pass two: accumulate two rotated linear samples

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    glEnable(GL_BLEND);

    glBlendFunc(GL_SRC_ALPHA, GL_ONE);

    for (i = 0; i < 4; i++)

    {

        tmpquad[i].x = quad[i].s + 1.5 * offw;

        tmpquad[i].y = quad[i].t + 0.5 * offh;

        tmpquad[i].s = quad[i].s - 1.5 * offw;

        tmpquad[i].t = quad[i].t - 0.5 * offh;

    }

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].x);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

    glActiveTexture(GL_TEXTURE1);

    glEnable(GL_TEXTURE_2D);

    glClientActiveTexture(GL_TEXTURE1);

    glTexCoordPointer(2, GL_FLOAT, sizeof(V2fT2f), &tmpquad[0].s);

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glBindTexture(GL_TEXTURE_2D, tex);

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,      GL_INTERPOLATE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB,         GL_TEXTURE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB,         GL_PREVIOUS);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC2_RGB,         GL_PRIMARY_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,     GL_SRC_COLOR);

    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA,    GL_REPLACE);

    glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA,       GL_PRIMARY_COLOR);

    glColor4f(0.5, 0.5, 0.5, 2.0/5);

    validateTexEnv();

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Pass three: accumulate two rotated linear samples

    for (i = 0; i < 4; i++)

    {

        tmpquad[i].x = quad[i].s - 0.5 * offw;

        tmpquad[i].y = quad[i].t + 1.5 * offh;

        tmpquad[i].s = quad[i].s + 0.5 * offw;

        tmpquad[i].t = quad[i].t - 1.5 * offh;

    }

    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

    // Restore state

    glDisableClientState(GL_TEXTURE_COORD_ARRAY);

    glClientActiveTexture(GL_TEXTURE0);

    glBindTexture(GL_TEXTURE_2D, Half.texID);

    glDisable(GL_TEXTURE_2D);

    glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB,     GL_SRC_ALPHA);

    glActiveTexture(GL_TEXTURE0);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glDisable(GL_BLEND);

}

void drawGL(int wide, int high, float val, int mode)

{

    static int prevmode = -1;

    typedef void (*procfunc)(V2fT2f *, float);

    typedef struct {

        procfunc func;

        procfunc degen;

    } Filter;

    const Filter filter[] = {

        { brightness             },

        { contrast               },

        { extrapolate, greyscale },

        { hue                    },

        { extrapolate, blur      }, // The blur could be exaggerated by downsampling to half size

    };

    #define NUM_FILTERS (sizeof(filter)/sizeof(filter[0]))

    rt_assert(mode < NUM_FILTERS);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    glOrthof(0, wide, 0, high, -1, 1);

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    glScalef(wide, high, 1);

    glBindTexture(GL_TEXTURE_2D, Input.texID);

    if (prevmode != mode)

    {

        prevmode = mode;

        if (filter[mode].degen)

        {

            // Cache degenerate image, potentially a different size than the system framebuffer

            glBindFramebufferOES(GL_FRAMEBUFFER_OES, DegenFBO);

            glViewport(0, 0, Degen.wide*Degen.s, Degen.high*Degen.t);

            // The entire framebuffer won't be written to if the image was padded to POT.

            // In this case, clearing is a performance win on TBDR systems.

            glClear(GL_COLOR_BUFFER_BIT);

            glDisable(GL_BLEND);

            filter[mode].degen(fullquad, 1.0);

            glBindFramebufferOES(GL_FRAMEBUFFER_OES, SystemFBO);

        }

    }

    // Render filtered image to system framebuffer

    glViewport(0, 0, wide, high);

    filter[mode].func(flipquad, val);

    glCheckError();

}

void initGL(void)

{

    int i;

    // Query renderer capabilities that affect this app's rendering paths

    renderer.extension[APPLE_texture_2D_limited_npot] =

        (0 != strstr((char *)glGetString(GL_EXTENSIONS), "GL_APPLE_texture_2D_limited_npot"));

    renderer.extension[IMG_texture_format_BGRA8888] =

        (0 != strstr((char *)glGetString(GL_EXTENSIONS), "GL_IMG_texture_format_BGRA8888"));

    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &renderer.maxTextureSize);

    // Constant state for the lifetime of the app-- position and unit0 are always used

    glEnableClientState(GL_VERTEX_ARRAY);

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glEnable(GL_TEXTURE_2D);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    // Load image into texture

    loadTexture("Image.png", &Input, &renderer);

    // Modify quad texcoords to match (possibly padded) image

    for (i = 0; i < 4; i++)

    {

        fullquad[i].s *= Input.s;

        fullquad[i].t *= Input.t;

        flipquad[i].s *= Input.s;

        flipquad[i].t *= Input.t;

    }

    // Create 1x1 for default constant texture

    // To enable a texture unit, a valid texture has to be bound even if the combine modes do not access it

    GLubyte half[4] = { 0x80, 0x80, 0x80, 0x80 };

    glActiveTexture(GL_TEXTURE1);

    glGenTextures(1, &Half.texID);

    Half.wide = Half.high = 1;

    Half.s = Half.t = 1.0;

    glBindTexture(GL_TEXTURE_2D, Half.texID);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, half);

    glActiveTexture(GL_TEXTURE0);

    // Remember the FBO being used for the display framebuffer

    glGetIntegerv(GL_FRAMEBUFFER_BINDING_OES, (GLint *)&SystemFBO);

    // Create scratch textures and FBOs

    glGenTextures(1, &Degen.texID);

    Degen.wide = Input.wide;

    Degen.high = Input.high;

    Degen.s = Input.s;

    Degen.t = Input.t;

    glBindTexture(GL_TEXTURE_2D, Degen.texID);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Degen.wide, Degen.high, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

    glGenFramebuffersOES(1, &DegenFBO);

    glBindFramebufferOES(GL_FRAMEBUFFER_OES, DegenFBO);

    glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, Degen.texID, 0);

    rt_assert(GL_FRAMEBUFFER_COMPLETE_OES == glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES));

    glGenTextures(1, &Scratch.texID);

    Scratch.wide = Input.wide;

    Scratch.high = Input.high;

    Scratch.s = Input.s;

    Scratch.t = Input.t;

    glBindTexture(GL_TEXTURE_2D, Scratch.texID);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);

    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Scratch.wide, Scratch.high, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

    glGenFramebuffersOES(1, &ScratchFBO);

    glBindFramebufferOES(GL_FRAMEBUFFER_OES, ScratchFBO);

    glFramebufferTexture2DOES(GL_FRAMEBUFFER_OES, GL_COLOR_ATTACHMENT0_OES, GL_TEXTURE_2D, Scratch.texID, 0);

    rt_assert(GL_FRAMEBUFFER_COMPLETE_OES == glCheckFramebufferStatusOES(GL_FRAMEBUFFER_OES));

    glBindFramebufferOES(GL_FRAMEBUFFER_OES, SystemFBO);

    glCheckError();

}