diff options
Diffstat (limited to '')
| -rw-r--r-- | brlan.c | 303 | ||||
| -rw-r--r-- | brlyt.c | 293 | ||||
| -rw-r--r-- | brlyt.h | 73 |
3 files changed, 669 insertions, 0 deletions
@@ -0,0 +1,303 @@ +/* + * brlan.c + * + * + * Created by Alex Marshall on 09/01/27. + * Copyright 2009 __MyCompanyName__. All rights reserved. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "types.h" +#include "brlan.h" + +//#define DEBUGBRLAN + +#ifdef DEBUGBRLAN +#define dbgprintf printf +#else +#define dbgprintf // +#endif //DEBUGBRLAN + +char RLPA_FourCC[] = "RLPA"; + +static size_t BRLAN_fileoffset = 0; + +static void BRLAN_ReadDataFromMemoryX(void* destination, void* input, size_t size) +{ + u8* out = (u8*)destination; + u8* in = ((u8*)input) + BRLAN_fileoffset; + memcpy(out, in, size); +} + +static void BRLAN_ReadDataFromMemory(void* destination, void* input, size_t size) +{ + BRLAN_ReadDataFromMemoryX(destination, input, size); + BRLAN_fileoffset += size; +} + +static void CreateGlobal_pai1(brlan_pai1_header_type2 *pai1_header, brlan_pai1_header_type1 pai1_header1, + brlan_pai1_header_type2 pai1_header2, int pai1_header_type) +{ + if(pai1_header_type == 1) { + pai1_header->magic[0] = pai1_header1.magic[0]; + pai1_header->magic[1] = pai1_header1.magic[1]; + 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->flags = pai1_header1.flags; + pai1_header->num_entries = pai1_header1.num_entries; + pai1_header->unk2 = 0; + pai1_header->entry_offset = pai1_header1.entry_offset; + }else + memcpy(pai1_header, &pai1_header2, sizeof(brlan_pai1_header_type2)); +} + +static void DisplayRLPAData(u32 flags, RLPA_data data) +{ + 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); +} + +static int FourCCsMatch(fourcc cc1, fourcc cc2) +{ + if((cc1[0] == cc2[0]) && (cc1[1] == cc2[1]) && (cc1[2] == cc2[2]) && (cc1[3] == cc2[3])) + return 1; + else + return 0; +} + +static void DisplayRLPAInformation(int idx, RLPA_header* heads, RLPA_entry** entriesx, + RLPA_entryinfo** entryinfosx, RLPA_data*** datasxx) +{ + RLPA_header head = heads[idx]; + RLPA_entry* entries = entriesx[idx]; + RLPA_entryinfo* entryinfos = entryinfosx[idx]; + RLPA_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); + printf(" Unk2: %02x\n", head.pad2); + 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(" 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)); + for(z = 0; z < be16(entryinfos[i].coord_count); z++) + DisplayRLPAData(be32(entryinfos[i].flags), datas[i][z]); + } +} + +static void ReadRLPAFromBRLAN(int idx, u8* brlan_file, RLPA_header *head, RLPA_entry** entries, + RLPA_entryinfo** entryinfo, RLPA_data*** data) +{ + int rlpahead_location = BRLAN_fileoffset; + BRLAN_ReadDataFromMemory(&head[idx], brlan_file, sizeof(RLPA_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); + dbgprintf("reallocated entries[idx]\n"); + entryinfo[idx] = realloc(entryinfo[idx], sizeof(RLPA_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); + 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); + 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)); + 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; + dbgprintf("read entry infos. 0x%08x\n", &entryinfo[idx][i]); + BRLAN_ReadDataFromMemory(&entryinfo[idx][i], brlan_file, sizeof(RLPA_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)); + 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)); + dbgprintf("read data.\n"); + } + } +} + +void parse_brlan(char* filename) +{ + FILE* fp = fopen(filename, "rb"); + if(fp == NULL) { + printf("Error! Couldn't open %s!\n", filename); + exit(1); + } + fseek(fp, 0, SEEK_END); + int file_size = ftell(fp); + dbgprintf("Filesize is %d\n", file_size); + u8* brlan_file = (u8*)malloc(file_size); + dbgprintf("brlan_file allocated\n"); + fseek(fp, 0, SEEK_SET); + fread(brlan_file, file_size, 1, fp); + dbgprintf("brlan_file read to.\n"); + BRLAN_fileoffset = 0; + brlan_header header; + BRLAN_ReadDataFromMemoryX(&header, brlan_file, sizeof(brlan_header)); + dbgprintf("brlan_header read to.\n"); + BRLAN_fileoffset = be16(header.pai1_offset); + brlan_pai1_universal universal; + BRLAN_ReadDataFromMemoryX(&universal, brlan_file, sizeof(brlan_pai1_universal)); + dbgprintf("pa1_universal read to.\n"); + + int pai1_header_type; + brlan_pai1_header_type1 pai1_header1; + brlan_pai1_header_type2 pai1_header2; + brlan_pai1_header_type2 pai1_header; + + if((be32(universal.flags) & (1 << 25)) >= 1) { + pai1_header_type = 2; + BRLAN_ReadDataFromMemory(&pai1_header2, brlan_file, sizeof(brlan_pai1_header_type2)); + } else { + pai1_header_type = 1; + BRLAN_ReadDataFromMemory(&pai1_header1, brlan_file, sizeof(brlan_pai1_header_type1)); + } + dbgprintf("pai1 headers gotten.\n"); + + CreateGlobal_pai1(&pai1_header, pai1_header1, pai1_header2, pai1_header_type); + dbgprintf("pai1 global created.\n"); + + int tagcount = be16(pai1_header.num_entries); + dbgprintf("tagcount done.\n"); + u32 *taglocations = (u32*)calloc(tagcount, sizeof(u32)); + dbgprintf("allocated tag locations.\n"); + fourcc CCs[256]; + memset(CCs, 0, 256*4); + dbgprintf("allocated fourccs.\n"); + BRLAN_ReadDataFromMemory(taglocations, brlan_file, tagcount * sizeof(u32)); + 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; + dbgprintf("rlpa entry infos created.\n"); + RLPA_data ***RLPA_datas = NULL; + dbgprintf("rlpa datas created.\n"); + int RLPA_cnt = 1; + int i; + for(i = 0; i < tagcount; i++) { + BRLAN_fileoffset = be32(taglocations[i]) + be16(header.pai1_offset); + dbgprintf("fileoffset set.\n"); + BRLAN_ReadDataFromMemory(&(tag_entries[i]), brlan_file, sizeof(brlan_entry)); + dbgprintf("got tag entry.\n"); + if((be32(tag_entries[i].flags) & (1 << 25)) >= 1) { + BRLAN_fileoffset += sizeof(u32); + dbgprintf("skipped extra.\n"); + } + fourcc magick; + 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) { + printf("Error allocating heads.\n"); + exit(2); + } + if(RLPA_entries == NULL) { + printf("Error allocating entries.\n"); + exit(2); + } + if(RLPA_entryinfos == NULL) { + printf("Error allocating entryinfos.\n"); + exit(2); + } + if(RLPA_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++; + } + dbgprintf("looping.\n"); + } + + printf("Parsed BRLAN! Information:\n"); + printf("Main header:\n"); + 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)); + 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(" 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)); + printf("\nBRLAN entries:"); + RLPA_cnt = 0; + for(i = 0; i < tagcount; i++) { + printf("\n Index: %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)); + 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++; + }else{ + printf(" Sorry, this type is currently unsupported.\n"); + } + } + free(brlan_file); + fclose(fp); +} @@ -0,0 +1,293 @@ +/* + * brlyt.c + * + * + * Created by Alex Marshall on 09/01/27. + * Copyright 2009 __MyCompanyName__. All rights reserved. + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "types.h" +#include "brlyt.h" + +//#define DEBUGBRLYT + +#ifdef DEBUGBRLYT +#define dbgprintf printf +#else +#define dbgprintf // +#endif //DEBUGBRLYT + +char pic1_magic[] = "pic1"; +char pan1_magic[] = "pan1"; +char bnd1_magic[] = "bnd1"; +char wnd1_magic[] = "wnd1"; +char lyt1_magic[] = "lyt1"; +char grp1_magic[] = "grp1"; +char txl1_magic[] = "txl1"; +char mat1_magic[] = "mat1"; +char fnl1_magic[] = "fnl1"; + +static size_t BRLYT_fileoffset = 0; + +static int FourCCsMatch(fourcc cc1, fourcc cc2) +{ + dbgprintf("FourCCs\n"); + int ret[4]; + dbgprintf("Let's go %08x %08x\n", cc1, cc2); + ret[0] = (cc1[0] == cc2[0]); + dbgprintf("Got zero |%02x| |%02x| %d\n", cc1[0], cc2[0], ret[0]); + ret[1] = (cc1[1] == cc2[1]); + dbgprintf("Got one |%02x| |%02x| %d\n", cc1[1], cc2[1], ret[1]); + ret[2] = (cc1[2] == cc2[2]); + dbgprintf("Got two |%02x| |%02x| %d\n", cc1[2], cc2[2], ret[2]); + ret[3] = (cc1[3] == cc2[3]); + dbgprintf("Got three |%02x| |%02x| %d\n", cc1[3], cc2[3], ret[3]); + int retval; + if(ret[0] && ret[1] && ret[2] && ret[3]) + retval = 1; + else + retval = 0; + dbgprintf("Got retval %d\n", retval); + return retval; +} + +static void BRLYT_ReadDataFromMemoryX(void* destination, void* input, size_t size) +{ + u8* out = (u8*)destination; + u8* in = ((u8*)input) + BRLYT_fileoffset; + memcpy(out, in, size); +} + +static void BRLYT_ReadDataFromMemory(void* destination, void* input, size_t size) +{ + BRLYT_ReadDataFromMemoryX(destination, input, size); + BRLYT_fileoffset += size; +} + +int BRLYT_ReadEntries(u8* brlyt_file, size_t file_size, brlyt_header header, brlyt_entry* entries) +{ +/* BRLYT_fileoffset = be16(header.lyt_offset); + brlyt_entry_header tempentry; + int i; + dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size); + for(i = 0; BRLYT_fileoffset < file_size; i++) { + BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header)); + BRLYT_fileoffset += be32(tempentry.length); + dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size); + } + int entrycount = i; + entries = (brlyt_entry*)calloc(i, sizeof(brlyt_entry)); + dbgprintf("%08x\n", entries); + if(entries == NULL) { + printf("Couldn't allocate for entries!\n"); + exit(1); + } + BRLYT_fileoffset = be16(header.lyt_offset); + for(i = 0; i < entrycount; i++) { + dbgprintf("&(entries[i].realhead) = %08x\n", &(entries[i].realhead)); + BRLYT_ReadDataFromMemoryX(&(entries[i].realhead), brlyt_file, sizeof(brlyt_entry_header)); + entries[i].data_location = BRLYT_fileoffset + sizeof(brlyt_entry_header); + BRLYT_fileoffset += be32(tempentry.length); + } + return entrycount;*/ +} + +void BRLYT_CheckHeaderSanity(brlyt_header header, size_t filesize) +{ + if((header.magic[0] != 'R') || (header.magic[1] != 'L') || (header.magic[2] != 'Y') || (header.magic[3] != 'T')) { + printf("BRLYT magic doesn't match! %c%c%c%c\n", header.magic[0], header.magic[1], header.magic[2], header.magic[3]); + exit(1); + } + if(filesize != be32(header.filesize)) { + printf("BRLYT filesize doesn't match!\n"); + exit(1); + } +} + +void PrintBRLYTEntry_pic1(brlyt_entry entry, u8* brlyt_file) +{ +} + +void PrintBRLYTEntry_lyt1(brlyt_entry entry, u8* brlyt_file) +{ + brlyt_lyt1_chunk data; + BRLYT_fileoffset = entry.data_location; + BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_lyt1_chunk)); + printf(" Type: %c%c%c%c\n", entry.magic[0], entry.magic[1], entry.magic[2], entry.magic[3]); + printf(" unk1: %08x\n", be32(data.unk[0])); + printf(" unk2: %08x\n", be32(data.unk[1])); + printf(" unk3: %08x\n", be32(data.unk[2])); +} + +void PrintBRLYTEntry_grp1(brlyt_entry entry, u8* brlyt_file) +{ + brlyt_grp1_chunkbase data; + BRLYT_fileoffset = entry.data_location; + char name[16]; + u16 numsubs; + u16 unk; + BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_grp1_chunkbase)); + printf(" Name: %s\n", data.name); + printf(" Type: %c%c%c%c\n", entry.magic[0], entry.magic[1], entry.magic[2], entry.magic[3]); + printf(" Number of subs: %08x\n", be16(data.numsubs)); + printf(" unk: %08x\n", be16(data.unk)); +} + +void PrintBRLYTEntry_img(brlyt_entry entry, u8* brlyt_file) +{ + brlyt_img_chunk data; + BRLYT_fileoffset = entry.data_location; + BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_img_chunk)); + printf(" Type: %c%c%c%c\n", entry.magic[0], entry.magic[1], entry.magic[2], entry.magic[3]); + printf(" Number: %d\n", be16(data.num)); + printf(" Offset: %04x\n", be16(data.offs)); +} + +void PrintBRLYTEntries(brlyt_entry *entries, int entrycnt, u8* brlyt_file) +{ + int i; + + for(i = 0; i < entrycnt; i++) { + printf("\n Index %d (@%08x):\n", i, entries[i].data_location - 8); + if((FourCCsMatch(entries[i].magic, pic1_magic) == 1) || (FourCCsMatch(entries[i].magic, pan1_magic) == 1) || + (FourCCsMatch(entries[i].magic, bnd1_magic) == 1) || (FourCCsMatch(entries[i].magic, wnd1_magic) == 1)) { + dbgprintf("pic1\n"); +// PrintBRLYTEntry_pic1(entries[i], brlyt_file); + brlyt_pic1_chunk data; + BRLYT_fileoffset = entries[i].data_location; + BRLYT_ReadDataFromMemory(&data, brlyt_file, sizeof(brlyt_pic1_chunk)); + printf("%08x\n", BRLYT_fileoffset); + printf(" Name: %s (%08x)\n", data.name); + 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]); + }else if((FourCCsMatch(entries[i].magic, lyt1_magic) == 1)) { + dbgprintf("lyt1\n"); + PrintBRLYTEntry_lyt1(entries[i], brlyt_file); + }else if((FourCCsMatch(entries[i].magic, grp1_magic) == 1)) { + dbgprintf("grp1\n"); + PrintBRLYTEntry_grp1(entries[i], brlyt_file); + }else if((FourCCsMatch(entries[i].magic, txl1_magic) == 1) || (FourCCsMatch(entries[i].magic, mat1_magic) == 1) || + (FourCCsMatch(entries[i].magic, fnl1_magic) == 1)) { + dbgprintf("img\n"); + PrintBRLYTEntry_img(entries[i], brlyt_file); + }else + printf(" Unknown tag (%c%c%c%c)!\n",entries[i].magic[0],entries[i].magic[1],entries[i].magic[2],entries[i].magic[3]); + } +} + +void parse_brlyt(char *filename) +{ + FILE* fp = fopen(filename, "rb"); + if(fp == NULL) { + printf("Error! Couldn't open %s!\n", filename); + exit(1); + } + fseek(fp, 0, SEEK_END); + size_t file_size = ftell(fp); + dbgprintf("Filesize is %d\n", file_size); + u8* brlyt_file = (u8*)malloc(file_size); + dbgprintf("brlyt_file allocated\n"); + fseek(fp, 0, SEEK_SET); + fread(brlyt_file, file_size, 1, fp); + dbgprintf("brlyt_file read to.\n"); + BRLYT_fileoffset = 0; + brlyt_header header; + BRLYT_ReadDataFromMemory(&header, brlyt_file, sizeof(brlyt_header)); + BRLYT_CheckHeaderSanity(header, file_size); + brlyt_entry *entries; + BRLYT_fileoffset = be16(header.lyt_offset); + brlyt_entry_header tempentry; + int i; + dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size); + for(i = 0; BRLYT_fileoffset < file_size; i++) { + BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header)); + BRLYT_fileoffset += be32(tempentry.length); + dbgprintf("curr %08x max %08x\n", BRLYT_fileoffset, file_size); + } + int entrycount = i; + entries = (brlyt_entry*)calloc(entrycount, sizeof(brlyt_entry)); + dbgprintf("%08x\n", entries); + if(entries == NULL) { + printf("Couldn't allocate for entries!\n"); + exit(1); + } + BRLYT_fileoffset = be16(header.lyt_offset); + for(i = 0; i < entrycount; i++) { + dbgprintf("&(entries[i]) = %08x\n", &(entries[i])); + BRLYT_ReadDataFromMemoryX(&tempentry, brlyt_file, sizeof(brlyt_entry_header)); + memcpy(entries[i].magic, tempentry.magic, 4); + entries[i].length = tempentry.length; + entries[i].data_location = BRLYT_fileoffset + sizeof(brlyt_entry_header); + BRLYT_fileoffset += be32(tempentry.length); + } +// int entrycnt = BRLYT_ReadEntries(brlyt_file, file_size, header, entries); + dbgprintf("%08x\n", entries); + printf("Parsed BRLYT! Information:\n"); + printf("Main header:\n"); + printf(" Magic: %c%c%c%c\n", header.magic[0], header.magic[1], header.magic[2], header.magic[3]); + printf(" Unk1: %08x\n", be32(header.unk1)); + printf(" Filesize: %lu\n", be32(header.filesize)); + printf(" %s real file size!\n", be32(header.filesize) == file_size ? "Matches" : "Does not match"); + printf(" Offset to lyt1: %04x\n", be16(header.lyt_offset)); + printf(" Unk2: %04x\n", be16(header.unk2)); + printf("\nBRLYT Entries:"); + PrintBRLYTEntries(entries, entrycount, brlyt_file); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -0,0 +1,73 @@ +/* + * brlyt.h + * + * + * Created by Alex Marshall on 09/01/27. + * Copyright 2009 __MyCompanyName__. All rights reserved. + * + */ + +#ifndef BRLYT_H_ +#define BRLYT_H_ + +#include "types.h" + +typedef struct +{ + fourcc magic; // RLYT + u32 unk1; // 0xFEFF0008 + u32 filesize; // The filesize of the brlyt. + u16 lyt_offset; // Offset to the lyt1 section. + u16 unk2; // Unknown. +} brlyt_header; + +typedef struct +{ + fourcc magic; // The magic. + u32 length; // How long the entry is. +} brlyt_entry_header; + +typedef struct +{ + fourcc magic; // The magic. + u32 length; // How long the entry is. + u32 data_location; // The location of the data in the BRLYT file. +} brlyt_entry; + +typedef struct +{ + u16 flags; + u16 alpha; + char name[0x18]; + f32 x; + f32 y; + f32 unk[3]; + f32 angle; + f32 xmag; + f32 ymag; + f32 width; + f32 height; +} brlyt_pic1_chunk; + +typedef struct +{ + u32 unk[3]; +} brlyt_lyt1_chunk; + +typedef struct +{ + char name[16]; + u16 numsubs; + u16 unk; +} brlyt_grp1_chunkbase; + +typedef struct +{ + u16 num; + u16 offs; +} brlyt_img_chunk; +// 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); + +#endif //BRLYT_H_
\ No newline at end of file |