unix line endings; indent

svn-id: r4740

2 files changed, 379 insertions, 366 deletions

diff --git a/bundle.cpp b/bundle.cpp
index 8b1e9c8d99..14486838b5 100644
--- a/bundle.cpp
+++ b/bundle.cpp
@@ -23,22 +23,25 @@
 #include "scummsys.h"
 #include "bundle.h"
 
-Bundle::Bundle(Scumm * parent) {
+Bundle::Bundle(Scumm *parent)
+{
 	_voiceFile = NULL;
 	_musicFile = NULL;
 	_scumm = parent;
 	_lastSong = -1;
 }
 
-Bundle::~Bundle() {
+Bundle::~Bundle()
+{
 	if (_voiceFile != NULL)
-		fclose (_voiceFile);
+		fclose(_voiceFile);
 
 	if (_musicFile != NULL)
-		fclose (_musicFile);
+		fclose(_musicFile);
 }
 
-bool Bundle::openVoiceFile(char * filename) {
+bool Bundle::openVoiceFile(char *filename)
+{
 	int32 tag, offset;
 
 	if (_voiceFile != NULL) {
@@ -63,7 +66,7 @@ bool Bundle::openVoiceFile(char * filename) {
 		char name[13], c;
 		int32 z = 0;
 		int32 z2;
-			
+
 		for (z2 = 0; z2 < 8; z2++)
 			if ((c = _scumm->fileReadByte(_voiceFile)) != 0)
 				name[z++] = c;
@@ -80,7 +83,8 @@ bool Bundle::openVoiceFile(char * filename) {
 	return true;
 }
 
-bool Bundle::openMusicFile(char * filename) {
+bool Bundle::openMusicFile(char *filename)
+{
 	int32 tag, offset;
 
 	if (_musicFile != NULL) {
@@ -105,12 +109,12 @@ bool Bundle::openMusicFile(char * filename) {
 		char name[13], c;
 		int z = 0;
 		int z2;
-			
-		for (z2 = 0;z2 < 8; z2++)
+
+		for (z2 = 0; z2 < 8; z2++)
 			if ((c = _scumm->fileReadByte(_musicFile)) != 0)
 				name[z++] = c;
 		name[z++] = '.';
-		for (z2 = 0;z2 < 4; z2++)
+		for (z2 = 0; z2 < 4; z2++)
 			if ((c = _scumm->fileReadByte(_musicFile)) != 0)
 				name[z++] = c;
 		name[z] = '\0';
@@ -122,9 +126,10 @@ bool Bundle::openMusicFile(char * filename) {
 	return true;
 }
 
-int32 Bundle::decompressVoiceSampleByIndex(int32 index, byte * comp_final) {
+int32 Bundle::decompressVoiceSampleByIndex(int32 index, byte *comp_final)
+{
 	int32 i, tag, num, final_size, output_size;
-	byte * comp_input, * comp_output;
+	byte *comp_input, *comp_output;
 
 	if (_voiceFile == NULL) {
 		printf("Bundle: voice file is not open !\n");
@@ -136,16 +141,17 @@ int32 Bundle::decompressVoiceSampleByIndex(int32 index, byte * comp_final) {
 	num = _scumm->fileReadDwordBE(_voiceFile);
 	_scumm->fileReadDwordBE(_voiceFile);
 	_scumm->fileReadDwordBE(_voiceFile);
-	
+
 	if (tag != MKID_BE('COMP')) {
-		warning("Bundle: Compressed sound %d invalid (%c%c%c%c)", index, tag>>24, tag>>16, tag>>8, tag);
+		warning("Bundle: Compressed sound %d invalid (%c%c%c%c)", index, tag >> 24, tag >> 16, tag >> 8,
+						tag);
 		return 0;
 	}
 
 	for (i = 0; i < num; i++) {
 		_compVoiceTable[i].offset = _scumm->fileReadDwordBE(_voiceFile);
-		_compVoiceTable[i].size   = _scumm->fileReadDwordBE(_voiceFile);
-		_compVoiceTable[i].codec  = _scumm->fileReadDwordBE(_voiceFile);
+		_compVoiceTable[i].size = _scumm->fileReadDwordBE(_voiceFile);
+		_compVoiceTable[i].codec = _scumm->fileReadDwordBE(_voiceFile);
 		_scumm->fileReadDwordBE(_voiceFile);
 	}
 
@@ -153,12 +159,13 @@ int32 Bundle::decompressVoiceSampleByIndex(int32 index, byte * comp_final) {
 
 	comp_output = (byte *)malloc(10000);
 	for (i = 0; i < num; i++) {
-		comp_input  = (byte *)malloc(_compVoiceTable[i].size);
+		comp_input = (byte *)malloc(_compVoiceTable[i].size);
 
 		_scumm->fileSeek(_voiceFile, _bundleVoiceTable[index].offset + _compVoiceTable[i].offset, SEEK_SET);
 		_scumm->fileRead(_voiceFile, comp_input, _compVoiceTable[i].size);
 
-		output_size = decompressCodec(_compVoiceTable[i].codec, comp_input, comp_output, _compVoiceTable[i].size);
+		output_size =
+			decompressCodec(_compVoiceTable[i].codec, comp_input, comp_output, _compVoiceTable[i].size);
 		memcpy((byte *)&comp_final[final_size], comp_output, output_size);
 		final_size += output_size;
 
@@ -169,9 +176,10 @@ int32 Bundle::decompressVoiceSampleByIndex(int32 index, byte * comp_final) {
 	return final_size;
 }
 
-int32 Bundle::decompressMusicSampleByIndex(int32 index, int32 number, byte * comp_final) {
+int32 Bundle::decompressMusicSampleByIndex(int32 index, int32 number, byte *comp_final)
+{
 	int32 i, tag, num, final_size;
-	byte * comp_input;
+	byte *comp_input;
 
 	if (_musicFile == NULL) {
 		printf("Bundle: music file is not open !\n");
@@ -184,25 +192,28 @@ int32 Bundle::decompressMusicSampleByIndex(int32 index, int32 number, byte * com
 		num = _scumm->fileReadDwordBE(_musicFile);
 		_scumm->fileReadDwordBE(_musicFile);
 		_scumm->fileReadDwordBE(_musicFile);
-	
+
 		if (tag != MKID_BE('COMP')) {
-			warning("Bundle: Compressed sound %d invalid (%c%c%c%c)", index, tag>>24, tag>>16, tag>>8, tag);
+			warning("Bundle: Compressed sound %d invalid (%c%c%c%c)", index, tag >> 24, tag >> 16, tag >> 8,
+							tag);
 			return 0;
 		}
 
 		for (i = 0; i < num; i++) {
 			_compMusicTable[i].offset = _scumm->fileReadDwordBE(_musicFile);
-			_compMusicTable[i].size   = _scumm->fileReadDwordBE(_musicFile);
-			_compMusicTable[i].codec  = _scumm->fileReadDwordBE(_musicFile);
+			_compMusicTable[i].size = _scumm->fileReadDwordBE(_musicFile);
+			_compMusicTable[i].codec = _scumm->fileReadDwordBE(_musicFile);
 			_scumm->fileReadDwordBE(_musicFile);
 		}
 	}
 
-	comp_input  = (byte *)malloc(_compMusicTable[number].size);
+	comp_input = (byte *)malloc(_compMusicTable[number].size);
 
-	_scumm->fileSeek(_musicFile, _bundleMusicTable[index].offset + _compMusicTable[number].offset, SEEK_SET);
+	_scumm->fileSeek(_musicFile, _bundleMusicTable[index].offset + _compMusicTable[number].offset,
+									 SEEK_SET);
 	_scumm->fileRead(_musicFile, comp_input, _compMusicTable[number].size);
-	final_size = decompressCodec(_compMusicTable[number].codec, comp_input, comp_final, _compMusicTable[number].size);
+	final_size =
+		decompressCodec(_compMusicTable[number].codec, comp_input, comp_final, _compMusicTable[number].size);
 
 	free(comp_input);
 
@@ -212,9 +223,10 @@ int32 Bundle::decompressMusicSampleByIndex(int32 index, int32 number, byte * com
 }
 
 
-int32 Bundle::decompressVoiceSampleByName(char * name, byte * comp_final) {
+int32 Bundle::decompressVoiceSampleByName(char *name, byte *comp_final)
+{
 	int32 final_size = 0, i;
-	
+
 	if (_voiceFile == NULL) {
 		printf("Bundle: voice file is not open !\n");
 		return 0;
@@ -224,14 +236,15 @@ int32 Bundle::decompressVoiceSampleByName(char * name, byte * comp_final) {
 		if (!scumm_stricmp(name, _bundleVoiceTable[i].filename)) {
 			final_size = decompressVoiceSampleByIndex(i, comp_final);
 			return final_size;
-		}			
-	} 
+		}
+	}
 	return final_size;
 }
 
-int32 Bundle::decompressMusicSampleByName(char * name, int32 number, byte * comp_final) {
+int32 Bundle::decompressMusicSampleByName(char *name, int32 number, byte *comp_final)
+{
 	int32 final_size = 0, i;
-	
+
 	if (_voiceFile == NULL) {
 		printf("Bundle: voice file is not open !\n");
 		return 0;
@@ -241,8 +254,8 @@ int32 Bundle::decompressMusicSampleByName(char * name, int32 number, byte * comp
 		if (!scumm_stricmp(name, _bundleMusicTable[i].filename)) {
 			final_size = decompressMusicSampleByIndex(i, number, comp_final);
 			return final_size;
-		}			
-	} 
+		}
+	}
 	return final_size;
 }
 
@@ -258,7 +271,8 @@ int32 Bundle::getNumberOfMusicSamplesByIndex(int32 index)
 	return _scumm->fileReadDwordBE(_musicFile);
 }
 
-int32 Bundle::getNumberOfMusicSamplesByName(char * name) {
+int32 Bundle::getNumberOfMusicSamplesByName(char *name)
+{
 	int32 number = 0, i;
 
 	if (_musicFile == NULL) {
@@ -268,7 +282,7 @@ int32 Bundle::getNumberOfMusicSamplesByName(char * name) {
 
 	for (i = 0; i < _numMusicFiles; i++) {
 		if (!scumm_stricmp(name, _bundleMusicTable[i].filename)) {
-			number = getNumberOfMusicSamplesByIndex (i);
+			number = getNumberOfMusicSamplesByIndex(i);
 			return number;
 		}
 	}
@@ -277,18 +291,17 @@ int32 Bundle::getNumberOfMusicSamplesByName(char * name) {
 
 #define NextBit bit = mask & 1; mask >>= 1; if (!--bitsleft) {mask = READ_LE_UINT16(srcptr); srcptr += 2; bitsleft=16;}
 
-int32 Bundle::compDecode(byte * src, byte * dst) {
-	byte * result, * srcptr = src, * dstptr = dst;
-	int data, size, bit, bitsleft = 16, mask = READ_LE_UINT16(srcptr);	
+int32 Bundle::compDecode(byte *src, byte *dst)
+{
+	byte *result, *srcptr = src, *dstptr = dst;
+	int data, size, bit, bitsleft = 16, mask = READ_LE_UINT16(srcptr);
 	srcptr += 2;
 
-	while(1) {
-		NextBit
-		if (bit) {
+	while (1) {
+		NextBit if (bit) {
 			*dstptr++ = *srcptr++;
 		} else {
-			NextBit
-			if (!bit) {
+			NextBit if (!bit) {
 				NextBit size = bit << 1;
 				NextBit size = (size | bit) + 3;
 				data = *srcptr++ | 0xffffff00;
@@ -300,347 +313,348 @@ int32 Bundle::compDecode(byte * src, byte * dst) {
 				size = (size & 0x0f) + 3;
 
 				if (size == 3)
-			 		if (((*srcptr++) + 1) == 1)
+					if (((*srcptr++) + 1) == 1)
 						return dstptr - dst;
 			}
-			result = dstptr+data;
-			while (size--) 
+			result = dstptr + data;
+			while (size--)
 				*dstptr++ = *result++;
 		}
 	}
 }
 #undef NextBit
 
-int32 Bundle::decompressCodec(int32 codec, byte * comp_input, byte * comp_output, int32 input_size) {
+int32 Bundle::decompressCodec(int32 codec, byte *comp_input, byte *comp_output, int32 input_size)
+{
 	int32 output_size = input_size;
 	int32 offset1, offset2, offset3, length, k, c, s, j, r, t, z;
-	byte * src, * t_table, * p, * ptr;
+	byte *src, *t_table, *p, *ptr;
 	byte t_tmp1, t_tmp2;
 
-	switch(codec) {
-		case 0:
-			memcpy(comp_output, comp_input, output_size);
+	switch (codec) {
+	case 0:
+		memcpy(comp_output, comp_input, output_size);
 		break;
 
-		case 1:
-			output_size = compDecode(comp_input, comp_output);
+	case 1:
+		output_size = compDecode(comp_input, comp_output);
 		break;
 
-		case 2:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
+	case 2:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
 		break;
 
-		case 3: 
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
+	case 3:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
 		break;
 
-		case 4:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-			
-			t_table = (byte*)malloc(output_size);
-			memset (t_table, 0, output_size);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 0;
-			if (length > 0)
-			{
-				c = -12;
-				s = 0;
-				j = 0;
-				do {
-					ptr = src + length + (k / 2);
-					if (k & 1) {
-						r = c / 8;
-						*(t_table + r + 2) = ((*(src + j) & 0x0f) << 4) | ((*(ptr + 1) & 0xf0) >> 4);
-						*(t_table + r + 1) = (*(src + j) & 0xf0) | (*(t_table + r + 1));
-					} else {
-						r = s / 8;
-						*(t_table + r + 0) = ((*(src + j) & 0x0f) << 4) | (*ptr & 0x0f);
-						*(t_table + r + 1) = (*(src + j) & 0xf0) >> 4;
-					}
-					s += 12;
-					k++;
-					j++;
-					c += 12;
-				} while (k < length);
-			}
-			offset1 = ((length - 1) * 3) / 2;
-			*(t_table + offset1 + 1) = (*(t_table + offset1 + 1)) | *(src + length - 1) & 0xf0;
-			memcpy(src, t_table, output_size);
-			free (t_table);
+	case 4:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memset(t_table, 0, output_size);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 0;
+		if (length > 0) {
+			c = -12;
+			s = 0;
+			j = 0;
+			do {
+				ptr = src + length + (k / 2);
+				if (k & 1) {
+					r = c / 8;
+					*(t_table + r + 2) = ((*(src + j) & 0x0f) << 4) | ((*(ptr + 1) & 0xf0) >> 4);
+					*(t_table + r + 1) = (*(src + j) & 0xf0) | (*(t_table + r + 1));
+				} else {
+					r = s / 8;
+					*(t_table + r + 0) = ((*(src + j) & 0x0f) << 4) | (*ptr & 0x0f);
+					*(t_table + r + 1) = (*(src + j) & 0xf0) >> 4;
+				}
+				s += 12;
+				k++;
+				j++;
+				c += 12;
+			} while (k < length);
+		}
+		offset1 = ((length - 1) * 3) / 2;
+		*(t_table + offset1 + 1) = (*(t_table + offset1 + 1)) | *(src + length - 1) & 0xf0;
+		memcpy(src, t_table, output_size);
+		free(t_table);
 		break;
 
-		case 5:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-			
-			t_table = (byte*)malloc(output_size);
-			memset (t_table, 0, output_size);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 1;
-			c = 0;
-			s = 12;
-			*t_table = (*(src + length)) >> 4;
-			t = length + k;
-			j = 1;
-			if (t > k) {
-				do {
-					ptr = src + length + (k / 2);
-					if (k & 1) {
-						r = c / 8;
-						*(t_table + r + 0) =  (*(src + j - 1) & 0xf0) | (*(t_table + r));
-						*(t_table + r + 1) = ((*(src + j - 1) & 0x0f) << 4) | (*ptr & 0x0f);
-					} else {
-						r = s / 8;
-						*(t_table + r + 0) = (*(src + j - 1) & 0xf0) >> 4;
-						*(t_table + r - 1) = ((*(src + j - 1) & 0x0f) << 4) | ((*ptr & 0xf0) >> 4);
-					}
-					s += 12;
-					k++;
-					j++;
-					c += 12;
-				} while (k < t);
-			}
-			memcpy(src, t_table, output_size);
-			free (t_table);
+	case 5:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memset(t_table, 0, output_size);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 1;
+		c = 0;
+		s = 12;
+		*t_table = (*(src + length)) >> 4;
+		t = length + k;
+		j = 1;
+		if (t > k) {
+			do {
+				ptr = src + length + (k / 2);
+				if (k & 1) {
+					r = c / 8;
+					*(t_table + r + 0) = (*(src + j - 1) & 0xf0) | (*(t_table + r));
+					*(t_table + r + 1) = ((*(src + j - 1) & 0x0f) << 4) | (*ptr & 0x0f);
+				} else {
+					r = s / 8;
+					*(t_table + r + 0) = (*(src + j - 1) & 0xf0) >> 4;
+					*(t_table + r - 1) = ((*(src + j - 1) & 0x0f) << 4) | ((*ptr & 0xf0) >> 4);
+				}
+				s += 12;
+				k++;
+				j++;
+				c += 12;
+			} while (k < t);
+		}
+		memcpy(src, t_table, output_size);
+		free(t_table);
 		break;
 
-		case 6:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-			
-			t_table = (byte*)malloc(output_size);
-			memset (t_table, 0, output_size);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 0;
-			c = 0;
-			j = 0;
-			s = -12;
-			*t_table = *(output_size + src - 1);
-			*(t_table + output_size - 1) = *(src + length - 1);
-			t = length - 1;
-			if (t > 0) {
-				do {
-					ptr = src + length + (k / 2);
-					if (k & 1) {
-						r = s / 8;
-						*(t_table + r + 2) = (*(src + j) & 0xf0) | *(t_table + r + 2);
-						*(t_table + r + 3) = ((*(src + j) & 0x0f) << 4) | ((*ptr & 0xf0) >> 4);
-					} else {
-						r = c / 8;
-						*(t_table + r + 2) = (*(src + j) & 0xf0) >> 4;
-						*(t_table + r + 1) = ((*(src + j) & 0x0f) << 4) | (*ptr & 0x0f);
-					}
-					s += 12;
-					k++;
-					j++;
-					c += 12;
-				} while (k < t);
-			}
-			memcpy(src, t_table, output_size);
-			free (t_table);
+	case 6:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memset(t_table, 0, output_size);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 0;
+		c = 0;
+		j = 0;
+		s = -12;
+		*t_table = *(output_size + src - 1);
+		*(t_table + output_size - 1) = *(src + length - 1);
+		t = length - 1;
+		if (t > 0) {
+			do {
+				ptr = src + length + (k / 2);
+				if (k & 1) {
+					r = s / 8;
+					*(t_table + r + 2) = (*(src + j) & 0xf0) | *(t_table + r + 2);
+					*(t_table + r + 3) = ((*(src + j) & 0x0f) << 4) | ((*ptr & 0xf0) >> 4);
+				} else {
+					r = c / 8;
+					*(t_table + r + 2) = (*(src + j) & 0xf0) >> 4;
+					*(t_table + r + 1) = ((*(src + j) & 0x0f) << 4) | (*ptr & 0x0f);
+				}
+				s += 12;
+				k++;
+				j++;
+				c += 12;
+			} while (k < t);
+		}
+		memcpy(src, t_table, output_size);
+		free(t_table);
 		break;
 
-		case 10: 
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-
-			t_table = (byte*)malloc(output_size);
-			memcpy (t_table, p, output_size);
-
-			offset1 = output_size / 3;
-			offset2 = offset1 * 2;
-			offset3 = offset2;
-			src = comp_output;
+	case 10:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memcpy(t_table, p, output_size);
+
+		offset1 = output_size / 3;
+		offset2 = offset1 * 2;
+		offset3 = offset2;
+		src = comp_output;
+		do {
+			if (offset1 == 0)
+				break;
+			offset1--;
+			offset2 -= 2;
+			offset3--;
+			*(t_table + offset2 + 0) = *(src + offset1);
+			*(t_table + offset2 + 1) = *(src + offset3);
+		} while (1);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 0;
+		if (length > 0) {
+			c = -12;
+			s = 0;
 			do {
-				if (offset1 == 0) break;
-				offset1--;
-				offset2 -= 2;
-				offset3--;
-				*(t_table + offset2 + 0) = *(src + offset1);
-				*(t_table + offset2 + 1) = *(src + offset3);
-			} while(1);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 0;
-			if (length > 0)
-			{
-				c = -12;
-				s = 0;
-				do {
-					j = length + (k / 2);
-					if (k & 1) {
-						r = c / 8;
-						t_tmp1 = *(t_table + k);
-						t_tmp2 = *(t_table + j + 1);
-						*(src + r + 2) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
-						*(src + r + 1) = (*(src + r + 1)) | (t_tmp1 & 0xf0);
-					} else {
-						r = s / 8;
-						t_tmp1 = *(t_table + k);
-						t_tmp2 = *(t_table + j);
-						*(src + r + 0) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
-						*(src + r + 1) = ((t_tmp1 & 0xf0) >> 4);
-					}
-					s += 12;
-					k++;
-					c += 12;
-				} while (k < length);
-			}
-			offset1 = ((length - 1) * 3) / 2;
-			*(src + offset1 + 1) = (*(t_table + length) & 0xf0) | *(src + offset1 + 1);
-			free (t_table);
+				j = length + (k / 2);
+				if (k & 1) {
+					r = c / 8;
+					t_tmp1 = *(t_table + k);
+					t_tmp2 = *(t_table + j + 1);
+					*(src + r + 2) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
+					*(src + r + 1) = (*(src + r + 1)) | (t_tmp1 & 0xf0);
+				} else {
+					r = s / 8;
+					t_tmp1 = *(t_table + k);
+					t_tmp2 = *(t_table + j);
+					*(src + r + 0) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
+					*(src + r + 1) = ((t_tmp1 & 0xf0) >> 4);
+				}
+				s += 12;
+				k++;
+				c += 12;
+			} while (k < length);
+		}
+		offset1 = ((length - 1) * 3) / 2;
+		*(src + offset1 + 1) = (*(t_table + length) & 0xf0) | *(src + offset1 + 1);
+		free(t_table);
 		break;
 
-		case 11:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-
-			t_table = (byte*)malloc(output_size);
-			memcpy (t_table, p, output_size);
-
-			offset1 = output_size / 3;
-			offset2 = offset1 * 2;
-			offset3 = offset2;
-			src = comp_output;
+	case 11:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memcpy(t_table, p, output_size);
+
+		offset1 = output_size / 3;
+		offset2 = offset1 * 2;
+		offset3 = offset2;
+		src = comp_output;
+		do {
+			if (offset1 == 0)
+				break;
+			offset1--;
+			offset2 -= 2;
+			offset3--;
+			*(t_table + offset2 + 0) = *(src + offset1);
+			*(t_table + offset2 + 1) = *(src + offset3);
+		} while (1);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 1;
+		c = 0;
+		s = 12;
+		t_tmp1 = (*(t_table + length)) >> 4;
+		*(src) = t_tmp1;
+		t = length + k;
+		if (t > k) {
 			do {
-				if (offset1 == 0) break;
-				offset1--;
-				offset2 -= 2;
-				offset3--;
-				*(t_table + offset2 + 0) = *(src + offset1);
-				*(t_table + offset2 + 1) = *(src + offset3);
-			} while(1);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 1;
-			c = 0;
-			s = 12;
-			t_tmp1 = (*(t_table + length)) >> 4;
-			*(src) = t_tmp1;
-			t = length + k;
-			if (t > k) {
-				do {
-					j = length + (k / 2);
-					if (k & 1) {
-						r = c / 8;
-						t_tmp1 = *(t_table + k - 1);
-						t_tmp2 = *(t_table + j);
-						*(src + r + 0) = (*(src + r)) | (t_tmp1 & 0xf0);
-						*(src + r + 1) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
-					} else {
-						r = s / 8;
-						t_tmp1 = *(t_table + k - 1);
-						t_tmp2 = *(t_table + j);
-						*(src + r + 0) = (t_tmp1 & 0xf0) >> 4;
-						*(src + r - 1) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
-					}
-					s += 12;
-					k++;
-					c += 12;
-				} while (k < t);
-			}
-			free (t_table);
+				j = length + (k / 2);
+				if (k & 1) {
+					r = c / 8;
+					t_tmp1 = *(t_table + k - 1);
+					t_tmp2 = *(t_table + j);
+					*(src + r + 0) = (*(src + r)) | (t_tmp1 & 0xf0);
+					*(src + r + 1) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
+				} else {
+					r = s / 8;
+					t_tmp1 = *(t_table + k - 1);
+					t_tmp2 = *(t_table + j);
+					*(src + r + 0) = (t_tmp1 & 0xf0) >> 4;
+					*(src + r - 1) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
+				}
+				s += 12;
+				k++;
+				c += 12;
+			} while (k < t);
+		}
+		free(t_table);
 		break;
 
-		case 12:
-			output_size = compDecode(comp_input, comp_output);
-			p = comp_output;
-			for (z = 2; z < output_size; z++)
-				p[z] += p[z - 1];
-			for (z = 1; z < output_size; z++)
-				p[z] += p[z - 1];
-
-			t_table = (byte*)malloc(output_size);
-			memcpy (t_table, p, output_size);
-
-			offset1 = output_size / 3;
-			offset2 = offset1 * 2;
-			offset3 = offset2;
-			src = comp_output;
+	case 12:
+		output_size = compDecode(comp_input, comp_output);
+		p = comp_output;
+		for (z = 2; z < output_size; z++)
+			p[z] += p[z - 1];
+		for (z = 1; z < output_size; z++)
+			p[z] += p[z - 1];
+
+		t_table = (byte *)malloc(output_size);
+		memcpy(t_table, p, output_size);
+
+		offset1 = output_size / 3;
+		offset2 = offset1 * 2;
+		offset3 = offset2;
+		src = comp_output;
+		do {
+			if (offset1 == 0)
+				break;
+			offset1--;
+			offset2 -= 2;
+			offset3--;
+			*(t_table + offset2 + 0) = *(src + offset1);
+			*(t_table + offset2 + 1) = *(src + offset3);
+		} while (1);
+
+		src = comp_output;
+		length = (output_size * 8) / 12;
+		k = 0;
+		c = 0;
+		s = -12;
+		*(src) = *(output_size + t_table - 1);
+		*(src + output_size - 1) = *(t_table + length - 1);
+		t = length - 1;
+		if (t > 0) {
 			do {
-				if (offset1 == 0) break;
-				offset1--;
-				offset2 -= 2;
-				offset3--;
-				*(t_table + offset2 + 0) = *(src + offset1);
-				*(t_table + offset2 + 1) = *(src + offset3);
-			} while(1);
-
-			src = comp_output;
-			length = (output_size * 8) / 12;
-			k = 0;
-			c = 0;
-			s = -12;
-			*(src) = *(output_size + t_table - 1);
-			*(src + output_size - 1) = *(t_table + length - 1);
-			t = length - 1;
-			if (t > 0) {
-				do {
-					j = length + (k / 2);
-					if (k & 1) {
-						r = s / 8;
-						t_tmp1 = *(t_table + k);
-						t_tmp2 = *(t_table + j);
-						*(src + r + 2) = (*(src + r + 2)) | (t_tmp1 & 0xf0);
-						*(src + r + 3) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
-					} else {
-						r = c / 8;
-						t_tmp1 = *(t_table + k);
-						t_tmp2 = *(t_table + j);
-						*(src + r + 2) = (t_tmp1 & 0xf0) >> 4;
-						*(src + r + 1) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
-					}
-					s += 12;
-					k++;
-					c += 12;
-				} while (k < t);
-			}
-			free (t_table);
+				j = length + (k / 2);
+				if (k & 1) {
+					r = s / 8;
+					t_tmp1 = *(t_table + k);
+					t_tmp2 = *(t_table + j);
+					*(src + r + 2) = (*(src + r + 2)) | (t_tmp1 & 0xf0);
+					*(src + r + 3) = ((t_tmp1 & 0x0f) << 4) | ((t_tmp2 & 0xf0) >> 4);
+				} else {
+					r = c / 8;
+					t_tmp1 = *(t_table + k);
+					t_tmp2 = *(t_table + j);
+					*(src + r + 2) = (t_tmp1 & 0xf0) >> 4;
+					*(src + r + 1) = ((t_tmp1 & 0x0f) << 4) | (t_tmp2 & 0x0f);
+				}
+				s += 12;
+				k++;
+				c += 12;
+			} while (k < t);
+		}
+		free(t_table);
 		break;
 
-		default:
-			printf("Bundle: Unknown codec %d!\n", (int)codec);
-			output_size = 0;
+	default:
+		printf("Bundle: Unknown codec %d!\n", (int)codec);
+		output_size = 0;
 		break;
 	}
 
 	return output_size;
 }
-
diff --git a/bundle.h b/bundle.h
index 4cac1e6d18..912bd74e36 100644
--- a/bundle.h
+++ b/bundle.h
@@ -41,32 +41,31 @@ class Bundle {
 protected:
 
 private:
-	int32 compDecode(byte * src, byte * dst);
-	int32 decompressCodec(int32 codec, byte * comp_input, byte * comp_output, int32 size);
+	int32 compDecode(byte *src, byte *dst);
+	int32 decompressCodec(int32 codec, byte *comp_input, byte *comp_output, int32 size);
 	CompTable _compVoiceTable[50];
 	CompTable _compMusicTable[2500];
-	FILE * _voiceFile;
-	FILE * _musicFile;
-	BundleAudioTable * _bundleVoiceTable;
-	BundleAudioTable * _bundleMusicTable;
+	FILE *_voiceFile;
+	FILE *_musicFile;
+	BundleAudioTable *_bundleVoiceTable;
+	BundleAudioTable *_bundleMusicTable;
 	int32 _numVoiceFiles;
 	int32 _numMusicFiles;
-	Scumm * _scumm;
+	Scumm *_scumm;
 	int32 _lastSong;
 
 public:
-	Bundle(Scumm * parent);
-	~Bundle();
+	  Bundle(Scumm *parent);
+	 ~Bundle();
 
-	bool openVoiceFile(char * filename);
-	bool openMusicFile(char * filename);
-	int32 decompressVoiceSampleByName(char * name, byte * comp_final);
-	int32 decompressVoiceSampleByIndex(int32 index, byte * comp_final);
-	int32 decompressMusicSampleByName(char * name, int32 number, byte * comp_final);
-	int32 decompressMusicSampleByIndex(int32 index, int32 number, byte * comp_final);
+	bool openVoiceFile(char *filename);
+	bool openMusicFile(char *filename);
+	int32 decompressVoiceSampleByName(char *name, byte *comp_final);
+	int32 decompressVoiceSampleByIndex(int32 index, byte *comp_final);
+	int32 decompressMusicSampleByName(char *name, int32 number, byte *comp_final);
+	int32 decompressMusicSampleByIndex(int32 index, int32 number, byte *comp_final);
 	int32 getNumberOfMusicSamplesByIndex(int32 index);
-	int32 getNumberOfMusicSamplesByName(char * name);
+	int32 getNumberOfMusicSamplesByName(char *name);
 };
 
 #endif
-