├── README.md
├── WudCompress.sln
└── WudCompress
    ├── wud.h
    ├── WudCompress.vcproj
    ├── wud.cpp
    └── main.cpp


/README.md:
--------------------------------------------------------------------------------
1 | # WudCompress
2 | A little tool to compress Wii U images/dumps.
3 | 


--------------------------------------------------------------------------------
/WudCompress.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 10.00
 3 | # Visual Studio 2008
 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WudCompress", "WudCompress\WudCompress.vcproj", "{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|Win32 = Debug|Win32
 9 | 		Release|Win32 = Release|Win32
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}.Debug|Win32.ActiveCfg = Debug|Win32
13 | 		{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}.Debug|Win32.Build.0 = Debug|Win32
14 | 		{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}.Release|Win32.ActiveCfg = Release|Win32
15 | 		{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}.Release|Win32.Build.0 = Release|Win32
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/WudCompress/wud.h:
--------------------------------------------------------------------------------
 1 | typedef struct 
 2 | {
 3 | 	unsigned int		magic0;
 4 | 	unsigned int		magic1;
 5 | 	unsigned int		sectorSize;
 6 | 	unsigned long long	uncompressedSize;
 7 | 	unsigned int		flags;
 8 | }wuxHeader_t;
 9 | 
10 | typedef struct  
11 | {
12 | 	FILE*			fileWud;
13 | 	long long		uncompressedSize;
14 | 	bool			isCompressed;
15 | 	// data only used when compressed
16 | 	unsigned int	sectorSize;
17 | 	unsigned int	indexTableEntryCount;
18 | 	unsigned int*	indexTable;
19 | 	long long		offsetIndexTable;
20 | 	long long		offsetSectorArray;
21 | }wud_t;
22 | 
23 | #define WUX_MAGIC_0	'0XUW' // "WUX0"
24 | #define WUX_MAGIC_1	0x1099d02e
25 | 
26 | // wud and wux functions
27 | wud_t* wud_open(char* path); // handles both, compressed and uncompressed files
28 | void wud_close(wud_t* wud);
29 | 
30 | unsigned int wud_readData(wud_t* wud, void* buffer, unsigned int length, long long offset);
31 | bool wud_isWUXCompressed(wud_t* wud);
32 | long long wud_getWUDSize(wud_t* wud);


