XeNTaX

Code: Select all

  fileSource = blah.png
  fileDestination = blah.dds.raw
  bufBlockBuffer_0 []
  bufBlockBuffer_1 []
  sizeBlock = 0x2000
  posBlock []

func init(){
  posBlock[0] = 0
  posBlock[1] = 1
  convertThread()
}

func convertThread(){
  bufBlockBuffer_0 = read(fileSource, posBlock[0], sizeBlock) ;read (char filename, int seek location, int bytes to read)
  bufBlockBuffer_1 = read(fileSource, posBlock[1]*sizeBlock, sizeBlock)
  while (bufBlockBuffer_0 == 0; bufBlockBuffer_1 == 0):
    write DWORD from bufBlockBuffer_0 to fileDestination
    write DWORD from bufBlockBuffer_1 to fileDestination
  posBlock[0] += 2
  posBlock[1] += 2
}

init()
while (until bufBlockBuffer reached to the end of file)
{
  convertThread()
}

Code: Select all

#include <stdio.h>
#include <string.h>
#include <assert.h>

#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
#  include <fcntl.h>
#  include <io.h>
#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#  define SET_BINARY_MODE(file)
#endif

typedef int DWORD;

#define		DDSD_CAPS					0x1
#define		DDSD_HEIGHT				0x2
#define		DDSD_WIDTH				0x4
#define		DDSD_PITCH				0x8
#define		DDSD_PIXELFORMAT			0x1000
#define		DDSD_MIPMAPCOUNT			0x20000
#define		DDSD_LINEARSIZE			0x80000
#define		DDSD_DEPTH				0x800000

#define		DDPF_ALPHAPIXELS			0x1
#define		DDPF_ALPHA				0x2
#define		DDPF_FOURCC				0x4
#define		DDPF_RGB					0x40
#define		DDPF_YUV					0x200
#define		DDPF_LUMINANCE				0x20000

#define		DDSCAPS_COMPLEX			0x8
#define		DDSCAPS_MIPMAP				0x400000
#define		DDSCAPS_TEXTURE			0x1000

#define		DDSCAPS2_CUBEMAP			0x200
#define		DDSCAPS2_CUBEMAP_POSITIVEX	0x400
#define		DDSCAPS2_CUBEMAP_NEGATIVEX	0x800
#define		DDSCAPS2_CUBEMAP_POSITIVEY	0x1000
#define		DDSCAPS2_CUBEMAP_NEGATIVEY	0x2000
#define		DDSCAPS2_CUBEMAP_POSITIVEZ	0x4000
#define		DDSCAPS2_CUBEMAP_NEGATIVEZ	0x8000
#define		DDSCAPS2_VOLUME			0x200000


typedef struct {
  DWORD dwSize;
  DWORD dwFlags;
  DWORD dwFourCC;
  DWORD dwRGBBitCount;
  DWORD dwRBitMask;
  DWORD dwGBitMask;
  DWORD dwBBitMask;
  DWORD dwABitMask;
} DDS_PIXELFORMAT;

typedef struct {
  DWORD           dwSize;
  DWORD           dwFlags;
  DWORD           dwHeight;
  DWORD           dwWidth;
  DWORD           dwPitchOrLinearSize;
  DWORD           dwDepth;
  DWORD           dwMipMapCount;
  DWORD           dwReserved1[11];
  DDS_PIXELFORMAT ddspf;
  DWORD           dwCaps;
  DWORD           dwCaps2;
  DWORD           dwCaps3;
  DWORD           dwCaps4;
  DWORD           dwReserved2;
} DDS_HEADER;

#define blockSize 0x2000
#define cpySize 0x0004 //0x0020
#define blankSize 0x0

long posBlock[2];
long totalBlocks;

int convertOneBlock(FILE* src, FILE* dst)
{
	unsigned char block1_in[blockSize];
	unsigned char block1_out[blockSize];
	unsigned char block2_in[blockSize];
	unsigned char block2_out[blockSize];
	unsigned char block_out[cpySize];
	int read1_ret, read2_ret;
	fseek(src, (posBlock[0]*blockSize), SEEK_SET);
	read1_ret = fread(block1_in, 1, blockSize, src);
	fseek(src, (posBlock[1]*blockSize), SEEK_SET);
	read2_ret = fread(block2_in, 1, blockSize, src);

	if ( !(read1_ret == 0 || read2_ret == 0) )
	{
		if (cpySize < blockSize)
		{
			size_t remainingSize = blockSize;
			unsigned char* block1_ptr = (unsigned char *) &block1_in;
			unsigned char* block2_ptr = (unsigned char *) &block2_in;
			while (remainingSize > 0)
			{
				memcpy(&block_out, block1_ptr, cpySize);
				fwrite(block_out, 1, cpySize, dst);
				memcpy(&block_out, block2_ptr, cpySize);
				fwrite(block_out, 1, cpySize, dst);
				
				block1_ptr += cpySize;
				block2_ptr += cpySize;
				remainingSize -= cpySize;
			}
			
			posBlock[0] += 2;
			posBlock[1] += 2;
			
			totalBlocks += 2;
		}
		else
		{
			memcpy(&block_out, &block1_in, cpySize);
			fwrite(block_out, 1, cpySize, dst);
			memcpy(&block_out, &block2_in, cpySize);
			fwrite(block_out, 1, cpySize, dst);
	
			posBlock[0] += 2;
			posBlock[1] += 2;
	
			totalBlocks += 2;
		}

		return 0;
	}
	else
	{
		posBlock[0] += 2;
		posBlock[1] += 2;

		return 1;
	}
}

