/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include "common.h"

#include "hgl.h"

#include "context.h"

#include "half.h"

#include "util.h"

#include "degl.h"

DGLTexture* DGLTexture_create(GLuint name, DGLTextureType type, GLint num_levels)

{

	DGLTexture* texture = malloc(sizeof(DGLTexture));

	if(texture == NULL)

	{

		return NULL;

	}

	texture->obj.name = name;

	texture->obj.next = NULL;

	texture->type = type;

	{

		int face;

		for(face = 0; face < 6; face++)

		{

			texture->num_levels[face] = 0;

			texture->levels[face] = malloc(num_levels * sizeof(DGLTextureLevel));

			if(texture->levels[face] == NULL)

			{

				while(face--)

				{

					free(texture->levels[face]);

				}

				free(texture);

				return NULL;

			}

			{

				int level;

				for(level = 0; level < num_levels; level++)

				{

					texture->levels[face][level].specified = GL_FALSE;

					texture->levels[face][level].format = 0;

					texture->levels[face][level].width = 0;

					texture->levels[face][level].height = 0;

					texture->levels[face][level].bound_surface = NULL;

				}

			}

			texture->egl_image[face] = NULL;

		}

	}

	return texture;

}

static GLenum dglFaceToTarget(DGLTexture* texture, int face)

{

	DGLES2_ASSERT(texture != NULL);

	{

		switch(face)

		{

			case 0:

				if(texture->type == DGLES2_TEXTURE_2D)

				{

					return GL_TEXTURE_2D;

				}

				else

				{

					DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

					return GL_TEXTURE_CUBE_MAP_POSITIVE_X;

				}

			case 1:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;

			case 2:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;

			case 3:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;

			case 4:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;

			case 5:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;

			default:

				DGLES2_ASSERT(GL_FALSE);

				return -1;

		}

	}

}

void DGLTexture_destroy(DGLTexture *texture)

{

	DGLES2_ASSERT(texture != NULL);

	{

		int face;

		for(face = 0; face < 6; face++)

		{

			DGLES2_ASSERT(texture->levels[face] != NULL);

			free(texture->levels[face]);

			texture->levels[face] = NULL;

			if(texture->egl_image[face] != NULL)

			{

				deglUnregisterImageTarget(texture->egl_image[face], dglFaceToTarget(texture, face), texture->obj.name);

				texture->egl_image[face] = NULL;

			}

		}

	}

	free(texture);

}

GLboolean DGLTexture_isComplete(const DGLTexture* texture)

{

	DGLES2_ASSERT(texture != NULL);

	{

		int num_faces = 6 ? texture->type == DGLES2_TEXTURE_CUBE_MAP : 1;

		int face;

		for(face = 0; face < num_faces; face++)

		{

			if(texture->num_levels[face] < 1)

			{

				return GL_FALSE;

			}

			else

			{

				int i;

				const DGLTextureLevel* level_zero;

				int width;

				int height;

				level_zero = &texture->levels[face][0];

				width = level_zero->width;

				height = level_zero->height;

				if(width <= 0 || height <= 0)

				{

					return GL_FALSE;

				}

				for(i = 1; i < texture->num_levels[face]; i++)

				{

					const DGLTextureLevel* level = &texture->levels[face][i];

					if(width > 1) width /= 2;

					if(height > 1) height /= 2;

					if(level->format != level_zero->format ||

					   level->width != width ||

					   level->height != height ||

					   level->width == 0 ||

					   level->height == 0)

					{

						return GL_FALSE;

					}

				}

			}

		}

		return GL_TRUE;

	}

}

GLboolean DGLTexture_hasLevelZero(const DGLTexture* texture)

{

	DGLES2_ASSERT(texture != NULL);

	{

		int num_faces = 6 ? texture->type == DGLES2_TEXTURE_CUBE_MAP : 1;

		int face;

		for(face = 0; face < num_faces; face++)

		{

			if(texture->num_levels[face] <= 0 || !texture->levels[face][0].specified)

			{

				return GL_FALSE;

			}

		}

		return GL_TRUE;

	}

}

GLboolean DGLTexture_hasLevelsOtherThanZero(const DGLTexture* texture)