--------------------------------------------------------------------------------
/WudCompress/WudCompress.vcproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="Windows-1252"?>
  2 | <VisualStudioProject
  3 | 	ProjectType="Visual C++"
  4 | 	Version="9,00"
  5 | 	Name="WudCompress"
  6 | 	ProjectGUID="{6FC9B74D-FB07-4173-B7CB-86D34867BCD7}"
  7 | 	RootNamespace="WudCompress"
  8 | 	TargetFrameworkVersion="196613"
  9 | 	>
 10 | 	<Platforms>
 11 | 		<Platform
 12 | 			Name="Win32"
 13 | 		/>
 14 | 	</Platforms>
 15 | 	<ToolFiles>
 16 | 	</ToolFiles>
 17 | 	<Configurations>
 18 | 		<Configuration
 19 | 			Name="Debug|Win32"
 20 | 			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
 21 | 			IntermediateDirectory="$(ConfigurationName)"
 22 | 			ConfigurationType="1"
 23 | 			CharacterSet="2"
 24 | 			>
 25 | 			<Tool
 26 | 				Name="VCPreBuildEventTool"
 27 | 			/>
 28 | 			<Tool
 29 | 				Name="VCCustomBuildTool"
 30 | 			/>
 31 | 			<Tool
 32 | 				Name="VCXMLDataGeneratorTool"
 33 | 			/>
 34 | 			<Tool
 35 | 				Name="VCWebServiceProxyGeneratorTool"
 36 | 			/>
 37 | 			<Tool
 38 | 				Name="VCMIDLTool"
 39 | 			/>
 40 | 			<Tool
 41 | 				Name="VCCLCompilerTool"
 42 | 				Optimization="0"
 43 | 				MinimalRebuild="true"
 44 | 				BasicRuntimeChecks="3"
 45 | 				RuntimeLibrary="3"
 46 | 				WarningLevel="3"
 47 | 				DebugInformationFormat="4"
 48 | 			/>
 49 | 			<Tool
 50 | 				Name="VCManagedResourceCompilerTool"
 51 | 			/>
 52 | 			<Tool
 53 | 				Name="VCResourceCompilerTool"
 54 | 			/>
 55 | 			<Tool
 56 | 				Name="VCPreLinkEventTool"
 57 | 			/>
 58 | 			<Tool
 59 | 				Name="VCLinkerTool"
 60 | 				GenerateDebugInformation="true"
 61 | 				TargetMachine="1"
 62 | 			/>
 63 | 			<Tool
 64 | 				Name="VCALinkTool"
 65 | 			/>
 66 | 			<Tool
 67 | 				Name="VCManifestTool"
 68 | 			/>
 69 | 			<Tool
 70 | 				Name="VCXDCMakeTool"
 71 | 			/>
 72 | 			<Tool
 73 | 				Name="VCBscMakeTool"
 74 | 			/>
 75 | 			<Tool
 76 | 				Name="VCFxCopTool"
 77 | 			/>
 78 | 			<Tool
 79 | 				Name="VCAppVerifierTool"
 80 | 			/>
 81 | 			<Tool
 82 | 				Name="VCPostBuildEventTool"
 83 | 			/>
 84 | 		</Configuration>
 85 | 		<Configuration
 86 | 			Name="Release|Win32"
 87 | 			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
 88 | 			IntermediateDirectory="$(ConfigurationName)"
 89 | 			ConfigurationType="1"
 90 | 			CharacterSet="2"
 91 | 			WholeProgramOptimization="1"
 92 | 			>
 93 | 			<Tool
 94 | 				Name="VCPreBuildEventTool"
 95 | 			/>
 96 | 			<Tool
 97 | 				Name="VCCustomBuildTool"
 98 | 			/>
 99 | 			<Tool
100 | 				Name="VCXMLDataGeneratorTool"
101 | 			/>
102 | 			<Tool
103 | 				Name="VCWebServiceProxyGeneratorTool"
104 | 			/>
105 | 			<Tool
106 | 				Name="VCMIDLTool"
107 | 			/>
108 | 			<Tool
109 | 				Name="VCCLCompilerTool"
110 | 				Optimization="2"
111 | 				EnableIntrinsicFunctions="true"
112 | 				FavorSizeOrSpeed="1"
113 | 				RuntimeLibrary="0"
114 | 				EnableFunctionLevelLinking="true"
115 | 				WarningLevel="3"
116 | 				DebugInformationFormat="3"
117 | 			/>
118 | 			<Tool
119 | 				Name="VCManagedResourceCompilerTool"
120 | 			/>
121 | 			<Tool
122 | 				Name="VCResourceCompilerTool"
123 | 			/>
124 | 			<Tool
125 | 				Name="VCPreLinkEventTool"
126 | 			/>
127 | 			<Tool
128 | 				Name="VCLinkerTool"
129 | 				GenerateDebugInformation="true"
130 | 				OptimizeReferences="2"
131 | 				EnableCOMDATFolding="2"
132 | 				TargetMachine="1"
133 | 			/>
134 | 			<Tool
135 | 				Name="VCALinkTool"
136 | 			/>
137 | 			<Tool
138 | 				Name="VCManifestTool"
139 | 			/>
140 | 			<Tool
141 | 				Name="VCXDCMakeTool"
142 | 			/>
143 | 			<Tool
144 | 				Name="VCBscMakeTool"
145 | 			/>
146 | 			<Tool
147 | 				Name="VCFxCopTool"
148 | 			/>
149 | 			<Tool
150 | 				Name="VCAppVerifierTool"
151 | 			/>
152 | 			<Tool
153 | 				Name="VCPostBuildEventTool"
154 | 			/>
155 | 		</Configuration>
156 | 	</Configurations>
157 | 	<References>
158 | 	</References>
159 | 	<Files>
160 | 		<Filter
161 | 			Name="Source Files"
162 | 			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
163 | 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
164 | 			>
165 | 			<File
166 | 				RelativePath=".\main.cpp"
167 | 				>
168 | 			</File>
169 | 			<File
170 | 				RelativePath=".\wud.cpp"
171 | 				>
172 | 			</File>
173 | 			<File
174 | 				RelativePath=".\wud.h"
175 | 				>
176 | 			</File>
177 | 		</Filter>
178 | 		<Filter
179 | 			Name="Header Files"
180 | 			Filter="h;hpp;hxx;hm;inl;inc;xsd"
181 | 			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
182 | 			>
183 | 		</Filter>
184 | 		<Filter
185 | 			Name="Resource Files"
186 | 			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
187 | 			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
188 | 			>
189 | 		</Filter>
190 | 	</Files>
191 | 	<Globals>
192 | 	</Globals>
193 | </VisualStudioProject>
194 | 


