Torque2D/tools/PVRTC/PVRTC_Mac/older/main.cpp

//-----------------------------------------------------------------------------
// Copyright (c) 2013 GarageGames, LLC
//
// 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 THE
// AUTHORS OR COPYRIGHT HOLDERS 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.
//-----------------------------------------------------------------------------

#include <stdlib.h>
#include "/usr/local/include/png.h"
#include "/usr/local/include/pngconf.h"
//#include "stdafx.h"
//#include "C:\\Program Files\\GnuWin32\\include\\png.h"

#define MAX_ARGS 10
#define TEMP_OUTPUT_FILE "xxtempxx.pvr"
#define TEST_PVR_FILE "compare.pvr"

extern bool readPvr( FILE* fp);
extern bool writePvr( FILE* fp);

bool readPNG( char *filename);

int gBitsPerPixel = -1;
int gChannelWeight = -1;
int gGenerateMipMaps = -1;
char gPNGFileName[256];
char gPVRFileName[256];
unsigned long gWidth;
unsigned long gHeight;
int gBitDepth;
int gColorType;
long gFsize;
bool gIsAlpha;

bool parseArgs(int argc, char * const argv[]);
void usage();

int main (int argc, char * const argv[]) {

#if 0
	FILE *tf;
	tf = fopen(TEST_PVR_FILE, "rb");
	readPvr(tf);
	fclose(tf);
#endif
	
	FILE *wf;
	FILE *rf;
    // insert code here...
    memset(gPNGFileName,0,256);
    memset(gPVRFileName,0,256);
	
	if(parseArgs(argc, argv)){
#if 1		
		char *argv2[MAX_ARGS];
		for(int i=0; i<MAX_ARGS-1; i++){
			argv2[i] = new char[256];
		}
		strcpy(argv2[0],"texturetool");
		strcpy(argv2[1],"-e");
		strcpy(argv2[2],"PVRTC");
		if(gChannelWeight==0){
			strcpy(argv2[3],"--channel-weighting-linear");
		}
		else if(gChannelWeight==1){		
			strcpy(argv2[3],"--channel-weighting-perceptual");
		}
		else{ 
			usage();
			return -1;
		}
		if(gBitsPerPixel==2){
			strcpy(argv2[4],"--bits-per-pixel-2");
		}
		else if(gBitsPerPixel==4){		
			strcpy(argv2[4],"--bits-per-pixel-4");
		}
		else{ 
			usage();
			return -1;
		}

		strcpy(argv2[5],gPNGFileName);

		strcpy(argv2[6],"-o");
		strcpy(argv2[7],TEMP_OUTPUT_FILE);
		
		if(gGenerateMipMaps==1){
			strcpy(argv2[8],"-m");
		}
		else{
			delete argv2[MAX_ARGS-2];
			argv2[MAX_ARGS-2] = NULL;
		}
		argv2[MAX_ARGS-1] = NULL;

		char *newargs = new char[8*1024];
		memset(newargs, 0, 8*1024);
		sprintf(newargs,"./%s",argv2[0]);
		for(int i=1; i<MAX_ARGS-1; i++){
			if(argv2[i]){
				strcat(newargs," ");
				strcat(newargs,argv2[i]);
			}
		}
		
		system(newargs);
		//if(execv("texturetool", argv2)<0){
		//	usage();
		//	return -1;
		//}
		delete newargs;
		//printf("\nHere %d\n",gFsize);

		if(!readPNG(gPNGFileName)){
			usage();
			return -1;
		}
		
		wf = fopen(gPVRFileName, "wb");
		if(!wf){
			printf("\nCannot open file %s\n\n",gPVRFileName);
			return -1;
		}
#endif
		rf = fopen(TEMP_OUTPUT_FILE, "rb");
		if(!rf){
			printf("\nCannot open file %s\n\n",TEMP_OUTPUT_FILE);
			return -1;
		}
		fseek(rf,0,SEEK_END);
		gFsize = ftell(rf);
		//printf("\nHere %d\n",gFsize);
		fseek(rf,0,SEEK_SET);
		char *filedata = new char[gFsize];
		fread(filedata,1,gFsize,rf);
		fclose(rf);

		writePvr(wf);
		fwrite(filedata,1,gFsize,wf);
		fclose(wf);
		delete filedata;

		return 0;

	}
	usage();

    return -1;
}

