Updated animtypes (a little bit) made brlan.c not spit out useless info, updated some info on pai1, and made code less RLPA biased (which is retarded). All changes were only on C files.

1 files changed, 114 insertions, 85 deletions

diff --git a/brlan.c b/brlan.c
index 54570ec..3c5146c 100644
--- a/brlan.c
+++ b/brlan.c
@@ -22,7 +22,9 @@
 #define dbgprintf	//
 #endif //DEBUGBRLAN
 
-char RLPA_FourCC[] = "RLPA";
+fourcc tag_FourCCs[] = { "RLPA", "RLTS", "RLVI", "RLVC", "RLMC", "RLTP" };
+
+char RLPA_Types[15][24];
 
 static size_t BRLAN_fileoffset = 0;
 
@@ -48,8 +50,10 @@ static void CreateGlobal_pai1(brlan_pai1_header_type2 *pai1_header, brlan_pai1_h
 		pai1_header->magic[2]		= pai1_header1.magic[2];
 		pai1_header->magic[3]		= pai1_header1.magic[3];
 		pai1_header->size		= pai1_header1.size;
-		pai1_header->unk1		= pai1_header1.unk1;
+		pai1_header->framesize		= pai1_header1.framesize;
 		pai1_header->flags		= pai1_header1.flags;
+		pai1_header->unk1		= pai1_header1.unk1;
+		pai1_header->num_timgs		= pai1_header1.num_timgs;
 		pai1_header->num_entries	= pai1_header1.num_entries;
 		pai1_header->unk2		= 0;
 		pai1_header->entry_offset	= pai1_header1.entry_offset;
@@ -57,29 +61,15 @@ static void CreateGlobal_pai1(brlan_pai1_header_type2 *pai1_header, brlan_pai1_h
 		memcpy(pai1_header, &pai1_header2, sizeof(brlan_pai1_header_type2));
 }
 
-static void DisplayRLPAData(u32 flags, RLPA_data data)
+static void DisplayTagData(u32 flags, tag_data data, int z)
 {
 	u32 p1 = be32(data.part1);
 	u32 p2 = be32(data.part2);
 	u32 p3 = be32(data.part3);
-//	if((flags & (1 << 9)) >= 1)
-		printf("					Coordinate 1: %f\n", *(f32*)(&p1));
-//	else if((flags & (1 << 17)) >= 1)
-//		printf("					Coordinate 1: %f\n", *(f32*)(&p1));
-//	else
-//		printf("					Part 1: %08x\n", p1);
-//	if((flags & (1 << 16)) >= 1)
-		printf("					Coordinate 2: %f\n", *(f32*)(&p2));
-//	else if((flags & (1 << 17)) >= 1)
-//		printf("					Coordinate 2: %f\n", *(f32*)(&p2));
-//	else
-//		printf("					Part 2: %08x\n", p2);
-//	if((flags & (1 << 16)) >= 1)
-		printf("					Coordinate 3: %f\n", *(f32*)(&p3));
-//	else if((flags & (1 << 17)) >= 1)
-//		printf("					Coordinate 3: %f\n", *(f32*)(&p3));
-//	else
-//		printf("					Part 3: %08x\n", p3);
+	printf("					Triplet %d:\n", z);
+	printf("						Frame number: %f\n", *(f32*)(&p1));
+	printf("						Value: %f\n", *(f32*)(&p2));
+	printf("						Interpolation Value: %f\n", *(f32*)(&p3));
 }
 
 static int FourCCsMatch(fourcc cc1, fourcc cc2)
@@ -90,69 +80,84 @@ static int FourCCsMatch(fourcc cc1, fourcc cc2)
 		return 0;
 }
 
