usbloadergx/source/ImageOperations/TplImage.cpp

/***************************************************************************
 * Copyright (C) 2010
 * Dimok
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any
 * damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it and
 * redistribute it freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you
 * must not claim that you wrote the original software. If you use
 * this software in a product, an acknowledgment in the product
 * documentation would be appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and
 * must not be misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source
 * distribution.
 *
 * TplImage.cpp
 *
 * for WiiXplorer 2010
 ***************************************************************************/
#include <gccore.h>
#include <malloc.h>
#include <string.h>
#include "FileOperations/fileops.h"
#include "TextureConverter.h"
#include "TplImage.h"

TplImage::TplImage(const char * filepath)
{
	TPLBuffer = NULL;
	TPLSize = 0;

	u8 * buffer = NULL;
	u64 filesize = 0;
	LoadFileToMem(filepath, &buffer, &filesize);

	if(buffer)
	{
		LoadImage(buffer, filesize);
		free(buffer);
	}
}

TplImage::TplImage(const u8 * imgBuffer, u32 imgSize)
{
	TPLBuffer = NULL;
	TPLSize = 0;

	if(imgBuffer)
	{
		LoadImage(imgBuffer, imgSize);
	}
}

TplImage::~TplImage()
{
	if(TPLBuffer)
		free(TPLBuffer);

	Texture.clear();
	TextureHeader.clear();
	TplTextureBuffer.clear();
}

bool TplImage::LoadImage(const u8 * imgBuffer, u32 imgSize)
{
	if(TPLBuffer)
		free(TPLBuffer);

	TPLBuffer = NULL;
	TPLSize = 0;

	if(!imgBuffer)
		return false;

	TPLBuffer = (u8 *) malloc(imgSize);
	if(!TPLBuffer)
		return false;

	TPLSize = imgSize;

	memcpy(TPLBuffer, imgBuffer, imgSize);

	return ParseTplFile();
}

bool TplImage::ParseTplFile()
{
	if(!TPLBuffer)
		return false;

	TPLHeader = (const TPL_Header *) TPLBuffer;

	if(TPLHeader->magic != 0x0020AF30)
		return false;

	if(TPLHeader->head_size != 12)
		return false;

	const TPL_Texture * curTexture = (const TPL_Texture *) (TPLHeader+1);

	for(u32 i = 0; i < TPLHeader->num_textures; i++)
	{
		Texture.resize(i+1);
		TextureHeader.resize(i+1);
		TplTextureBuffer.resize(i+1);

		Texture[i] = curTexture;

		TextureHeader[i] = (const TPL_Texture_Header *) ((const u8 *) TPLBuffer+Texture[i]->text_header_offset);

		TplTextureBuffer[i] = TPLBuffer + TextureHeader[i]->offset;

		curTexture++;
	}

	return true;

}

int TplImage::GetWidth(int pos)
{
	if(pos < 0 || pos >= (int) Texture.size())
	{
		return 0;
	}

	return TextureHeader[pos]->width;
}

int TplImage::GetHeight(int pos)
{
	if(pos < 0 || pos >= (int) TextureHeader.size())
	{
		return 0;
	}

	return TextureHeader[pos]->height;
}

u32 TplImage::GetFormat(int pos)
{
	if(pos < 0 || pos >= (int) TextureHeader.size())
	{
		return 0;
	}

	return TextureHeader[pos]->format;
}

const u8 * TplImage::GetTextureBuffer(int pos)
{
	if(pos < 0 || pos >= (int) TplTextureBuffer.size())
	{
		return 0;
	}

	return TplTextureBuffer[pos];
}

int TplImage::GetTextureSize(int pos)
{
	int width = GetWidth(pos);
	int height = GetHeight(pos);
	int len = 0;

	switch(GetFormat(pos))
	{
			case GX_TF_I4:
			case GX_TF_CI4:
			case GX_TF_CMPR:
				len = ((width+7)>>3)*((height+7)>>3)*32;
				break;
			case GX_TF_I8:
			case GX_TF_IA4:
			case GX_TF_CI8:
				len = ((width+7)>>3)*((height+7)>>2)*32;
				break;
			case GX_TF_IA8:
			case GX_TF_CI14:
			case GX_TF_RGB565:
			case GX_TF_RGB5A3:
				len = ((width+3)>>2)*((height+3)>>2)*32;
				break;
			case GX_TF_RGBA8:
				len = ((width+3)>>2)*((height+3)>>2)*32*2;
				break;
			default:
				len = ((width+3)>>2)*((height+3)>>2)*32*2;
				break;
	}

	return len;
}

gdImagePtr TplImage::ConvertToGD(int pos)
{
	if(pos < 0 || pos >= (int) Texture.size())
	{
		return 0;
	}

	gdImagePtr gdImg = 0;

	switch(TextureHeader[pos]->format)
	{
		case GX_TF_RGB565:
			RGB565ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_RGB5A3:
			RGB565A3ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_RGBA8:
			RGBA8ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_I4:
			I4ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_I8:
			I8ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_IA4:
			IA4ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_IA8:
			IA8ToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		case GX_TF_CMPR:
			CMPToGD(TplTextureBuffer[pos], TextureHeader[pos]->width, TextureHeader[pos]->height, &gdImg);
			break;
		default:
			gdImg = 0;
			break;
	}

	return gdImg;
}