Added (partially) functional XML -> BRLAN converter to C side Benzin. Added some other new fun stuff. Look at the converter please comex, its output doesn't work in parse-brlan but works in C benzin.

13 files changed, 730 insertions, 69 deletions

diff --git a/Makefile b/Makefile
index 849eced..6026ace 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,7 @@
-OBJECTS = main.o general.o brlyt.o brlan.o
+OBJECTS = main.o general.o brlyt.o brlan.o memfile.o xml.o
+LIBS = -lmxml
 OUTPUT = benzin
 main: $(OBJECTS)
-	gcc -o $(OUTPUT) $(OBJECTS)
+	gcc -o $(OUTPUT) $(LIBS) $(OBJECTS)
 clean:
 	rm -f $(OUTPUT) $(OBJECTS)
diff --git a/animtypes.txt b/animtypes.txt
index a059f83..b77cfdc 100644
--- a/animtypes.txt
+++ b/animtypes.txt
@@ -2,7 +2,7 @@ RLPA
 0   translateX
 1   translateY
 2   translateZ
-3   pane_unk1  (Related to Alpha? See GH3 banner)
+3   pane_unk1
 4   pane_unk2
 5   angle
 6   xmag
diff --git a/brlan.c b/brlan.c
index 8d10cb2..a1ac601 100644
--- a/brlan.c
+++ b/brlan.c
@@ -10,11 +10,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
+#include <mxml.h>
 
+#include "memfile.h"
 #include "types.h"
 #include "brlan.h"
-
-//#define DEBUGBRLAN
+#include "xml.h"
 
 #ifdef DEBUGBRLAN
 #define dbgprintf	printf
@@ -22,9 +24,11 @@
 #define dbgprintf	//
 #endif //DEBUGBRLAN
 
+#define MAXIMUM_TAGS_SIZE		(0x1000)
+
 fourcc tag_FourCCs[] = { "RLPA", "RLTS", "RLVI", "RLVC", "RLMC", "RLTP" };
 
-char RLPA_Types[15][24];
+char tag_types_list[15][24];
 
 static size_t BRLAN_fileoffset = 0;
 