void usage(){
	printf("\n");
	printf("Usage: PVRTC_Mac [-m] -b# -wX -i <input_png> -o <output_pvr>");
	printf("\n");
	printf("    -m            Generate a complete mipmap chain from the input image.\n");
	printf("    -b#           Bits per pixel either 2 or 4 is valid.\n");
	printf("    -wX           Encoding either l = linear or p = perceptual.\n");
	printf("    -i <input>    <input> PNG file must be square power of 2.\n");
	printf("    -o <output>   Write processed image to <output>.");
	printf("\n\n");
	printf("Example:\n");
	printf("	PVRTC_Mac -b2 -wp -i my.png -o my.pvr\n\n");
	printf("This Will encode my.png with perceptual coding at 2 bits per pixel and output my.pvr.\n");
	printf("\n\n");
/*
	Usage: texturetool [-hlm] [-e <encoder>] [-p <preview_file>] -o <output> [-f <format>] input_image

    -h            Display this help menu.
    -l            List available encoders, individual encoder options, and file formats.
    -m            Generate a complete mipmap chain from the input image.
    -e <encoder>        Encode texture levels with <encoder>.
    -p <preview_file>    Output a PNG preview of the encoded output to <preview_file>. Requires -e option.
    -o <output>        Write processed image to <output>.
    -f <format>        Set file <format> for <output> image.

	PVRTC
	 --channel-weighting-linear
	 --channel-weighting-perceptual
	 --bits-per-pixel-2
	 --bits-per-pixel-4

	Formats:
	Raw
	PVR
*/
}

bool parseArgs(int argc, char * const argv[]){
	if(argc < 7) return false;
	
	for(int i=1; i<argc; i++){
		if(strcmp(argv[i],"-b2")==0){
			gBitsPerPixel = 2;
		}
		if(strcmp(argv[i],"-b4")==0){
			gBitsPerPixel = 4;
		}
		if(strcmp(argv[i],"-wl")==0){
			gChannelWeight = 0;
		}
		if(strcmp(argv[i],"-wp")==0){
			gChannelWeight = 1;
		}
		if(strcmp(argv[i],"-m")==0){
			gGenerateMipMaps = 1;
		}
		if(strcmp(argv[i],"-i")==0){
			i++;
			if(i<argc){
				strcpy(gPNGFileName,argv[i]);
			}
			else{
				return false;
			}
		}
		if(strcmp(argv[i],"-o")==0){
			i++;
			if(i<argc){
				strcpy(gPVRFileName,argv[i]);
			}
			else{
				return false;
			}
		}
	}
	return true;
}

//--------------------------------------
static void pngFatalErrorFn(png_structp     /*png_ptr*/,
                            png_const_charp pMessage)
{
	printf("Error reading PNG file:\n %s", pMessage);
}


//--------------------------------------
static void pngWarningFn(png_structp, png_const_charp pMessage)
{
	printf("Warning reading PNG file:\n %s", pMessage);
}

png_voidp gPngErrorPtr;