{

	DGLES2_ASSERT(texture != NULL);

	{

		int num_faces = 6 ? texture->type == DGLES2_TEXTURE_CUBE_MAP : 1;

		int face;

		for(face = 0; face < num_faces; face++)

		{

			int level;

			for(level = 1; level < texture->num_levels[face]; level++)

			{

				if(texture->levels[face][level].specified)

				{

					return GL_TRUE;

				}

			}

		}

		return GL_FALSE;

	}

}

static int dglTargetToFace(DGLTexture* texture, GLenum target)

{

	DGLES2_ASSERT(texture != NULL);

	{

		switch(target)

		{

			case GL_TEXTURE_2D:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_2D);

				return 0;

			case GL_TEXTURE_CUBE_MAP_POSITIVE_X:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 0;

			case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 1;

			case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 2;

			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 3;

			case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 4;

			case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:

				DGLES2_ASSERT(texture->type == DGLES2_TEXTURE_CUBE_MAP);

				return 5;

			default:

				DGLES2_ASSERT(GL_FALSE);

				return -1;

		}

	}

}

DGLTextureLevel* DGLTexture_getLevel(DGLTexture* texture, GLenum target, GLint level)

{	

	DGLES2_ASSERT(texture != NULL);

	return &texture->levels[dglTargetToFace(texture, target)][level];

}

void DGLTexture_setLevel(DGLTexture* texture, GLenum target, GLint level, GLenum format, GLsizei width, GLsizei height)

{

	DGLES2_ASSERT(texture != NULL);

	{

		DGLTextureLevel* level_obj = DGLTexture_getLevel(texture, target, level);

		level_obj->format = format;

		level_obj->width = width;

		level_obj->height = height;

		level_obj->specified = GL_TRUE;

	}

}

GLeglImageOES DGLTexture_getEGLImage(DGLTexture* texture, GLenum target)

{

	return texture->egl_image[dglTargetToFace(texture, target)];

}

void DGLTexture_setEGLImage(DGLTexture* texture, GLenum target, GLeglImageOES image)

{

	texture->egl_image[dglTargetToFace(texture, target)] = image;

}

void DGLTexture_generateMipmap(DGLTexture* texture)

{

	DGLES2_ASSERT(texture != NULL);

	{

		int face;

		int num_faces;

		const DGLTextureLevel* level_zero;

		int level;

		int num_levels;

		int width, height;

		num_faces = 6 ? texture->type == DGLES2_TEXTURE_CUBE_MAP : 1;

		for(face = 0; face < num_faces; face++)

		{

			level_zero = &texture->levels[face][0];

			num_levels = dglLog2(dglMax(level_zero->width, level_zero->height)) + 1;

			texture->num_levels[face] = num_levels;

			width = level_zero->width;

			height = level_zero->height;

			for(level = 0; level < num_levels; level++)

			{

				if(width > 1) width /= 2;

				if(height > 1) height /= 2;

				DGLES2_ASSERT(level < num_levels - 1 || (width > 1 || height > 1));

				if(texture->levels[face][level].bound_surface != NULL)

				{

					// Texture image is respecified. Release the bound EGLSurface.

					deglReleaseTexImage(texture->levels[face][level].bound_surface, texture->obj.name, level);

				}

				texture->levels[face][level].format = level_zero->format;

				texture->levels[face][level].width = width;

				texture->levels[face][level].height = height;

				texture->levels[face][level].bound_surface = NULL;

				texture->levels[face][level].specified = GL_TRUE;

			}

		}

	}

}

// Add a 3-bit two's complement integer to an integer.

static int dglAddTwosComplement(int a, char b)

{

	if(b & 0x4)

	{

		// Negative.

		return a - ((~b + 1) & 0x7);

	}

	else

	{

		// Positive.

		return a + b;

	}

}

static int dglClamp(int x, int min, int max)

{

	if(x < min)

	{

		return min;

	}

	else if(x > max)

	{

		return max;

	}

	else

	{

		return x;

	}

}

static void* dglDecompressETCTexture(int width, int height, const unsigned char* data)