-static void DisplayRLPAInformation(int idx, RLPA_header* heads, RLPA_entry** entriesx,
-			    RLPA_entryinfo** entryinfosx, RLPA_data*** datasxx)
+static int FourCCInList(fourcc cc)
+{
+	int i;
+	for(i = 0; i < 6; i++)
+		if(FourCCsMatch(cc, tag_FourCCs[i])) return 1;
+	return 0;
+}
+
+static void DisplayTagInformation(int idx, tag_header* heads, tag_entry** entriesx,
+			    tag_entryinfo** entryinfosx, tag_data*** datasxx)
 {
-	RLPA_header head = heads[idx];
-	RLPA_entry* entries = entriesx[idx];
-	RLPA_entryinfo* entryinfos = entryinfosx[idx];
-	RLPA_data** datas = datasxx[idx];
+	tag_header head = heads[idx];
+	tag_entry* entries = entriesx[idx];
+	tag_entryinfo* entryinfos = entryinfosx[idx];
+	tag_data** datas = datasxx[idx];
 	
-	printf("		Magic: %c%c%c%c\n", head.magic[0], head.magic[1], head.magic[2], head.magic[3]);
 	printf("		Number of entries: %u\n", head.entry_count);
-	printf("		Unk1: %02x\n", head.pad1);
+
+// Why should we show padding? It's 0 every single time.
+/*	printf("		Unk1: %02x\n", head.pad1);
 	printf("		Unk2: %02x\n", head.pad2);
-	printf("		Unk3: %02x\n", head.pad3);
+	printf("		Unk3: %02x\n", head.pad3); */
+
 	int i, z;
 	printf("		Entries:\n");
 	for(i = 0; i < head.entry_count; i++) {
-		printf("			Index: %u\n", i);
+		printf("			Entry %u:\n", i);
+	if(FourCCsMatch(head.magic, tag_FourCCs[0]) == 1)
+		printf("				Type: %s\n", RLPA_Types[i]);
 		printf("				Offset: %lu\n", be32(entries[i].offset));
 		printf("				Flags: %08x\n", be32(entryinfos[i].flags));
-		printf("				Unk1: %04x\n", be16(entryinfos[i].pad1));
-		printf("				Unk2: %08x\n", be32(entryinfos[i].unk1));
-		printf("				Data Count: %u\n", be16(entryinfos[i].coord_count));
+
+// Yet again, these are always the same, and seem to maybe be some marker. don't bother to show.
+/*		printf("				Unk1: %04x\n", be16(entryinfos[i].pad1));
+		printf("				Unk2: %08x\n", be32(entryinfos[i].unk1)); */
+		printf("				Triplet Count: %u\n", be16(entryinfos[i].coord_count));
+		printf("				Triplets:\n");
 		for(z = 0; z < be16(entryinfos[i].coord_count); z++)
-			DisplayRLPAData(be32(entryinfos[i].flags), datas[i][z]);
+			DisplayTagData(be32(entryinfos[i].flags), datas[i][z], z);
 	}
 }
 