@@ -61,7 +65,7 @@ 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 DisplayTagData(u32 flags, tag_data data, int z)
+static void DisplayTagData(tag_data data, int z)
 {
 	u32 p1 = be32(data.part1);
 	u32 p2 = be32(data.part2);
@@ -108,19 +112,20 @@ static void DisplayTagInformation(int idx, tag_header* heads, tag_entry** entrie
 	for(i = 0; i < head.entry_count; i++) {
 		printf("			Entry %u:\n", i);
 	if(FourCCsMatch(head.magic, tag_FourCCs[0]) == 1)
-		printf("				Type: %s\n", RLPA_Types[i]);
+//		printf("				Type: %04x\n", be16(entryinfos[i].type));
+		printf("				Type: %s (%04x)\n", tag_types_list[be32(entryinfos[i].type) % 16], be16(entryinfos[i].type));
 
 // User doesn't need to know the offset
 //		printf("				Offset: %lu\n", be32(entries[i].offset));
-		printf("				Flags: %08x\n", be32(entryinfos[i].flags));
 
 // 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("				Unk2: %04x\n", be16(entryinfos[i].unk1));
+		printf("				Unk3: %08x\n", be32(entryinfos[i].unk2)); */
 		printf("				Triplet Count: %u\n", be16(entryinfos[i].coord_count));
 		printf("				Triplets:\n");
 		for(z = 0; z < be16(entryinfos[i].coord_count); z++)
-			DisplayTagData(be32(entryinfos[i].flags), datas[i][z], z);
+			DisplayTagData(datas[i][z], z);
 	}
 }
 
@@ -129,7 +134,6 @@ static void ReadTagFromBRLAN(int idx, u8* brlan_file, tag_header *head, tag_entr
 {
 	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(tag_entry) * head[idx].entry_count);
 	dbgprintf("reallocated entries[idx]\n");
@@ -172,22 +176,25 @@ 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)");
+	int i;
+	for(i = 0; i < 16; i++)
+		memset(tag_types_list[i], 0, 24);
+	strcpy(tag_types_list[0], "X Translation");
+	strcpy(tag_types_list[1], "Y Translation");
+	strcpy(tag_types_list[2], "Z Translation");
+	strcpy(tag_types_list[3], "0x03");
+	strcpy(tag_types_list[4], "0x04");
+	strcpy(tag_types_list[5], "Angle");
+	strcpy(tag_types_list[6], "X Zoom");
+	strcpy(tag_types_list[7], "Y Zoom");
+	strcpy(tag_types_list[8], "Width");
+	strcpy(tag_types_list[9], "Height");
+	strcpy(tag_types_list[10], "0x0A");
+	strcpy(tag_types_list[11], "0x0B");
+	strcpy(tag_types_list[12], "0x0C");
+	strcpy(tag_types_list[13], "0x0D");
+	strcpy(tag_types_list[14], "0x0E");
+	strcpy(tag_types_list[15], "0x0F");
 	fseek(fp, 0, SEEK_END);
 	int file_size = ftell(fp);
 	dbgprintf("Filesize is %d\n", file_size);
@@ -242,7 +249,6 @@ void parse_brlan(char* filename)
 	tag_data ***intag_datas = NULL;
 	dbgprintf("rlpa datas created.\n");
 	int intag_cnt = 1;
-	int i;
 	for(i = 0; i < tagcount; i++) {
 		BRLAN_fileoffset = be32(taglocations[i]) + be16(header.pai1_offset);
 		dbgprintf("fileoffset set.\n");
@@ -332,3 +338,334 @@ void parse_brlan(char* filename)
 	free(brlan_file);
 	fclose(fp);
 }
+
+void WriteBRLANTagHeader(tag_header* head, FILE* fp)
+{
+	fwrite(head, sizeof(tag_header), 1, fp);
+}
+
+void WriteBRLANTagEntries(tag_entry* entry, u8 count, FILE* fp)
+{
+	tag_entry writeentry;
+	int i;
+	for(i = 0; i < count; i++) {
+		writeentry.offset = be32(entry[i].offset);
+		fwrite(&writeentry, sizeof(tag_entry), 1, fp);
+	}
+}
+
+void WriteBRLANTagEntryinfos(tag_entryinfo entryinfo, FILE* fp)
+{
+	tag_entryinfo writeentryinfo;
+	writeentryinfo.type = be16(entryinfo.type);
+	writeentryinfo.unk1 = be16(entryinfo.unk1);
+	writeentryinfo.coord_count = be16(entryinfo.coord_count);
+	writeentryinfo.pad1 = be16(entryinfo.pad1);
+	writeentryinfo.unk2 = be32(entryinfo.unk2);
+	fwrite(&writeentryinfo, sizeof(tag_entryinfo), 1, fp);
+}
+
+void WriteBRLANTagData(tag_data* data, u16 count, FILE* fp)
+{
+	tag_data writedata;
+	int i;
+	for(i = 0; i < count; i++) {
+		printf("%08x -> %08x\n", data[i].part1, be32(data[i].part1));
+		writedata.part1 = be32(data[i].part1);
+		printf("%08x -> %08x\n", data[i].part2, be32(data[i].part2));
+		writedata.part2 = be32(data[i].part2);
+		printf("%08x -> %08x\n\n", data[i].part3, be32(data[i].part3));
+		writedata.part3 = be32(data[i].part3);
+		fwrite(&writedata, sizeof(tag_data), 1, fp);
+	}
+}
+
+void WriteBRLANEntry(brlan_entry *entr, FILE* fp)
+{
+	brlan_entry writeentr;
+	memset(writeentr.name, 0, 20);
+	strncpy(writeentr.name, entr->name, 20);
+	writeentr.flags = be32(entr->flags);
+	writeentr.anim_header_len = be32(entr->anim_header_len);
+	fwrite(&writeentr, sizeof(brlan_entry), 1, fp);
+}
+
+u32 create_entries_from_xml(mxml_node_t *tree, mxml_node_t *node, brlan_entry *entr, tag_header* head, u8** tagblob, u32* blobsize)
+{
+	tag_entry* entry = NULL;
+	tag_entryinfo* entryinfo = NULL;
+	tag_data** data = NULL;
+	mxml_node_t *tempnode = NULL;
+	mxml_node_t *subnode = NULL;
+	mxml_node_t *subsubnode = NULL;
+	char temp[256];
+	char temp2[256];
+	char temp3[15][24];
+	int i, x;
+
+	for(i = 0; i < 16; i++)
+		memset(temp3[i], 0, 24);
+	for(x = 0; x < 16; x++)
+		for(i = 0; i < strlen(tag_types_list[x]); i++)
+			temp3[x][i] = toupper(tag_types_list[x][i]);
+	head->entry_count = 0;
+	subnode = node;
+	for (x = 0, subnode = mxmlFindElement(subnode, node, "entry", NULL, NULL, MXML_DESCEND); subnode != NULL; subnode = mxmlFindElement(subnode, node, "entry", NULL, NULL, MXML_DESCEND), x++) {
+		head->entry_count++;
+		entry = realloc(entry, sizeof(tag_entry) * head->entry_count);
+		entryinfo = realloc(entryinfo, sizeof(tag_entryinfo) * head->entry_count);
+		if(data == NULL)
+			data = (tag_data**)malloc(sizeof(tag_data*) * head->entry_count);
+		else
+			data = (tag_data**)realloc(data, sizeof(tag_data*) * head->entry_count);
+		data[x] = NULL;
+		tempnode = mxmlFindElement(subnode, tree, "type", NULL, NULL, MXML_DESCEND);
+		if(tempnode == NULL) {
+			printf("Couldn't find attribute \"type\"!\n");
+			exit(1);
+		}
+		memset(temp, 0, 256);
+		memset(temp2, 0, 256);
+		get_value(tempnode, temp, 24);
+		for(i = 0; i < strlen(temp); i++)
+			temp2[i] = toupper(temp[i]);
+		for(i = 0; (i < 16) && (strcmp(temp3[i - 1], temp2) != 0); i++);
+		if(i == 16)
+			i = atoi(temp2);
+		entry[x].offset = 0;
+		entryinfo[x].type = i;
+		entryinfo[x].unk1 = 0x0200;
+		entryinfo[x].pad1 = 0x0000;
+		entryinfo[x].unk2 = 0x0000000C;
+		entryinfo[x].coord_count = 0;
+		subsubnode = subnode;
+		for (i = 0, subsubnode = mxmlFindElement(subsubnode, subnode, "triplet", NULL, NULL, MXML_DESCEND); subsubnode != NULL; subsubnode = mxmlFindElement(subsubnode, subnode, "triplet", NULL, NULL, MXML_DESCEND), i++) {
+			entryinfo[x].coord_count++;
+			data[x] = realloc(data[x], sizeof(tag_data) * entryinfo[x].coord_count);
+			tempnode = mxmlFindElement(subsubnode, subsubnode, "frame", NULL, NULL, MXML_DESCEND);
+			if(tempnode == NULL) {
+				printf("Couldn't find attribute \"frame\"!\n");
+				exit(1);
+			}
+			get_value(tempnode, temp, 256);
+			*(f32*)(&(data[x][i].part1)) = atof(temp);
+			tempnode = mxmlFindElement(subsubnode, subsubnode, "value", NULL, NULL, MXML_DESCEND);
+			if(tempnode == NULL) {
+				printf("Couldn't find attribute \"value\"!\n");
+				exit(1);
+			}
+			get_value(tempnode, temp, 256);
+			*(f32*)(&(data[x][i].part2)) = atof(temp);
+			tempnode = mxmlFindElement(subsubnode, subsubnode, "interpolation", NULL, NULL, MXML_DESCEND);
+			if(tempnode == NULL) {
+				printf("Couldn't find attribute \"interpolation\"!\n");
+				exit(1);
+			}
+			get_value(tempnode, temp, 256);
+			*(f32*)(&(data[x][i].part3)) = atof(temp);
+		}
+	}
+	FILE* fp = fopen("temp.blan", "wb+");
+	if(fp == NULL) {
+		printf("Couldn't open temporary temp.blan file\n");
+		exit(1);
+	}
+	fseek(fp, 0, SEEK_SET);
+	entr->anim_header_len = 0;
+	WriteBRLANEntry(entr, fp);
+	WriteBRLANTagHeader(head, fp);
+	u32 entryloc = ftell(fp);
+	WriteBRLANTagEntries(entry, head->entry_count, fp);
+	u32* entryinfolocs = (u32*)calloc(head->entry_count, sizeof(u32));
+	for(x = 0; x < head->entry_count; x++) {
+		entryinfolocs[x] = ftell(fp);
+		entry[x].offset = entryinfolocs[x] - sizeof(brlan_entry);
+		WriteBRLANTagEntryinfos(entryinfo[x], fp);
+		WriteBRLANTagData(data[x], entryinfo[x].coord_count, fp);
+	}
+	u32 oldpos = ftell(fp);
+	fseek(fp, entryloc, SEEK_SET);
+	WriteBRLANTagEntries(entry, head->entry_count, fp);
+	fseek(fp, oldpos, SEEK_SET);
+	u32 filesz = ftell(fp);
+	fseek(fp, 0, SEEK_SET);
+	entr->anim_header_len = sizeof(tag_header) + (sizeof(tag_entry) * head->entry_count);
+	WriteBRLANEntry(entr, fp);
+	*blobsize = filesz;
+	*tagblob = (u8*)malloc(*blobsize);
+	fseek(fp, 0, SEEK_SET);
+	fread(*tagblob, *blobsize, 1, fp);
+	free(entry);
+	free(entryinfo);
+	free(data);
+	printf("All done.\n");
+	return filesz;
+}
+
+void create_tag_from_xml(mxml_node_t *tree, mxml_node_t *node, u8** tagblob, u32* blobsize)
+{
+	tag_header head;
+	brlan_entry entr;
+	mxml_node_t *tempnode = mxmlFindElement(node, tree, "name", NULL, NULL, MXML_DESCEND);
+	if(tempnode == NULL) {
+		printf("Couldn't find attribute \"name\"!\n");
+		exit(1);
+	}
+	memset(entr.name, 0, 20);
+	char temp[21];
+	get_value(tempnode, temp, 20);
+	strncpy(entr.name, temp, 20);
+	entr.flags = 0x01000000;
+	tempnode = mxmlFindElement(node, tree, "magic", NULL, NULL, MXML_DESCEND);
+	if(tempnode == NULL) {
+		printf("Couldn't find attribute \"magic\"!\n");
+		exit(1);
+	}
+	get_value(tempnode, temp, 5);
+	head.magic[0] = temp[0];
+	head.magic[1] = temp[1];
+	head.magic[2] = temp[2];
+	head.magic[3] = temp[3];
+	head.pad1 = 0;
+	head.pad2 = 0;
+	head.pad3 = 0;
+	create_entries_from_xml(tree, node, &entr, &head, tagblob, blobsize);
+}
+
+void WriteBRLANHeader(brlan_header rlanhead, FILE* fp)
+{
+	brlan_header writehead;
+	writehead.magic[0] = rlanhead.magic[0];
+	writehead.magic[1] = rlanhead.magic[1];
+	writehead.magic[2] = rlanhead.magic[2];
+	writehead.magic[3] = rlanhead.magic[3];
+	writehead.unk1 = be32(rlanhead.unk1);
+	writehead.file_size = be32(rlanhead.file_size);
+	writehead.pai1_offset = be16(rlanhead.pai1_offset);
+	writehead.pai1_count = be16(rlanhead.pai1_count);
+	fwrite(&writehead, sizeof(brlan_header), 1, fp);
+}
+
+void WriteBRLANPaiHeader(brlan_pai1_header_type1 paihead, FILE* fp)
+{
+	brlan_pai1_header_type1 writehead;
+	writehead.magic[0] = paihead.magic[0];
+	writehead.magic[1] = paihead.magic[1];
+	writehead.magic[2] = paihead.magic[2];
+	writehead.magic[3] = paihead.magic[3];
+	writehead.size = be32(paihead.size);
+	writehead.framesize = be16(paihead.framesize);
+	writehead.flags = paihead.flags;
+	writehead.unk1 = paihead.unk1;
+	writehead.num_timgs = be16(paihead.num_timgs);
+	writehead.num_entries = be16(paihead.num_entries);
+	writehead.entry_offset = be32(paihead.entry_offset);
+	fwrite(&writehead, sizeof(brlan_pai1_header_type1), 1, fp);
+}
+
+void write_brlan(char *infile, char* outfile)
+{
+	int i;
+	for(i = 0; i < 16; i++)
+		memset(tag_types_list[i], 0, 24);
+	strcpy(tag_types_list[0], "X Translation");
+	strcpy(tag_types_list[1], "Y Translation");
+	strcpy(tag_types_list[2], "Z Translation");
+	strcpy(tag_types_list[3], "0x03");
+	strcpy(tag_types_list[4], "0x04");
+	strcpy(tag_types_list[5], "Angle");
+	strcpy(tag_types_list[6], "X Zoom");
+	strcpy(tag_types_list[7], "Y Zoom");
+	strcpy(tag_types_list[8], "Width");
+	strcpy(tag_types_list[9], "Height");
+	strcpy(tag_types_list[10], "0x0A");
+	strcpy(tag_types_list[11], "0x0B");
+	strcpy(tag_types_list[12], "0x0C");
+	strcpy(tag_types_list[13], "0x0D");
+	strcpy(tag_types_list[14], "0x0E");
+	strcpy(tag_types_list[15], "0x0F");
+	FILE* fpx = fopen(infile, "r");
+	if(fpx == NULL) {
+		printf("xmlan couldn't be opened!\n");
+		exit(1);
+	}
+	mxml_node_t *hightree = mxmlLoadFile(NULL, fpx, MXML_TEXT_CALLBACK);
+	if(hightree == NULL) {
+		printf("Couldn't open hightree!\n");
+		exit(1);
+	}
+	mxml_node_t *tree = mxmlFindElement(hightree, hightree, "xmlan", NULL, NULL, MXML_DESCEND);
+	if(hightree == NULL) {
+		printf("Couldn't get tree!\n");
+		exit(1);
+	}
+	mxml_node_t *node;
+	FILE* fp = fopen(outfile, "wb+");
+	if(fpx == NULL) {
+		printf("destination brlan couldn't be opened!\n");
+		exit(1);
+	}
+	u8* tagblob;
+	u32 blobsize;
+	u16 blobcount = 0;
+	u32 bloboffset;
+	brlan_header rlanhead;
+	rlanhead.magic[0] = 'R';
+	rlanhead.magic[1] = 'L';
+	rlanhead.magic[2] = 'A';
+	rlanhead.magic[3] = 'N';
+	rlanhead.unk1 = 0xFEFF0008;
+	rlanhead.file_size = 0;
+	rlanhead.pai1_offset = sizeof(brlan_header);
+	rlanhead.pai1_count = 1;
+	WriteBRLANHeader(rlanhead, fp);
+	brlan_pai1_header_type1 paihead;
+	paihead.magic[0] = 'p';
+	paihead.magic[1] = 'a';
+	paihead.magic[2] = 'i';
+	paihead.magic[3] = '1';
+	paihead.size = 0;
+	char temp[256];
+	mxml_node_t *tempnode = mxmlFindElement(tree, tree, "framesize", NULL, NULL, MXML_DESCEND);
+	if(tempnode == NULL) {
+		printf("Couldn't find attribute \"framesize\"!\n");
+		exit(1);
+	}
+	get_value(tempnode, temp, 256);
+	paihead.framesize = atoi(temp);
+	paihead.flags = 1;
+	paihead.unk1 = 0;
+	paihead.num_timgs = 0;
+	paihead.num_entries = 0;
+	paihead.entry_offset = sizeof(brlan_pai1_header_type1);
+	WriteBRLANPaiHeader(paihead, fp);
+	// Do header stuff here...
+	u8* tagchunksbig = (u8*)calloc(MAXIMUM_TAGS_SIZE, 1);
+	MEMORY* tagsmem = mopen(tagchunksbig, MAXIMUM_TAGS_SIZE, 3);
+	u32 totaltagsize = 0;
+	for(node = mxmlFindElement(tree, tree, "tag", NULL, NULL, MXML_DESCEND); node != NULL; node = mxmlFindElement(node, tree, "tag", NULL, NULL, MXML_DESCEND)) {
+		blobcount++;
+		bloboffset = ftell(fp) + mtell(tagsmem) - (4 * (blobcount + 1));
+		bloboffset = be32(bloboffset);
+		fwrite(&bloboffset, sizeof(u32), 1, fp);
+		create_tag_from_xml(tree, node, &tagblob, &blobsize);
+		mwrite(tagblob, blobsize, 1, tagsmem);
+		totaltagsize += blobsize;
+	}
+	tagchunksbig = (u8*)mclose(tagsmem);
+	fwrite(tagchunksbig, totaltagsize, 1, fp);
+	paihead.num_entries = blobcount;
+	fseek(fp, 0, SEEK_END);
+	paihead.size = ftell(fp) - rlanhead.pai1_offset;
+	rlanhead.file_size = ftell(fp);
+	fseek(fp, 0, SEEK_SET);
+	WriteBRLANHeader(rlanhead, fp);
+	WriteBRLANPaiHeader(paihead, fp);
+}
+
+void make_brlan(char* infile, char* outfile)
+{
+	printf("Starting xmlan file @ %s parsing.\n", infile);
+	write_brlan(infile, outfile);
+}
+
diff --git a/brlan.h b/brlan.h
index 6880173..3df14ad 100755
--- a/brlan.h
+++ b/brlan.h
@@ -82,10 +82,11 @@ typedef struct
 
 typedef struct
 {
-	u32		flags;			// Flags?
+	u16		type;			// Type (look at animtypes)
+	u16		unk1;			// ??? Every case has been 0x0200
 	u16		coord_count;		// How many coordinates.
 	u16		pad1;			// All cases I've seen is zero.
-	u32		unk1;			// ??? In every case I've seen, it is \x00\x00\x00\x0C.
+	u32		unk2;			// ??? In every case I've seen, it is 0x0000000C.
 } tag_entryinfo;
 
 typedef struct
@@ -97,17 +98,7 @@ typedef struct
 
 
 void parse_brlan(char* filename);
-
-
-
-
-
-
-
-
-
-
-
+void make_brlan(char* infile, char* outfile);
 
 #endif //BRLAN_H_
 
diff --git a/brlyt.c b/brlyt.c
index 2e84bea..64c99e6 100644
--- a/brlyt.c
+++ b/brlyt.c
@@ -14,8 +14,6 @@
 #include "types.h"
 #include "brlyt.h"
 
-//#define DEBUGBRLYT
-
 #ifdef DEBUGBRLYT
 #define dbgprintf	printf
 #else
@@ -166,16 +164,16 @@ void PrintBRLYTEntries(brlyt_entry *entries, int entrycnt, u8* brlyt_file)
 			printf("		Type: %c%c%c%c\n", entries[i].magic[0], entries[i].magic[1], entries[i].magic[2], entries[i].magic[3]);
 			printf("		Flags: %04x (%08x)\n", be16(data.flags));
 			printf("		Alpha: %04x (%08x)\n", be16(data.alpha));
-			printf("		X: %f (%08x) (%08x)\n", data.x, &data.x, &data);
-			printf("		Y: %f (%08x)\n", data.y);
-			printf("		X Magnification: %f (%08x)\n", data.xmag);
-			printf("		Y Magnification: %f (%08x)\n", data.ymag);
-			printf("		Width: %f (%08x)\n", data.width);
-			printf("		Height: %f (%08x)\n", data.height);
-			printf("		Angle: %f (%08x)\n", data.angle);
-			printf("		unk1: %f (%08x)\n", data.unk[0]);
-			printf("		unk2: %f (%08x)\n", data.unk[1]);
-			printf("		unk3: %f (%08x)\n", data.unk[2]);
+			printf("		X: %f (%08x) (%08x)\n", be32(data.x), &data.x, &data);
+			printf("		Y: %f (%08x)\n", be32(data.y));
+			printf("		X Magnification: %f (%08x)\n", be32(data.xmag));
+			printf("		Y Magnification: %f (%08x)\n", be32(data.ymag));
+			printf("		Width: %f (%08x)\n", be32(data.width));
+			printf("		Height: %f (%08x)\n", be32(data.height));
+			printf("		Angle: %f (%08x)\n", be32(data.angle));
+			printf("		unk1: %f (%08x)\n", be32(data.unk[0]));
+			printf("		unk2: %f (%08x)\n", be32(data.unk[1]));
+			printf("		unk3: %f (%08x)\n", be32(data.unk[2]));
 		}else if((FourCCsMatch(entries[i].magic, lyt1_magic) == 1)) {
 			dbgprintf("lyt1\n");
 			PrintBRLYTEntry_lyt1(entries[i], brlyt_file);
@@ -250,6 +248,10 @@ void parse_brlyt(char *filename)
 	PrintBRLYTEntries(entries, entrycount, brlyt_file);
 }
 