{

	int bytes_per_pixel = 3; // RGB888

	unsigned char* decompressed = malloc(width * height * bytes_per_pixel);

	if(decompressed == NULL)

	{

		return NULL;

	}

	{

		int xblock, yblock;

		char dr, dg, db;

		// Number of 4x4 blocks horizontally and vertically.

		int num_xblocks = (width + 3) / 4;

		int num_yblocks = (height + 3) / 4;

		for(yblock = 0; yblock < num_yblocks; yblock++)

		{

			for(xblock = 0; xblock < num_xblocks; xblock++)

			{

				int i;

				char pixel;

				khronos_int64_t blockbits;

				int diffbit, flipbit;

				unsigned char r[2], g[2], b[2];

				int table[2];

				// Construct 64 bits from 8 bytes.

				blockbits = data[0];

				for(i = 1; i < 8; i++)

				{

					blockbits <<= 8;

					blockbits |= data[i];

				}

				diffbit = (blockbits >> 33) & 1;

				flipbit = (blockbits >> 32) & 1;

				// Base color.

				if(!diffbit)

				{

					// Individual mode.

					// Subblock 1.

					r[0] = (blockbits >> 60) & 0xf;

					g[0] = (blockbits >> 52) & 0xf;

					b[0] = (blockbits >> 44) & 0xf;

					r[0] |= r[0] << 4;

					g[0] |= g[0] << 4;

					b[0] |= b[0] << 4;

					// Subblock 2.

					r[1] = (blockbits >> 56) & 0xf;

					g[1] = (blockbits >> 48) & 0xf;

					b[1] = (blockbits >> 40) & 0xf;

					r[1] |= r[1] << 4;

					g[1] |= g[1] << 4;

					b[1] |= b[1] << 4;

				}

				else

				{

					// Differential mode.

					r[0] = (blockbits >> 59) & 0x1f;

					g[0] = (blockbits >> 51) & 0x1f;

					b[0] = (blockbits >> 43) & 0x1f;

					dr = (blockbits >> 56) & 0x7;

					dg = (blockbits >> 48) & 0x7;

					db = (blockbits >> 40) & 0x7;

					// Subblock 2.

					r[1] = dglAddTwosComplement(r[0], dr);

					g[1] = dglAddTwosComplement(g[0], dg);

					b[1] = dglAddTwosComplement(b[0], db);

					r[1] = (r[1] << 3) | ((r[1] >> 2) & 0x7);

					g[1] = (g[1] << 3) | ((g[1] >> 2) & 0x7);

					b[1] = (b[1] << 3) | ((b[1] >> 2) & 0x7);

					// Subblock 1.

					r[0] = (r[0] << 3) | ((r[0] >> 2) & 0x7);

					g[0] = (g[0] << 3) | ((g[0] >> 2) & 0x7);

					b[0] = (b[0] << 3) | ((b[0] >> 2) & 0x7);

				}

				// Modifier tables.

				table[0] = (blockbits >> 37) & 0x7;

				table[1] = (blockbits >> 34) & 0x7;

				// Write final pixel colors in a top-down left-right order per block.

				for(pixel = 0; pixel < 4 * 4; pixel++)

				{

					static const int tables[][8] = {{2, 8}, {15, 17}, {9, 29}, {13, 42},

										 	    {18, 60}, {24, 80}, {33, 106}, {47, 183}};

					int x, y;

					int loc;

					int subblock;

					int modifier;

					x = 4 * xblock + pixel / 4;

					y = 4 * yblock + pixel % 4;

					if(x >= width || y >= height)

					{

						continue;

					}

					// Memory location of destination pixel.

					loc = y * width + x;

					loc *= bytes_per_pixel;

					if(flipbit)

					{

						subblock = (pixel / 2) & 1;

					}

					else

					{

						subblock = pixel / 8;

					}

					DGLES2_ASSERT(subblock == 0 || subblock == 1);

					modifier = tables[table[subblock]][(blockbits >> pixel) & 1];

					if((blockbits >> (16 + pixel)) & 1)

					{

						modifier *= -1;

					}

					decompressed[loc + 0] = dglClamp(r[subblock] + modifier, 0, 255);

					decompressed[loc + 1] = dglClamp(g[subblock] + modifier, 0, 255);

					decompressed[loc + 2] = dglClamp(b[subblock] + modifier, 0, 255);

				}

				// Move to next block.