--------------------------------------------------------------------------------
/WudCompress/wud.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #include<string.h>
  4 | #include"wud.h"
  5 | 
  6 | long long wud_getFileSize64(FILE* file)
  7 | {
  8 | 	long long prevSeek = _ftelli64(file);
  9 | 	_fseeki64(file, 0, SEEK_END);
 10 | 	long long fileSize = _ftelli64(file);
 11 | 	_fseeki64(file, prevSeek, SEEK_SET);
 12 | 	return fileSize;
 13 | }
 14 | 
 15 | long long wud_getCurrentSeek64(FILE* file)
 16 | {
 17 | 	long long currentSeek = _ftelli64(file);
 18 | 	return currentSeek;
 19 | }
 20 | 
 21 | void wud_setCurrentSeek64(FILE* file, long long newSeek)
 22 | {
 23 | 	_fseeki64(file, newSeek, SEEK_SET);
 24 | }
 25 | 
 26 | /*
 27 |  * Open .wud (Wii U image) or .wux (Wii U compressed image) file
 28 |  */
 29 | wud_t* wud_open(char* path)
 30 | {
 31 | 	FILE* inputFile;
 32 | 	inputFile = fopen(path, "rb");
 33 | 	if( inputFile == NULL )
 34 | 		return NULL;
 35 | 	// allocate wud struct
 36 | 	wud_t* wud = (wud_t*)malloc(sizeof(wud_t));
 37 | 	memset(wud, 0x00, sizeof(wud_t));
 38 | 	wud->fileWud = inputFile;
 39 | 	// get size of file
 40 | 	long long inputFileSize = wud_getFileSize64(wud->fileWud);
 41 | 	// determine whether the WUD is compressed or not
 42 | 	wuxHeader_t wuxHeader = {0};
 43 | 	if( fread(&wuxHeader, sizeof(wuxHeader_t), 1, wud->fileWud) != 1 )
 44 | 	{
 45 | 		// file is too short to be either
 46 | 		wud_close(wud);
 47 | 		return NULL;
 48 | 	}
 49 | 	if( wuxHeader.magic0 == WUX_MAGIC_0 && wuxHeader.magic1 == WUX_MAGIC_1 )
 50 | 	{
 51 | 		// this is a compressed file
 52 | 		wud->isCompressed = true;
 53 | 		wud->sectorSize = wuxHeader.sectorSize;
 54 | 		wud->uncompressedSize = wuxHeader.uncompressedSize;
 55 | 		// validate header values
 56 | 		if( wud->sectorSize < 0x100 || wud->sectorSize >= 0x10000000 )
 57 | 		{
 58 | 			wud_close(wud);
 59 | 			return NULL;
 60 | 		}
 61 | 		// calculate offsets and sizes
 62 | 		wud->indexTableEntryCount = (unsigned int)((wud->uncompressedSize+(long long)(wud->sectorSize-1)) / (long long)wud->sectorSize);
 63 | 		wud->offsetIndexTable = wud_getCurrentSeek64(wud->fileWud);
 64 | 		wud->offsetSectorArray = (wud->offsetIndexTable + (long long)wud->indexTableEntryCount*sizeof(unsigned int));
 65 | 		// align to SECTOR_SIZE
 66 | 		wud->offsetSectorArray = (wud->offsetSectorArray + (long long)(wud->sectorSize-1));
 67 | 		wud->offsetSectorArray = wud->offsetSectorArray - (wud->offsetSectorArray%(long long)wud->sectorSize);
 68 | 		// read index table
 69 | 		unsigned int indexTableSize = sizeof(unsigned int) * wud->indexTableEntryCount;
 70 | 		wud->indexTable = (unsigned int*)malloc(sizeof(unsigned int) * wud->indexTableEntryCount);
 71 | 		wud_setCurrentSeek64(wud->fileWud, wud->offsetIndexTable);
 72 | 		if( fread(wud->indexTable, sizeof(unsigned int), wud->indexTableEntryCount, wud->fileWud) != wud->indexTableEntryCount )
 73 | 		{
 74 | 			// could not read index table
 75 | 			wud_close(wud);
 76 | 			return NULL;
 77 | 		}
 78 | 	}
 79 | 	else
 80 | 	{
 81 | 		// uncompressed file
 82 | 		wud->uncompressedSize = inputFileSize;
 83 | 	}
 84 | 	return wud;
 85 | }
 86 | 
 87 | /*
 88 |  * Close wud/wux reader
 89 |  */
 90 | void wud_close(wud_t* wud)
 91 | {
 92 | 	fclose(wud->fileWud);
 93 | 	if( wud->indexTable )
 94 | 		free(wud->indexTable);
 95 | 	free(wud);
 96 | }
 97 | 
 98 | /*
 99 |  * Read data
100 |  * Transparently handles WUX decompression
101 |  * Can read up to 4GB-1 at once
102 |  */
103 | unsigned int wud_readData(wud_t* wud, void* buffer, unsigned int length, long long offset)
104 | {
105 | 	// make sure there is no out-of-bounds read
106 | 	long long fileBytesLeft = wud->uncompressedSize - offset;
107 | 	if( fileBytesLeft <= 0 )
108 | 		return 0;
109 | 	if( fileBytesLeft < (long long)length )
110 | 		length = (unsigned int)fileBytesLeft;
111 | 	// read data
112 | 	unsigned int readBytes = 0;
113 | 	if( wud->isCompressed == false )
114 | 	{
115 | 		// uncompressed read is just a 1:1 copy
116 | 		wud_setCurrentSeek64(wud->fileWud, offset);
117 | 		readBytes = (unsigned int)fread(buffer, 1, length, wud->fileWud);
118 | 	}
119 | 	else
120 | 	{
121 | 		// compressed read must be handled on a per-sector level
122 | 		while( length > 0 )
123 | 		{
124 | 			unsigned int sectorOffset = (unsigned int)(offset % (long long)wud->sectorSize);
125 | 			unsigned int remainingSectorBytes = wud->sectorSize - sectorOffset;
126 | 			unsigned int sectorIndex = (unsigned int)(offset / (long long)wud->sectorSize);
127 | 			unsigned int bytesToRead = (remainingSectorBytes<length)?remainingSectorBytes:length; // read only up to the end of the current sector
128 | 			// look up real sector index
129 | 			sectorIndex = wud->indexTable[sectorIndex];
130 | 			wud_setCurrentSeek64(wud->fileWud, wud->offsetSectorArray + (long long)sectorIndex*(long long)wud->sectorSize+(long long)sectorOffset);
131 | 			readBytes += (unsigned int)fread(buffer, 1, bytesToRead, wud->fileWud);
132 | 			// progress read offset, write pointer and decrease length
133 | 			buffer = (void*)((char*)buffer + bytesToRead);
134 | 			length -= bytesToRead;
135 | 			offset += bytesToRead;
136 | 		}
137 | 	}
138 | 	return readBytes;
139 | }
140 | 
141 | /*
142 |  * Returns true if the file uses .wux compression, false otherwise
143 |  */
144 | bool wud_isWUXCompressed(wud_t* wud)
145 | {
146 | 	return wud->isCompressed;
147 | }
148 | 
149 | /*
150 |  * Returns size of data in bytes
151 |  * For .wud: Size of raw file
152 |  * For .wux: Size of uncompressed data
153 |  */
154 | long long wud_getWUDSize(wud_t* wud)
155 | {
156 | 	return wud->uncompressedSize;
157 | }