+void make_brlyt(char* infile, char* outfile)
+{
+}
+
 
 
 
diff --git a/brlyt.h b/brlyt.h
index e257d68..6f224a2 100644
--- a/brlyt.h
+++ b/brlyt.h
@@ -69,5 +69,6 @@ typedef struct
 // grs1, gre1, pas1, and pae1 all don't have anything special. they seem to just be prefixes to some sections.
 
 void parse_brlyt(char *filename);
+void make_brlyt(char* infile, char* outfile);
 
 #endif //BRLYT_H_
\ No newline at end of file
diff --git a/general.h b/general.h
index 18e4008..953764f 100644
--- a/general.h
+++ b/general.h
@@ -9,12 +9,16 @@
 
 #define BENZIN_VERSION_MAJOR		0
 #define BENZIN_VERSION_MINOR		1
-#define BENZIN_VERSION_BUILD		100
+#define BENZIN_VERSION_BUILD		200
 #define BENZIN_VERSION_OTHER		"WIP"
 
 #define USE_BRLAN
 //#define USE_BRLYT
 
+#define DEBUGBRLAN
+#define DEBUGMAIN
+//#define DEBUGBRLYT
+
 #define fatal(x)	printf(x); exit(1)
 
 // WTF is this doing here?
diff --git a/main.c b/main.c
index 15d3150..bebf838 100644
--- a/main.c
+++ b/main.c
@@ -8,35 +8,72 @@
 #include "endian.h"
 #include "general.h"
 
