SampleCode/GLImageProcessing/Imaging.c at master · FaustStudio/SampleCode

815 lines (705 loc) · 27.5 KB
     File: Imaging.c
 Abstract: 
  Version: 1.2
 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) 2010 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);
		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]
	// 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);
		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);
			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])
	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;
	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;
	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)
	// 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();
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

Imaging.c

Latest commit

History

Imaging.c

File metadata and controls