--------------------------------------------------------------------------------
/WudCompress/main.cpp:
--------------------------------------------------------------------------------
  1 | #include<stdio.h>
  2 | #include<stdlib.h>
  3 | #include<string.h>
  4 | #include"wud.h"
  5 | 
  6 | /*
  7 |  * WUX file structure (v1.0):
  8 | 		[Header]
  9 | 		UINT32		magic1				"WUX0"
 10 | 		UINT32		magic2				0x1099d02e
 11 | 		UINT32		sectorSize			Size per uncompressed sector (SECTOR_SIZE constant)
 12 | 		UINT64		uncompressedSize	Size of the Wii U image before being compressed
 13 | 		UINT32		flags				Enable optional parts of the header (not used right now)
 14 | 
 15 | 		[SectorIndexTable]
 16 | 		UINT32[]	lookupIndex			table of indices for lookup of each sector. To calculate number of entries in this array: sectorCount = (uncompressedSize+sectorSize-1)/sectorSize
 17 | 		
 18 | 		[SectorData]
 19 | 		UINT8[]		padding				Padding until the next field (sectorData) is aligned to sectorSize bytes. You can write whatever data you want here
 20 | 		UINT8[]		sectorData			Array of unique sectors. Size in bytes: sectorSize * sectorCount
 21 | 		
 22 |  */
 23 | 
 24 | 
 25 | #define SECTOR_SIZE			(0x8000)
 26 | #define SECTOR_HASH_SIZE	(32)
 27 | 
 28 | /*
 29 |  * Hash function used to create a hash of each sector
 30 |  * The hashes are then compared to find duplicate sectors
 31 |  */
 32 | void calculateHash256(unsigned char* data, unsigned int length, unsigned char* hashOut)
 33 | {
 34 | 	// cheap and simple hash implementation
 35 | 	// you can replace this part with your favorite hash method
 36 | 	memset(hashOut, 0x00, 32);
 37 | 	for(unsigned int i=0; i<length; i++)
 38 | 	{
 39 | 		hashOut[i%32] ^= data[i];
 40 | 		hashOut[(i+7)%32] += data[i];
 41 | 	}
 42 | }
 43 | 
 44 | /*
 45 |  * Compare content of two WUD/WUX files
 46 |  * Used to compare uncompressed and compressed version of a WUD
 47 |  * Returns false if there is even a single byte of difference
 48 |  */
 49 | bool validateWUX(char* wud1Path, char* wud2Path)
 50 | {
 51 | 	puts("Checking for errors...");
 52 | 	wud_t* wudFile1 = wud_open(wud1Path);
 53 | 	wud_t* wudFile2 = wud_open(wud2Path);
 54 | 	if( wudFile1 == NULL )
 55 | 	{
 56 | 		printf("Failed to open \"%s\"\n", wud1Path);
 57 | 		if( wudFile2 == NULL )
 58 | 			wud_close(wudFile2);
 59 | 		return false;
 60 | 	}
 61 | 	if( wudFile2 == NULL )
 62 | 	{
 63 | 		printf("Failed to open \"%s\"\n", wud2Path);
 64 | 		if( wudFile1 == NULL )
 65 | 			wud_close(wudFile1);
 66 | 		return false;
 67 | 	}
 68 | 	// get and compare sizes
 69 | 	long long wud1Size = wud_getWUDSize(wudFile1);
 70 | 	long long wud2Size = wud_getWUDSize(wudFile2);
 71 | 	if( wud1Size != wud2Size )
 72 | 	{
 73 | 		printf("WUD data size mismatch\n");
 74 | 		return false;
 75 | 	}
 76 | 	// compare data
 77 | 	long long currentValidationOffset = 0;
 78 | 	unsigned int tempBufferSize = 1024*1024+19; // 1MB + some extra bytes to make the number uneven (we want to provoke cross-sector reads)
 79 | 	unsigned char* tempBufferWUD1 = (unsigned char*)malloc(tempBufferSize); 
 80 | 	unsigned char* tempBufferWUD2 = (unsigned char*)malloc(tempBufferSize); 
 81 | 	bool dataMismatch = false;
 82 | 	int pct = -1;
 83 | 	printf("0%\r");
 84 | 	while( currentValidationOffset < wud1Size )
 85 | 	{
 86 | 		// calculate how many bytes we are reading in this cycle
 87 | 		long long remainingBytes = wud1Size - currentValidationOffset;
 88 | 		unsigned int bytesToRead = tempBufferSize;
 89 | 		if( remainingBytes < (long long)bytesToRead )
 90 | 			bytesToRead = (unsigned int)remainingBytes;
 91 | 		unsigned int readByteCount1 = wud_readData(wudFile1, tempBufferWUD1, bytesToRead, currentValidationOffset);
 92 | 		unsigned int readByteCount2 = wud_readData(wudFile2, tempBufferWUD2, bytesToRead, currentValidationOffset);
 93 | 		if( readByteCount1 != readByteCount2 || bytesToRead != readByteCount1 )
 94 | 		{
 95 | 			printf("Data read size mismatch\n");
 96 | 			dataMismatch = true;
 97 | 			break;
 98 | 		}
 99 | 		// compare buffers
100 | 		if( memcmp(tempBufferWUD1, tempBufferWUD2, bytesToRead) != 0 )
101 | 		{
102 | 			printf("Data mismatch\n");
103 | 			dataMismatch = true;
104 | 			break;
105 | 		}
106 | 		// progress offset
107 | 		currentValidationOffset += bytesToRead;
108 | 		// display current progress
109 | 		int newPct = (int)(currentValidationOffset*1000LL / wud1Size);
110 | 		if( newPct != pct )	
111 | 		{
112 | 			printf("%d.%d%%   \r", (newPct/10), (newPct%10));
113 | 			pct = newPct;
114 | 		}
115 | 	}
116 | 	puts("");
117 | 	free(tempBufferWUD1);
118 | 	free(tempBufferWUD2);
119 | 	wud_close(wudFile1);
120 | 	wud_close(wudFile2);
121 | 	return dataMismatch == false;
122 | }
123 | 
124 | bool compressWUD(wud_t* inputFile, FILE* outputFile, char* outputPath)
125 | {
126 | 	long long inputSize = wud_getWUDSize(inputFile);
127 | 	// write header
128 | 	wuxHeader_t wuxHeader = {0};
129 | 	wuxHeader.magic0 = WUX_MAGIC_0;
130 | 	wuxHeader.magic1 = WUX_MAGIC_1;
131 | 	wuxHeader.sectorSize = SECTOR_SIZE;
132 | 	wuxHeader.uncompressedSize = inputSize;
133 | 	wuxHeader.flags = 0;
134 | 	fwrite(&wuxHeader, sizeof(wuxHeader_t), 1, outputFile);
135 | 	unsigned int sectorTableEntryCount = (unsigned int)((inputSize+SECTOR_SIZE-1) / (long long)SECTOR_SIZE);
136 | 
137 | 	// remember current seek offset, this is where the index table will be written after compression is done
138 | 	long long offsetIndexTable = _ftelli64(outputFile);
139 | 	// skip index table and padding
140 | 	long long offsetSectorArrayStart = (offsetIndexTable + (long long)sectorTableEntryCount*sizeof(unsigned int));
141 | 	// align to SECTOR_SIZE
142 | 	offsetSectorArrayStart = (offsetSectorArrayStart + SECTOR_SIZE - 1);
143 | 	offsetSectorArrayStart = offsetSectorArrayStart - (offsetSectorArrayStart%SECTOR_SIZE);
144 | 	_fseeki64(outputFile, offsetSectorArrayStart, SEEK_SET);
145 | 
146 | 	unsigned int indexTableSize = sizeof(unsigned int) * sectorTableEntryCount;
147 | 	unsigned int* sectorIndexTable = (unsigned int*)malloc(sizeof(unsigned int) * sectorTableEntryCount);
148 | 	unsigned char* sectorHashArray = (unsigned char*)malloc(sizeof(unsigned char) * SECTOR_HASH_SIZE * sectorTableEntryCount);
149 | 	unsigned int uniqueSectorCount = 0;
150 | 	printf("Compressing %d sectors...\n", sectorTableEntryCount);
151 | 	unsigned char buffer[SECTOR_SIZE];
152 | 	unsigned char sectorHash[32];
153 | 	unsigned int storedSectors = 0;
154 | 	int currentPct = 0;
155 | 	long long compressedSize = offsetSectorArrayStart;
156 | 	for(unsigned int i=0; i<sectorTableEntryCount; i++)
157 | 	{
158 | 		// print status
159 | 		int newPct = ((i+1)*1000)/sectorTableEntryCount;
160 | 		if( currentPct != newPct )
161 | 		{
162 | 			currentPct = newPct;
163 | 			int compressionRatio = (int)(((long long)i * SECTOR_SIZE)*10 / compressedSize);
164 | 			printf("\r%d.%d%% Compression ratio: 1:%d.%d    \r", currentPct/10, currentPct%10, compressionRatio/10, compressionRatio%10);
165 | 		}
166 | 		// read sector and generate hash
167 | 		wud_readData(inputFile, buffer, SECTOR_SIZE, (long long)i * (long long)SECTOR_SIZE);
168 | 		calculateHash256(buffer, SECTOR_SIZE, sectorHash);
169 | 		unsigned int sectorReuseIndex = 0xFFFFFFFF;
170 | 		// try to locate any previous sector with same hash
171 | 		for(unsigned int f=0; f<uniqueSectorCount; f++)
172 | 		{
173 | 			if( memcmp(sectorHash, sectorHashArray+f*SECTOR_HASH_SIZE, SECTOR_HASH_SIZE) == 0 )
174 | 			{
175 | 				sectorReuseIndex = f;
176 | 				break;
177 | 			}
178 | 		}
179 | 		// if we found a sector then just store the index
180 | 		if( sectorReuseIndex != 0xFFFFFFFF )
181 | 		{
182 | 			sectorIndexTable[i] = sectorReuseIndex;
183 | 			continue;
184 | 		}
185 | 		// else store the sector and append a new index
186 | 		fwrite(buffer, SECTOR_SIZE, 1, outputFile);
187 | 		memcpy(sectorHashArray+uniqueSectorCount*SECTOR_HASH_SIZE, sectorHash, SECTOR_HASH_SIZE);
188 | 		compressedSize += SECTOR_SIZE;
189 | 		sectorIndexTable[i] = uniqueSectorCount;
190 | 		uniqueSectorCount++;
191 | 		storedSectors++;
192 | 	}
193 | 	printf("100%%   \n");
194 | 	_fseeki64(outputFile, offsetIndexTable, SEEK_SET);
195 | 	fwrite(sectorIndexTable, sectorTableEntryCount, sizeof(unsigned int), outputFile);
196 | 	fclose(outputFile);
197 | 	puts("done");
198 | 	return true;
199 | }
200 | 
201 | bool decompressWUD(wud_t* inputFile, FILE* outputFile, char* outputPath)
202 | {
203 | 	long long inputSize = wud_getWUDSize(inputFile);
204 | 	printf("Decompressing...\n");
205 | 	unsigned char buffer[SECTOR_SIZE];
206 | 	long long currentIndex = 0;
207 | 	int currentPct = 0;
208 | 	while( currentIndex < inputSize )
209 | 	{
210 | 		// print status
211 | 		int newPct = (int)((currentIndex*1000LL)/inputSize);
212 | 		if( currentPct != newPct )
213 | 		{
214 | 			currentPct = newPct;
215 | 			printf("\r%d.%d%%   \r", currentPct/10, currentPct%10);
216 | 		}
217 | 		// calculate how many bytes to read
218 | 		int bytesToRead = SECTOR_SIZE;
219 | 		if( (inputSize-currentIndex) < SECTOR_SIZE )
220 | 			bytesToRead = (int)(inputSize-currentIndex);
221 | 		// read data
222 | 		wud_readData(inputFile, buffer, bytesToRead, currentIndex);
223 | 		// write data
224 | 		fwrite(buffer, bytesToRead, 1, outputFile);
225 | 		currentIndex += (long long)bytesToRead;
226 | 	}
227 | 	printf("100%%   \n");
228 | 	fclose(outputFile);
229 | 	puts("done");
230 | 	return true;
231 | }
232 | 
233 | int main(int argc, char *argv[])
234 | {
235 | 	if( argc < 2 )
236 | 	{
237 | 		puts("Wii U image compression tool v1.0 by Exzap");
238 | 		puts("Lossless compression and decompression for Wii U dumps.");
239 | 		puts("");
240 | 		puts("Usage:");
241 | 		puts("WudCompress <game.wud/game.wux> [-noverify]");
242 | 		puts("");
243 | 		puts("Parameters:");
244 | 		puts("-noverify       Skip the file validation step at the end");
245 | 		return 0;
246 | 	}
247 | 	char* wudPath = argv[1];
248 | 	// parse options
249 | 	bool skipVerify = false;
250 | 	for(int i=2; i<argc; i++)
251 | 	{
252 | 		if( stricmp(argv[i], "-noverify") == 0 )
253 | 		{
254 | 			skipVerify = true;
255 | 		}
256 | 		else
257 | 		{
258 | 			printf("Unknown option: %s\n", argv[i]);
259 | 			return -1;
260 | 		}
261 | 	}
262 | 	// verify path
263 | 	if( wudPath[0] == '-' )
264 | 	{
265 | 		puts("Invalid input file");
266 | 		return -1;
267 | 	}
268 | 	// open input file
269 | 	wud_t* wud = wud_open(wudPath);
270 | 	if( wud == NULL )
271 | 	{
272 | 		printf("Unable to open input file \"%s\"\n", wudPath);
273 | 		return -2;
274 | 	}
275 | 	// create path of output file by replacing the extension with .wux
276 | 	char* outputPath = (char*)malloc(strlen(wudPath)+4+1); // allocate space for up to 4 extra characters in case we need to add the .wux extension
277 | 	strcpy(outputPath, wudPath);
278 | 	// replace with opposite extension (wux <-> wud) 
279 | 	char* newExtension;
280 | 	if( wud_isWUXCompressed(wud) )
281 | 	{
282 | 		printf("Mode: Decompress\n");
283 | 		newExtension = ".wud";
284 | 	}
285 | 	else
286 | 	{
287 | 		printf("Mode: Compress\n");
288 | 		newExtension = ".wux";
289 | 	}
290 | 	bool extensionFound = false;
291 | 	for(int i=strlen(outputPath)-1; i>=0; i--)
292 | 	{
293 | 		if( outputPath[i] == '.' )
294 | 		{
295 | 			extensionFound = true;
296 | 			strcpy(outputPath+i, newExtension);
297 | 			break;
298 | 		}
299 | 	}
300 | 	if( extensionFound == false )
301 | 		strcat(outputPath, newExtension);
302 | 	// make sure the output file doesn't already exist (avoid accidental overwriting)
303 | 	FILE* outputFile;
304 | 	outputFile = fopen(outputPath, "r");
305 | 	if( outputFile != NULL )
306 | 	{
307 | 		printf("Output file \"%s\" already exists.\n", outputPath);
308 | 		wud_close(wud);
309 | 		return -4;
310 | 	}
311 | 	// open output file
312 | 	outputFile = fopen(outputPath, "wb");
313 | 	if( outputFile == NULL )
314 | 	{
315 | 		printf("Unable to create output file\n");
316 | 		wud_close(wud);
317 | 		return -3;
318 | 	}
319 | 	printf("Input:\n");
320 | 	puts(wudPath);
321 | 	printf("Output:\n");
322 | 	puts(outputPath);
323 | 	if( wud_isWUXCompressed(wud) )
324 | 	{
325 | 		if( decompressWUD(wud, outputFile, outputPath) == false )
326 | 			return -1;
327 | 	}
328 | 	else
329 | 	{
330 | 		if( compressWUD(wud, outputFile, outputPath) == false )
331 | 			return -1;
332 | 	}
333 | 	// verify
334 | 	if( skipVerify == false )
335 | 	{
336 | 		if( validateWUX(wudPath, outputPath) == false )
337 | 		{
338 | 			printf("Validation failed. \"%s\" is corrupted.\n", outputPath);
339 | 			// delete output file
340 | 			remove(outputPath);
341 | 			return -5;
342 | 		}
343 | 		else
344 | 		{
345 | 			printf("Validation successful. No errors detected.\n");
346 | 		}
347 | 	}
348 | 	return 0;
349 | }


--------------------------------------------------------------------------------