+#ifdef DEBUGMAIN
+#define dbgprintf	printf
+#else
+#define dbgprintf	//
+#endif //DEBUGMAIN
+
 int main(int argc, char* argv[])
 {
-	int brlanarg;
-	int brlytarg;
-	int currentarg = 1;
-	char helpstr[256];
-	sprintf(helpstr, "%s", argv[0]);
+	int brlanargread;
+	int brlytargread;
+	int brlanargmake;
+	int brlytargmake;
+	int brlanargdestmake;
+	int brlytargdestmake;
+	int reqargs;
+	int currentarg = 2;
+	char helpstrmake[256];
+	char helpstrread[256];
+	sprintf(helpstrmake, "%s m", argv[0]);
+	sprintf(helpstrread, "%s r", argv[0]);
+#ifdef USE_BRLAN
+	brlanargread = currentarg;
+	strcat(helpstrread, " <*.brlan>");
+	brlanargmake = currentarg++;
+	strcat(helpstrmake, " <*.xmlan>");
+#endif //USE_BRLAN
+#ifdef USE_BRLYT
+	brlytargread = currentarg;
+	strcat(helpstrread, " <*.brlyt>");
+	brlytargmake = currentarg++;
+	strcat(helpstrmake, " <*.xmlyt>");
+#endif //USE_BRLYT
+	reqargs = currentarg;
 #ifdef USE_BRLAN
-	brlanarg = currentarg++;
-	strcat(helpstr, " <*.brlan>");
+	brlanargdestmake = currentarg++;
+	strcat(helpstrmake, " <out.brlan>");
 #endif //USE_BRLAN
 #ifdef USE_BRLYT
-	brlytarg = currentarg++;
-	strcat(helpstr, " <*.brlyt>");
+	brlytargdestmake = currentarg++;
+	strcat(helpstrmake, " <out.brlyt>");
 #endif //USE_BRLYT
+
 	printf("Benzin %d.%d.%d%s.\n" \
 	       "Written by SquidMan (Alex Marshall), Archangel (Takeda Toshinaka), and comex.\n" \
 	       "(c) 2009 HACKERCHANNEL\n", BENZIN_VERSION_MAJOR, BENZIN_VERSION_MINOR, BENZIN_VERSION_BUILD, BENZIN_VERSION_OTHER);
-	if(argc < currentarg) {
-		printf("Invalid arguments. Use like so:\n\t%s\n", helpstr);
+	if(argc < reqargs) {
+		printf("Invalid arguments. Use like:\n\t%s\n\t\tor:\n\t%s\n", helpstrread, helpstrmake);
 		exit(1);
 	}
-	
+	if(argv[1][0] == 'r') {
 #ifdef USE_BRLAN
-	parse_brlan(argv[brlanarg]);
+		parse_brlan(argv[brlanargread]);
 #endif //USE_BRLAN
 #ifdef USE_BRLYT
-	parse_brlyt(argv[brlytarg]);
+		parse_brlyt(argv[brlytargread]);
 #endif //USE_BRLYT
+	}else if(argv[1][0] == 'm') {
+#ifdef USE_BRLAN
+		dbgprintf("1:%d 2:%d f1:%s f2:%s\n", brlanargmake, brlanargdestmake, argv[brlanargmake], argv[brlanargdestmake]);
+		make_brlan(argv[brlanargmake], argv[brlanargdestmake]);
+#endif //USE_BRLAN
+#ifdef USE_BRLYT
+		dbgprintf("1:%d 2:%d f1:%s f2:%s\n", brlytargmake, brlytargdestmake, argv[brlytargmake], argv[brlytargdestmake]);
+		make_brlyt(argv[brlytargmake], argv[brlytargdestmake]);
+#endif //USE_BRLYT
+	}
 	return 0;
 }
 
diff --git a/memfile.c b/memfile.c
new file mode 100644
index 0000000..abbd673
--- /dev/null
+++ b/memfile.c
@@ -0,0 +1,110 @@
+/*
+ *  memfile.c
+ *  0CFMaker
+ *
+ *  Created by Alex Marshall on 09/02/08.
+ *  Copyright 2009 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "types.h"
+#include "memfile.h"
+
+void ReadMemory(void* dst, size_t size, size_t count, MEMORY* src)
+{
+	if((src->mode & 0x1) == 0) {
+		printf("Invalid mode for reading!\n");
+		return;
+	}
+	u8* data = (u8*)dst;
+	if(((size * count) + src->position) > src->memorysize) {
+		printf("Tried to over read.\n");
+		return;
+	}
+	memcpy(data, ((u8*)src->memory) + src->position, size * count);
+	src->position += size * count;
+}
+
+char ReadMemoryChar(MEMORY* src)
+{
+	char ret;
+	ReadMemory(&ret, 1, 1, src);
+	return ret;
+}
+
+void WriteMemory(void* dst, size_t size, size_t count, MEMORY* src)
+{
+	if((src->mode & 0x2) == 0) {
+		printf("Invalid mode for writing!\n");
+		return;
+	}
+	u8* data = (u8*)dst;
+	if(((size * count) + src->position) > src->memorysize) {
+		printf("Tried to over read.\n");
+		return;
+	}
+	memcpy(((u8*)src->memory) + src->position, data, size * count);
+	src->position += size * count;
+}
+
+void WriteMemoryChar(char inchar, MEMORY* src)
+{
+	WriteMemory(&inchar, 1, 1, src);
+}
+
+MEMORY* OpenMemory(void* indata, size_t size, char mode)
+{
+	MEMORY* mem = malloc(sizeof(MEMORY));
+	if((mode & 0x2) == 0x0)
+		mem->memory = indata;
+	else
+		mem->memory = calloc(size, 1);
+	if(mem->memory == NULL)
+		return NULL;
+	mem->memorysize = size;
+	mem->position = 0;
+	mem->mode = mode;
+	return mem;
+}
+
+void* CloseMemory(MEMORY* mem)
+{
+	void* ret = mem->memory;
+	mem->memory = NULL;
+	mem->memorysize = 0;
+	mem->position = 0;
+	mem->mode = 0;
+	free(mem);
+	return ret;
+}
+
+void* GetMemory(MEMORY* mem)
+{
+	return mem->memory;
+}
+
+void SeekMemory(MEMORY* mem, size_t location, int type)
+{
+	switch(type) {
+		case SEEK_SET:
+			mem->position = location;
+			break;
+			
+		case SEEK_END:
+			mem->position = mem->memorysize - location;
+			break;
+	}
+}
+
+size_t TellMemory(MEMORY* mem)
+{
+	return mem->position;
+}
+
+size_t SizeMemory(MEMORY* mem)
+{
+	return mem->memorysize;
+}
diff --git a/memfile.h b/memfile.h
new file mode 100644
index 0000000..729ec86
--- /dev/null
+++ b/memfile.h
@@ -0,0 +1,45 @@
+/*
+ *  memfile.h
+ *  0CFMaker
+ *
+ *  Created by Alex Marshall on 09/02/08.
+ *  Copyright 2009 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#ifndef _MEMFILE_H_
+#define _MEMFILE_H_
+
+#include "types.h"
+
+#define mread		ReadMemory
+#define mwrite		WriteMemory
+#define mopen		OpenMemory
+#define mclose		CloseMemory
+#define mseek		SeekMemory
+#define mgetc		ReadMemoryChar
+#define mputc		WriteMemoryChar
+#define mtell		TellMemory
+#define msize		SizeMemory
+#define mgetm		GetMemory
+
+typedef struct
+{
+	void*	memory;			// Pointer.
+	size_t	memorysize;		// Size.
+	size_t	position;		// Where we are.
+	char	mode;			// What mode opened (1 = read, 2 = write, 3 = both)
+} MEMORY;
+
+void ReadMemory(void* dst, size_t size, size_t count, MEMORY* src);
+char ReadMemoryChar(MEMORY* src);
+void WriteMemory(void* dst, size_t size, size_t count, MEMORY* src);
+void WriteMemoryChar(char inchar, MEMORY* src);
+MEMORY* OpenMemory(void* indata, size_t size, char mode);
+void* CloseMemory(MEMORY* mem);
+void* GetMemory(MEMORY* mem);
+void SeekMemory(MEMORY* mem, size_t location, int type);
+size_t TellMemory(MEMORY* mem);
+size_t SizeMemory(MEMORY* mem);
+
+#endif //_MEMFILE_H_
diff --git a/sample.xmlan b/sample.xmlan
new file mode 100644
index 0000000..f3c9657
--- /dev/null
+++ b/sample.xmlan
@@ -0,0 +1,56 @@
+<?xml version="1.0"?>
+<xmlan>
+	<framesize>70</framesize>
+	<tag>
+		<name>pic</name>
+		<magic>RLPA</magic>
+		<entry>
+			<type>X Translation</type>
+			<triplet>
+				<frame>20.000000</frame>
+				<value>0.000000</value>
+				<interpolation>3.000000</interpolation>
+			</triplet>
+			<triplet>
+				<frame>40.000000</frame>
+				<value>15.000000</value>
+				<interpolation>3.000000</interpolation>
+			</triplet>
+		</entry>
+		<entry>
+			<type>Y Translation</type>
+			<triplet>
+				<frame>10.000000</frame>
+				<value>0.000000</value>
+				<interpolation>3.000000</interpolation>
+			</triplet>
+			<triplet>
+				<frame>30.000000</frame>
+				<value>15.000000</value>
+				<interpolation>3.000000</interpolation>
+			</triplet>
+		</entry>
+	</tag>
+	<tag>
+		<name>pic</name>
+		<magic>RLVC</magic>
+		<entry>
+			<type>16</type>
+			<triplet>
+				<frame>20.000000</frame>
+				<value>50.000000</value>
+				<interpolation>1.000000</interpolation>
+			</triplet>
+			<triplet>
+				<frame>40.000000</frame>
+				<value>200.000000</value>
+				<interpolation>1.000000</interpolation>
+			</triplet>
+			<triplet>
+				<frame>60.000000</frame>
+				<value>100.000000</value>
+				<interpolation>1.000000</interpolation>
+			</triplet>
+		</entry>
+	</tag>
+</xmlan>
diff --git a/xml.c b/xml.c
new file mode 100644
index 0000000..7eb1cfb
--- /dev/null
+++ b/xml.c
@@ -0,0 +1,68 @@
+#include <string.h>
+#include <mxml.h>
+
+#include "types.h"
+#include "xml.h"
+
+char *					/* O - Buffer */
+get_value(mxml_node_t *node,		/* I - Node to get */
+         void        *buffer,		/* I - Buffer */
+	 int         buflen)		/* I - Size of buffer */
+{
+	char		*ptr,			/* Pointer into buffer */
+	*end;			/* End of buffer */
+	int		len;			/* Length of node */
+	mxml_node_t	*current;		/* Current node */
+	
+	
+	ptr = (char*)buffer;
+	end = (char*)buffer + buflen - 1;
+	char tempbuf[256];
+	current = node->child;
+	for (current = node->child; current && ptr < end; current = current->next)
+	{
+		if (current->type == MXML_TEXT)
+		{
+			if (current->value.text.whitespace)
+				*ptr++ = ' ';
+			
+			len = (int)strlen(current->value.text.string);
+			if (len > (int)(end - ptr))
+				len = (int)(end - ptr);
+			
+			memcpy(ptr, current->value.text.string, len);
+			ptr += len;
+		}
+		else if (current->type == MXML_OPAQUE)
+		{
+			len = (int)strlen(current->value.opaque);
+			if (len > (int)(end - ptr))
+				len = (int)(end - ptr);
+			
+			memcpy(ptr, current->value.opaque, len);
+			ptr += len;
+		}
+		else if (current->type == MXML_INTEGER)
+		{
+			sprintf(tempbuf, "%f", current->value.integer);
+			len = (int)strlen(tempbuf);
+			if (len > (int)(end - ptr))
+				len = (int)(end - ptr);
+			
+			memcpy(ptr, tempbuf, len);
+			ptr += len;
+		}
+		else if (current->type == MXML_REAL)
+		{
+			sprintf(tempbuf, "%f", current->value.real);
+			len = (int)strlen(tempbuf);
+			if (len > (int)(end - ptr))
+				len = (int)(end - ptr);
+			
+			memcpy(ptr, tempbuf, len);
+			ptr += len;
+		}
+	}
+	*ptr = 0;
+	return buffer;
+}
diff --git a/xml.h b/xml.h
new file mode 100755
index 0000000..7f581de
--- /dev/null
+++ b/xml.h
@@ -0,0 +1,9 @@
+#ifndef _XML_H_
+#define _XML_H_
+
+char *					/* O - Buffer */
+get_value(mxml_node_t *node,		/* I - Node to get */
+	  void        *buffer,		/* I - Buffer */
+	  int         buflen);		/* I - Size of buffer */
+
+#endif //_XML_H_