-static void ReadRLPAFromBRLAN(int idx, u8* brlan_file, RLPA_header *head, RLPA_entry** entries,
-		       RLPA_entryinfo** entryinfo, RLPA_data*** data)
+static void ReadTagFromBRLAN(int idx, u8* brlan_file, tag_header *head, tag_entry** entries,
+		       tag_entryinfo** entryinfo, tag_data*** data)
 {
-	int rlpahead_location = BRLAN_fileoffset;
-	BRLAN_ReadDataFromMemory(&head[idx], brlan_file, sizeof(RLPA_header));
+	int taghead_location = BRLAN_fileoffset;
+	BRLAN_ReadDataFromMemory(&head[idx], brlan_file, sizeof(tag_header));
 	dbgprintf("read header. entry count %d\n", head[idx].entry_count);
 	int i, z;
-	entries[idx] = realloc(entries[idx], sizeof(RLPA_entry) * head[idx].entry_count);
+	entries[idx] = realloc(entries[idx], sizeof(tag_entry) * head[idx].entry_count);
 	dbgprintf("reallocated entries[idx]\n");
-	entryinfo[idx] = realloc(entryinfo[idx], sizeof(RLPA_entryinfo) * head[idx].entry_count);
+	entryinfo[idx] = realloc(entryinfo[idx], sizeof(tag_entryinfo) * head[idx].entry_count);
 	dbgprintf("reallocated entryinfo[idx]\n");
 	if(data[idx] == NULL) {
 		dbgprintf("callocating data[idx]\n");
-		data[idx] = (RLPA_data**)malloc(sizeof(RLPA_data*) * head[idx].entry_count);
+		data[idx] = (tag_data**)malloc(sizeof(tag_data*) * head[idx].entry_count);
 		dbgprintf("callocated data[idx]\n");
 	}else{
 		dbgprintf("reallocating data[idx] %08x\n", data[idx]);
-		data[idx] = (RLPA_data**)realloc(data[idx], sizeof(RLPA_data*) * head[idx].entry_count);
+		data[idx] = (tag_data**)realloc(data[idx], sizeof(tag_data*) * head[idx].entry_count);
 		dbgprintf("reallocated data[idx]\n");
 	}
 	for(i = 0; i < head[idx].entry_count; i++) {
 		dbgprintf("reading entry %d 0x%08x\n", i, &entries[idx][i]);
-		BRLAN_ReadDataFromMemory(&entries[idx][i], brlan_file, sizeof(RLPA_entry));
+		BRLAN_ReadDataFromMemory(&entries[idx][i], brlan_file, sizeof(tag_entry));
 		dbgprintf("read entry.\n");
 	}
 	for(i = 0; i < head[idx].entry_count; i++) {
 		dbgprintf("i %d cnt %d\n", i, head[idx].entry_count);
-		BRLAN_fileoffset = be32(entries[idx][i].offset) + rlpahead_location;
+		BRLAN_fileoffset = be32(entries[idx][i].offset) + taghead_location;
 		dbgprintf("read entry infos. 0x%08x\n", &entryinfo[idx][i]);
-		BRLAN_ReadDataFromMemory(&entryinfo[idx][i], brlan_file, sizeof(RLPA_entryinfo));
+		BRLAN_ReadDataFromMemory(&entryinfo[idx][i], brlan_file, sizeof(tag_entryinfo));
 		dbgprintf("read entry info 0x%08x. %u\n", &data[idx][i][0], be16(entryinfo[idx][i].coord_count));
-		data[idx][i] = realloc(NULL, sizeof(RLPA_data) * be16(entryinfo[idx][i].coord_count));
+		data[idx][i] = realloc(NULL, sizeof(tag_data) * be16(entryinfo[idx][i].coord_count));
 		dbgprintf("reallocated data[i].\n");
 		for(z = 0; z < be16(entryinfo[idx][i].coord_count); z++) {
 			dbgprintf("reading data 0x%08x\n", &data[idx][i][z]);
-			BRLAN_ReadDataFromMemory(&data[idx][i][z], brlan_file, sizeof(RLPA_data));
+			BRLAN_ReadDataFromMemory(&data[idx][i][z], brlan_file, sizeof(tag_data));
 			dbgprintf("read data.\n");
 		}
 	}
@@ -165,6 +170,22 @@ void parse_brlan(char* filename)
 		printf("Error! Couldn't open %s!\n", filename);
 		exit(1);
 	}
+	strcpy(RLPA_Types[0], "X Translation");
+	strcpy(RLPA_Types[1], "Y Translation");
+	strcpy(RLPA_Types[2], "Z Translation");
+	strcpy(RLPA_Types[3], "Unknown (Alpha?) (0x03)");
+	strcpy(RLPA_Types[4], "Unknown (0x04)");
+	strcpy(RLPA_Types[5], "Angle");
+	strcpy(RLPA_Types[6], "X Zoom");
+	strcpy(RLPA_Types[7], "Y Zoom");
+	strcpy(RLPA_Types[8], "Width");
+	strcpy(RLPA_Types[9], "Height");
+	strcpy(RLPA_Types[10], "Unknown (0x0A)");
+	strcpy(RLPA_Types[11], "Unknown (0x0B)");
+	strcpy(RLPA_Types[12], "Unknown (0x0C)");
+	strcpy(RLPA_Types[13], "Unknown (0x0D)");
+	strcpy(RLPA_Types[14], "Unknown (0x0E)");
+	strcpy(RLPA_Types[15], "Unknown (0x0F)");
 	fseek(fp, 0, SEEK_END);
 	int file_size = ftell(fp);
 	dbgprintf("Filesize is %d\n", file_size);