bool readPNG( char *filename){
	static const unsigned int cs_headerBytesChecked = 8;
	unsigned char header[cs_headerBytesChecked];
	
    FILE *fp = fopen(filename, "rb");
    if (!fp)
    {
        return false;
    }
    fread(header, 1, cs_headerBytesChecked, fp);
    bool is_png = !png_sig_cmp(header, 0, cs_headerBytesChecked);
    if (!is_png)
    {
		fclose(fp);
        return false;
    }
	
	png_structp png_ptr = png_create_read_struct
	(PNG_LIBPNG_VER_STRING, (png_voidp)gPngErrorPtr,
	 pngFatalErrorFn, pngWarningFn);
    if (!png_ptr){
		fclose(fp);
        return false;
	}
    png_infop info_ptr = png_create_info_struct(png_ptr);
    if (!info_ptr)
    {
        png_destroy_read_struct(&png_ptr,
								(png_infopp)NULL, (png_infopp)NULL);
		fclose(fp);
        return false;
    }
	
    png_infop end_info = png_create_info_struct(png_ptr);
    if (!end_info)
    {
        png_destroy_read_struct(&png_ptr, &info_ptr,
								(png_infopp)NULL);
		fclose(fp);
        return false;
    }
	
	if (setjmp(png_jmpbuf(png_ptr)))
    {
        png_destroy_read_struct(&png_ptr, &info_ptr,
								&end_info);
        fclose(fp);
        return false;
    }
	
	png_init_io(png_ptr, fp);
	
	png_set_sig_bytes(png_ptr, cs_headerBytesChecked);
	
	png_read_info(png_ptr, info_ptr);
	
	png_get_IHDR(png_ptr, info_ptr,
				 &gWidth, &gHeight,             // obv.
				 &gBitDepth, &gColorType,     // obv.
				 NULL,                        // interlace
				 NULL,                        // compression_type
				 NULL);                       // filter_type
	
	bool transAlpha     = false;
	gIsAlpha = false;
	
	if(gWidth != gHeight){
		printf("Not a square input image %dx%d\n",gWidth,gHeight);
		return false;
	}
	if(gWidth > 1024){
		printf("Image %dx%d is too large for iPhone\n",gWidth,gHeight);
		return false;
	}
	int count = 0;
	int temp = gWidth;
	while(temp > 0){
		count += temp & 1;
		temp >>= 1;
	}
	if(count != 1){
		printf("Not a power of 2 image %dx%d\n",gWidth,gHeight);
		return false;
	}
	// Expand a transparency channel into a full alpha channel...
	//
	if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
		transAlpha = true;
	}
	
	if (gColorType == PNG_COLOR_TYPE_PALETTE) 
	{
		gIsAlpha = transAlpha;
	} 
	else if (gColorType == PNG_COLOR_TYPE_GRAY_ALPHA) 
	{
		gIsAlpha = true;
	}
	else if (gColorType == PNG_COLOR_TYPE_RGB_ALPHA) 
	{
		gIsAlpha = true;
	}
	
	fclose(fp);
	return true;
}