int init(FILE* src, FILE* dst)
{
	if (src == NULL || dst == NULL)
	{
		return -1;
	}
	
	fseek(src, 0L, SEEK_END);
	long srcFileSize = ftell(src);
	fseek(src, 0L, SEEK_SET);
	
	DDS_HEADER fileOutHeader;
	memset(&fileOutHeader, 0, sizeof(DDS_HEADER));
	fileOutHeader.dwSize = 124;

	fileOutHeader.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT;
	fileOutHeader.ddspf.dwSize = 32;
	fileOutHeader.ddspf.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS | DDPF_FOURCC | DDPF_ALPHA;
	fileOutHeader.ddspf.dwFourCC = 0x31545844; // "DXT1"
	fileOutHeader.ddspf.dwRGBBitCount = 32;
	fileOutHeader.ddspf.dwRBitMask = 0xff000000;
	fileOutHeader.ddspf.dwGBitMask = 0x00ff0000;
	fileOutHeader.ddspf.dwBBitMask = 0x0000ff00;
	fileOutHeader.ddspf.dwABitMask = 0x000000ff;
	fileOutHeader.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP;
	
	printf("file size: %ld  ", srcFileSize);
	if (srcFileSize == 0)
	{
		return -2;
	}
	else if (srcFileSize < 131100)
	{
		fileOutHeader.dwWidth = 512;
		fileOutHeader.dwHeight = 512;
		fileOutHeader.dwPitchOrLinearSize = (( (512*32)+7 ) / 8);
		fileOutHeader.dwMipMapCount = 1;
		printf("writing 512x512 32-bit dds file\n");
	} else if (srcFileSize < 655400)
	{
		fileOutHeader.dwWidth = 1024;
		fileOutHeader.dwHeight = 1024;
		fileOutHeader.dwPitchOrLinearSize = (( (1024*32)+7 ) / 8);
		fileOutHeader.dwMipMapCount = 1;
		printf("writing 1024x1024 32-bit dds file\n");
	}
	else if (srcFileSize < 1376260)
	{
		fileOutHeader.dwWidth = 1024;
		fileOutHeader.dwHeight = 1024;
		fileOutHeader.dwPitchOrLinearSize = (( (512*32)+7 ) / 8);
		fileOutHeader.dwMipMapCount = 1;
		printf("writing ?x? 32-bit dds file\n");
	}
	else
	{
		fileOutHeader.dwWidth = 2048;
		fileOutHeader.dwHeight = 2048;
		fileOutHeader.dwPitchOrLinearSize = 0; //(( (2048*32)+7 ) / 8);
		fileOutHeader.dwMipMapCount = 0;
		fileOutHeader.ddspf.dwFlags = DDPF_FOURCC;
		fileOutHeader.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT; /// | DDSD_MIPMAPCOUNT;
		fileOutHeader.ddspf.dwRGBBitCount = 0;
		fileOutHeader.ddspf.dwRBitMask = fileOutHeader.ddspf.dwGBitMask = fileOutHeader.ddspf.dwBBitMask = fileOutHeader.ddspf.dwABitMask = 0x00000000;
		fileOutHeader.dwCaps = DDSCAPS_TEXTURE;
		printf("writing 2048x2048 0-bit dds file\n");
	}
	
	// Write DDS prefix (0x44445320)
	totalBlocks = 0;
	fwrite("DDS ", 4, 1, dst);

	// Write DDS header
	fwrite(&fileOutHeader, 1, sizeof(DDS_HEADER), dst);

	posBlock[0] = 0;
	posBlock[1] = 1;
	convertOneBlock(src, dst);

	return 0;
}

int convertWFPNG(FILE* src, FILE* dst)
{
	init(src, dst);

	while (feof(src) == 0)
	{
		if (convertOneBlock(src, dst) == 1)
		{
			break;
		}
	}

	if (blankSize > 0)
	{
		unsigned char zeroSpace[blankSize];
		memset(&zeroSpace, 0, blankSize);
		int i = 0;
		for (i = 0; i < totalBlocks; i++)
		{
			fwrite(zeroSpace, 1, blankSize, dst);
		}
		printf("wrote some more zeros at file end\n");
	}

	return 0;
}

int main(int argc, char **argv)
{
	FILE* srcFile1 = NULL;
	FILE* dstFile1 = NULL;

	if (argc != 3)
	{
		fprintf(stderr, "Usage: wfpngc input-file.png output-file.dds\n");
		return 1;
	}

	srcFile1 = fopen(argv[1], "r");
	if (srcFile1 == NULL)
	{
		fprintf(stderr, "Error opening file for reading: %s\n", argv[1]);
		return 5;
	}

	dstFile1 = fopen(argv[2], "w");
	if (dstFile1 == NULL)
	{
		fclose(srcFile1);
		srcFile1 = NULL;
		fprintf(stderr, "Error opening file for writing: %s\n", argv[2]);
		return 5;
	}

	convertWFPNG(srcFile1, dstFile1);

	fclose(srcFile1);
	fclose(dstFile1);
}