@@ -210,15 +231,15 @@ void parse_brlan(char* filename)
 	dbgprintf("read tag locations.\n");
 	brlan_entry *tag_entries = (brlan_entry*)calloc(tagcount, sizeof(brlan_entry));
 	dbgprintf("tag entries allocated.\n");
-	RLPA_header *RLPA_heads = NULL;
-	dbgprintf("rlpa heads created.\n");
-	RLPA_entry **RLPA_entries = NULL;
-	dbgprintf("rlpa entries created.\n");
-	RLPA_entryinfo **RLPA_entryinfos = NULL;
+	tag_header *intag_heads = NULL;
+	dbgprintf("tag heads created.\n");
+	tag_entry **intag_entries = NULL;
+	dbgprintf("tag entries created.\n");
+	tag_entryinfo **intag_entryinfos = NULL;
 	dbgprintf("rlpa entry infos created.\n");
-	RLPA_data ***RLPA_datas = NULL;
+	tag_data ***intag_datas = NULL;
 	dbgprintf("rlpa datas created.\n");
-	int RLPA_cnt = 1;
+	int intag_cnt = 1;
 	int i;
 	for(i = 0; i < tagcount; i++) {
 		BRLAN_fileoffset = be32(taglocations[i]) + be16(header.pai1_offset);
@@ -233,35 +254,35 @@ void parse_brlan(char* filename)
 		BRLAN_ReadDataFromMemoryX(magick, brlan_file, 4);
 		memcpy(CCs[i], magick, 4);
 		dbgprintf("read fourcc from %04x %02x%02x%02x%02x.\n", BRLAN_fileoffset, magick[0], magick[1], magick[2], magick[3]);
-		if(FourCCsMatch(RLPA_FourCC, CCs[i]) == 1) {
-			dbgprintf("we found a rlpa.\n");
-			RLPA_heads = realloc(RLPA_heads, sizeof(RLPA_header) * RLPA_cnt);
-			dbgprintf("reallocated rlpa heads.\n");
-			RLPA_entries = realloc(RLPA_entries, sizeof(RLPA_entry) * RLPA_cnt * 20);
-			dbgprintf("reallocated rlpa entries.\n");
-			RLPA_entryinfos = realloc(RLPA_entryinfos, sizeof(RLPA_entryinfo) * RLPA_cnt * 20);
-			dbgprintf("reallocated rlpa entryinfos.\n");
-			RLPA_datas = realloc(RLPA_datas, sizeof(RLPA_data) * RLPA_cnt * 20 * 6);
-			dbgprintf("reallocated rlpa datas.\n");
-			if(RLPA_heads == NULL) {
+		if(FourCCInList(CCs[i]) == 1) {
+			dbgprintf("we found a tag.\n");
+			intag_heads = realloc(intag_heads, sizeof(tag_header) * intag_cnt);
+			dbgprintf("reallocated tag heads.\n");
+			intag_entries = realloc(intag_entries, sizeof(tag_entry) * intag_cnt * 20);
+			dbgprintf("reallocated tag entries.\n");
+			intag_entryinfos = realloc(intag_entryinfos, sizeof(tag_entryinfo) * intag_cnt * 20);
+			dbgprintf("reallocated tag entryinfos.\n");
+			intag_datas = realloc(intag_datas, sizeof(tag_data) * intag_cnt * 20 * 6);
+			dbgprintf("reallocated tag datas.\n");
+			if(intag_heads == NULL) {
 				printf("Error allocating heads.\n");
 				exit(2);
 			}
-			if(RLPA_entries == NULL) {
+			if(intag_entries == NULL) {
 				printf("Error allocating entries.\n");
 				exit(2);
 			}
-			if(RLPA_entryinfos == NULL) {
+			if(intag_entryinfos == NULL) {
 				printf("Error allocating entryinfos.\n");
 				exit(2);
 			}
-			if(RLPA_datas == NULL) {
+			if(intag_datas == NULL) {
 				printf("Error allocating datas.\n");
 				exit(2);
 			}
-			ReadRLPAFromBRLAN(RLPA_cnt - 1, brlan_file, RLPA_heads, RLPA_entries,
-					  RLPA_entryinfos, RLPA_datas);
-			RLPA_cnt++;
+			ReadTagFromBRLAN(intag_cnt - 1, brlan_file, intag_heads, intag_entries,
+					  intag_entryinfos, intag_datas);
+			intag_cnt++;
 		}
 		dbgprintf("looping.\n");
 	}
@@ -271,31 +292,39 @@ void parse_brlan(char* filename)
 	printf("	Magic: %c%c%c%c\n", header.magic[0], header.magic[1], header.magic[2], header.magic[3]);
 	printf("	Filesize: %lu\n", be32(header.file_size));
 	printf("		%s real file size!\n", be32(header.file_size) == file_size ? "Matches" : "Does not match");
-	printf("	pai1 Offset: %04x\n", be16(header.pai1_offset));
-	printf("	pai1 Count: %04x\n", be16(header.pai1_count));
+
+// Not important to user, why bother.
+/*	printf("	pai1 Offset: %04x\n", be16(header.pai1_offset));
+	printf("	pai1 Count: %04x\n", be16(header.pai1_count)); */
 	printf("\npai1 header:\n");
 	printf("	Type: %d\n", pai1_header_type);
 	printf("	Magic: %c%c%c%c\n", pai1_header.magic[0], pai1_header.magic[1], pai1_header.magic[2], pai1_header.magic[3]);
 	printf("	Size: %lu\n", be32(pai1_header.size));
-	printf("	unk1: %08lx\n", be32(pai1_header.unk1));
-	printf("	Flags: %04x\n", be16(pai1_header.flags));
+	printf("	Framesize: %u\n", be16(pai1_header.framesize));
+	printf("	Flags: %02x\n", pai1_header.flags);
+	printf("	unk1: %02x\n", pai1_header.unk1);
+	printf("	Number of Textures: %u\n", be16(pai1_header.num_timgs));
 	printf("	Number of Entries: %u\n", be16(pai1_header.num_entries));
 	printf("	unk2: %08lx\n", be32(pai1_header.unk2));
-	printf("	Offset to Entries: 0x%08lx\n", be32(pai1_header.entry_offset));
+		
+// Not important to user, why bother.
+//	printf("	Offset to Entries: 0x%08lx\n", be32(pai1_header.entry_offset));
+
 	printf("\nBRLAN entries:");
-	RLPA_cnt = 0;
+	intag_cnt = 0;
 	for(i = 0; i < tagcount; i++) {
-		printf("\n	Index: %u\n", i);
+		printf("\n	Entry %u:\n", i);
 		printf("		Name: %s\n", tag_entries[i].name);
 		printf("		Flags: %08x\n", be32(tag_entries[i].flags));
-		printf("		Animation Header Length: %lu\n", be32(tag_entries[i].anim_header_len));		
+// Not important to user, why bother.
+//		printf("		Animation Header Length: %lu\n", be32(tag_entries[i].anim_header_len));		
 		printf("		FourCC: %c%c%c%c\n", CCs[i][0], CCs[i][1], CCs[i][2], CCs[i][3]);
-		if(FourCCsMatch(RLPA_FourCC, CCs[i]) == 1) {
-			dbgprintf("found rlpa. cnt %d.\n", RLPA_cnt);
-			DisplayRLPAInformation(RLPA_cnt, RLPA_heads, RLPA_entries, RLPA_entryinfos, RLPA_datas);
-			RLPA_cnt++;
+		if(FourCCInList(CCs[i]) == 1) {
+			dbgprintf("found tag. cnt %d.\n", intag_cnt);
+			DisplayTagInformation(intag_cnt, intag_heads, intag_entries, intag_entryinfos, intag_datas);
+			intag_cnt++;
 		}else{
-			printf("		Sorry, this type is currently unsupported.\n");
+			printf("		Sorry, this type is currently unknown.\n");
 		}
 	}
 	free(brlan_file);