/*
static void pngReadDataFn(png_structp  png_ptr,
                          png_bytep   data,
                          png_size_t  length)
{
	
	bool success = sg_pStream->read(length, data);
}


//--------------------------------------
static void pngWriteDataFn(png_structp png_ptr,
                           png_bytep   data,
                           png_size_t  length)
{
	AssertFatal(sg_pStream != NULL, "No stream?");
	
	sg_pStream->write(length, data);
}

//--------------------------------------
static void pngFlushDataFn(png_structp png_ptr)
{
	//
}
*/
/*
//--------------------------------------
bool GBitmap::readPNG(Stream& io_rStream)
{
	static const U32 cs_headerBytesChecked = 8;
	
	U8 header[cs_headerBytesChecked];
	io_rStream.read(cs_headerBytesChecked, header);
	
	bool isPng = png_check_sig(header, cs_headerBytesChecked) != 0;
	if (isPng == false) 
	{
		AssertWarn(false, "GBitmap::readPNG: stream doesn't contain a PNG");
		return false;
	}
	
	U32 prevWaterMark = FrameAllocator::getWaterMark();
	
#if defined(PNG_USER_MEM_SUPPORTED)
	png_structp png_ptr = png_create_read_struct_2(PNG_LIBPNG_VER_STRING,
												   NULL,
												   pngFatalErrorFn,
												   pngWarningFn,
												   NULL,
												   pngMallocFn,
												   pngFreeFn);
#else
	png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
												 NULL,
												 pngFatalErrorFn,
												 pngWarningFn);
#endif
	
	if (png_ptr == NULL) 
	{
		FrameAllocator::setWaterMark(prevWaterMark);
		return false;
	}
	
	// Enable optimizations if appropriate.
#if defined(PNG_LIBPNG_VER) && (PNG_LIBPNG_VER >= 10200)
	png_uint_32 mask, flags;
	
	flags = png_get_asm_flags(png_ptr);
	mask = png_get_asm_flagmask(PNG_SELECT_READ | PNG_SELECT_WRITE);
	png_set_asm_flags(png_ptr, flags | mask);
#endif
	
	png_infop info_ptr = png_create_info_struct(png_ptr);
	if (info_ptr == NULL) {
		png_destroy_read_struct(&png_ptr,
								(png_infopp)NULL,
								(png_infopp)NULL);
		FrameAllocator::setWaterMark(prevWaterMark);
		return false;
	}
	
	png_infop end_info = png_create_info_struct(png_ptr);
	if (end_info == NULL) {
		png_destroy_read_struct(&png_ptr,
								&info_ptr,
								(png_infopp)NULL);
		FrameAllocator::setWaterMark(prevWaterMark);
		return false;
	}
	
	sg_pStream = &io_rStream;
	png_set_read_fn(png_ptr, NULL, pngReadDataFn);
	
	// Read off the info on the image.
	png_set_sig_bytes(png_ptr, cs_headerBytesChecked);
	png_read_info(png_ptr, info_ptr);
	
	// OK, at this point, if we have reached it ok, then we can reset the
	//  image to accept the new data...
	//
	deleteImage();
	
	png_uint_32 width;
	png_uint_32 height;
	S32 bit_depth;
	S32 color_type;
	
	png_get_IHDR(png_ptr, info_ptr,
				 &width, &height,             // obv.
				 &bit_depth, &color_type,     // obv.
				 NULL,                        // interlace
				 NULL,                        // compression_type
				 NULL);                       // filter_type
	
	// First, handle the color transformations.  We need this to read in the
	//  data as RGB or RGBA, _always_, with a maximal channel width of 8 bits.
	//
	bool transAlpha     = false;
	BitmapFormat format = RGB;
	
	// Strip off any 16 bit info
	//
	if (bit_depth == 16) {
		png_set_strip_16(png_ptr);
	}
	
	// Expand a transparency channel into a full alpha channel...
	//
	if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
		png_set_expand(png_ptr);
		transAlpha = true;
	}
	
	if (color_type == PNG_COLOR_TYPE_PALETTE) 
	{
		png_set_expand(png_ptr);
		format = transAlpha ? RGBA : RGB;
	} 
	else if (color_type == PNG_COLOR_TYPE_GRAY) 
	{
		png_set_expand(png_ptr);
		//png_set_gray_to_rgb(png_ptr);
		format = Alpha; //transAlpha ? RGBA : RGB;
	}
	else if (color_type == PNG_COLOR_TYPE_GRAY_ALPHA) 
	{
		png_set_expand(png_ptr);
		png_set_gray_to_rgb(png_ptr);
		format = RGBA;
	}
	else if (color_type == PNG_COLOR_TYPE_RGB) 
	{
		format = transAlpha ? RGBA : RGB;
		png_set_expand(png_ptr);
	}
	else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) 
	{
		png_set_expand(png_ptr);
		format = RGBA;
	}
	
	// Update the info pointer with the result of the transformations
	//  above...
	png_read_update_info(png_ptr, info_ptr);
	
	png_uint_32 rowBytes = png_get_rowbytes(png_ptr, info_ptr);
	if (format == RGB) {
		AssertFatal(rowBytes == width * 3,
					"Error, our rowbytes are incorrect for this transform... (3)");
	} 
	else if (format == RGBA) 
	{
		AssertFatal(rowBytes == width * 4,
					"Error, our rowbytes are incorrect for this transform... (4)");
	}
	
	// actually allocate the bitmap space...
	allocateBitmap(width, height,
				   false,            // don't extrude miplevels...
				   format);          // use determined format...
	
	// Set up the row pointers...
	AssertISV(height <= csgMaxRowPointers, "Error, cannot load pngs taller than 2048 pixels!");
	png_bytep* rowPointers = sRowPointers;
	U8* pBase = (U8*)getBits();
	for (U32 i = 0; i < height; i++)
		rowPointers[i] = pBase + (i * rowBytes);
	
	// And actually read the image!
	png_read_image(png_ptr, rowPointers);
	
	// We're outta here, destroy the png structs, and release the lock
	//  as quickly as possible...
	//png_read_end(png_ptr, end_info);
	png_read_end(png_ptr, NULL);
	png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
	
	sg_pStream = NULL;
	
	// Ok, the image is read in, now we need to finish up the initialization,
	//  which means: setting up the detailing members, init'ing the palette
	//  key, etc...
	//
	// actually, all of that was handled by allocateBitmap, so we're outta here
	//
	FrameAllocator::setWaterMark(prevWaterMark);
	
	//
	//-Mat if all palleted images are to be converted, set mForce16bit
	if( color_type == PNG_COLOR_TYPE_PALETTE ) {
		sgForcePalletedPNGsTo16Bit = dAtob( Con::getVariable("$pref::iPhone::ForcePalletedPNGsTo16Bit") );
		if( sgForcePalletedPNGsTo16Bit ) {
			mForce16Bit = true;
		}
	}
	return true;
}
*/