static bool loadResourceHighScores(file_t fp)
{
size_t i;
U16 u16Temp;
U32 u32Temp;
resource_hiscore_t dataTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
screen_nbr_hiscores = letoh16(u16Temp);
screen_highScores = sysmem_push(screen_nbr_hiscores * sizeof(*screen_highScores));
if (!screen_highScores)
{
return false;
}
for (i = 0; i < screen_nbr_hiscores; ++i)
{
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u32Temp, dataTemp.score, sizeof(U32));
screen_highScores[i].score = letoh32(u32Temp);
memcpy(screen_highScores[i].name, dataTemp.name, HISCORE_NAME_SIZE);
}
return true;
}
static bool loadResourceImapsteps(file_t fp)
{
size_t i;
U16 u16Temp;
resource_imapsteps_t dataTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
screen_nbr_imapstesps = letoh16(u16Temp);
screen_imapsteps = sysmem_push(screen_nbr_imapstesps * sizeof(*screen_imapsteps));
if (!screen_imapsteps)
{
return false;
}
for (i = 0; i < screen_nbr_imapstesps; ++i)
{
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.count, sizeof(U16));
screen_imapsteps[i].count = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.dx, sizeof(U16));
screen_imapsteps[i].dx = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.dy, sizeof(U16));
screen_imapsteps[i].dy = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.base, sizeof(U16));
screen_imapsteps[i].base = letoh16(u16Temp);
}
return true;
}
static bool loadResourceSubmaps(file_t fp)
{
size_t i;
U16 u16Temp;
resource_submap_t dataTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
map_nbr_submaps = letoh16(u16Temp);
map_submaps = sysmem_push(map_nbr_submaps * sizeof(*map_submaps));
if (!map_submaps)
{
return false;
}
for (i = 0; i < map_nbr_submaps; ++i)
{
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.page, sizeof(U16));
map_submaps[i].page = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.bnum, sizeof(U16));
map_submaps[i].bnum = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.connect, sizeof(U16));
map_submaps[i].connect = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.mark, sizeof(U16));
map_submaps[i].mark = letoh16(u16Temp);
}
return true;
}
/*
* load 16b length + not-terminated string
*/
static bool loadString(file_t fp, char ** buffer, const char terminator)
{
size_t length;
U16 u16Temp;
char * bufferTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
length = letoh16(u16Temp);
bufferTemp = sysmem_push(length + 1);
*buffer = bufferTemp;
if (!bufferTemp)
{
return false;
}
if (length)
{
if (sysfile_read(fp, bufferTemp, length, 1) != 1)
{
return false;
}
}
bufferTemp[length] = terminator;
return true;
}
static bool loadResourceSpritesData(file_t fp)
{
size_t i, j;
U16 u16Temp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
sprites_nbr_sprites = letoh16(u16Temp);
sprites_data = sysmem_push(sprites_nbr_sprites * sizeof(*sprites_data));
if (!sprites_data)
{
return false;
}
#ifdef GFXST
for (i = 0; i < sprites_nbr_sprites; ++i)
{
for (j = 0; j < SPRITES_NBR_DATA; ++j)
{
U32 u32Temp;
if (sysfile_read(fp, &u32Temp, sizeof(u32Temp), 1) != 1)
{
return false;
}
sprites_data[i][j] = letoh32(u32Temp);
}
}
#endif /* GFXST */
#ifdef GFXPC
for (i = 0; i < sprites_nbr_sprites; ++i)
{
for (j = 0; j < SPRITES_NBR_COLS; ++j)
{
size_t k;
for (k = 0; k < SPRITES_NBR_ROWS; ++k)
{
resource_spriteX_t dataTemp;
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.mask, sizeof(U16));
sprites_data[i][j][k].mask = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.pict, sizeof(U16));
sprites_data[i][j][k].pict = letoh16(u16Temp);
}
}
}
#endif /* GFXPC */
return true;
}
static bool loadImage(file_t fp, img_t ** image)
{
U16 u16Temp;
size_t pixelCount, colorCount;
resource_pic_t dataTemp;
img_t * imgTemp;
void * vp;
bool success;
imgTemp = sysmem_push(sizeof(*imgTemp));
*image = imgTemp;
if (!imgTemp)
{
return false;
}
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.width, sizeof(U16));
imgTemp->width = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.height, sizeof(U16));
imgTemp->height = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.xPos, sizeof(U16));
imgTemp->xPos = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.yPos, sizeof(U16));
imgTemp->yPos = letoh16(u16Temp);
vp = imgTemp->colors;
success = loadRawData(fp, &vp, sizeof(*imgTemp->colors), &colorCount);
imgTemp->ncolors = colorCount;
imgTemp->colors = vp;
if (!success)
{
return false;
}
pixelCount = (imgTemp->width * imgTemp->height); /*we use 8b per pixel*/
imgTemp->pixels = sysmem_push(pixelCount * sizeof(U8));
if (!imgTemp->pixels)
{
return false;
}
if (sysfile_read(fp, imgTemp->pixels, sizeof(U8), pixelCount) != (int)pixelCount)
{
return false;
}
return true;
}
static bool readHeader(file_t fp, const unsigned id)
{
resource_header_t header;
U16 u16Temp;
if (sysfile_read(fp, &header, sizeof(header), 1) != 1)
{
sys_error("(resources) unable to read header from \"%s\"", resourceFiles[id]);
return false;
}
if (memcmp(header.magic, resource_magic, sizeof(header.magic)) != 0)
{
sys_error("(resources) wrong header for \"%s\"", resourceFiles[id]);
return false;
}
memcpy(&u16Temp, header.version, sizeof(u16Temp));
u16Temp = htole16(u16Temp);
if (u16Temp != DATA_VERSION)
{
sys_error("(resources) incompatible version for \"%s\"", resourceFiles[id]);
return false;
}
memcpy(&u16Temp, header.resourceId, sizeof(u16Temp));
u16Temp = htole16(u16Temp);
if (u16Temp != id)
{
sys_error("(resources) mismatching ID for \"%s\"", resourceFiles[id]);
return false;
}
return true;
}
static bool loadResourceImaptext(file_t fp)
{
size_t i;
U16 u16Temp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
screen_nbr_imaptext = letoh16(u16Temp);
screen_imaptext = sysmem_push(screen_nbr_imaptext * sizeof(*screen_imaptext));
if (!screen_imapsteps)
{
return false;
}
for (i = 0; i < screen_nbr_imaptext; ++i)
{
if (!loadString(fp, (char **)(&(screen_imaptext[i])), 0xFE))
{
return false;
}
}
return true;
}
void filein_access(t_filein *x, t_symbol *s, short ac, t_atom *av)
{
OSErr err;
Byte data[8];
long count;
unsigned long dummy;
if (s==ps_int)
count = 1;
else if (s==ps_in1)
count = 2;
else
count = 4;
err = sysfile_setpos(x->f_fh,SYSFILE_FROMSTART,av->a_w.w_long);
if (err)
object_error((t_object *)x, "seek err %d",err);
else {
err = sysfile_read(x->f_fh,&count,data);
if (err)
object_error((t_object *)x, "read err %d",err);
else {
if (count==1)
dummy = data[0];
else
sysmem_copyptr(data,&dummy,count);
outlet_int(x->f_out,dummy);
}
}
}
static uint32_t sys_read(uint32_t arg[])
{
int fd = (int)arg[0];
void *base = (void *)arg[1];
size_t len = (size_t) arg[2];
return sysfile_read(fd, base, len);
}
static bool loadResourceMaps(file_t fp)
{
size_t i;
U16 u16Temp;
resource_map_t dataTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
map_nbr_maps = letoh16(u16Temp);
map_maps = sysmem_push(map_nbr_maps * sizeof(*map_maps));
if (!map_maps)
{
return false;
}
for (i = 0; i < map_nbr_maps; ++i)
{
#ifdef ENABLE_SOUND
sound_t **soundTemp;
#endif
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.x, sizeof(U16));
map_maps[i].x = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.y, sizeof(U16));
map_maps[i].y = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.row, sizeof(U16));
map_maps[i].row = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.submap, sizeof(U16));
map_maps[i].submap = letoh16(u16Temp);
#ifdef ENABLE_SOUND
memcpy(&u16Temp, dataTemp.tuneId, sizeof(U16));
if (!fromResourceIdToSound(letoh16(u16Temp), &soundTemp))
{
return false;
}
map_maps[i].tune = *soundTemp;
#endif /* ENABLE_SOUND */
}
return true;
}
static bool loadPicture(file_t fp, pic_t ** picture)
{
U16 u16Temp;
size_t i, pixelWords32b;
resource_pic_t dataTemp;
pic_t * picTemp;
picTemp = sysmem_push(sizeof(*picTemp));
*picture = picTemp;
if (!picTemp)
{
return false;
}
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
memcpy(&u16Temp, dataTemp.width, sizeof(U16));
picTemp->width = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.height, sizeof(U16));
picTemp->height = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.xPos, sizeof(U16));
picTemp->xPos = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.yPos, sizeof(U16));
picTemp->yPos = letoh16(u16Temp);
pixelWords32b = (picTemp->width * picTemp->height) / 8; /*we use 4b per pixel*/
picTemp->pixels = sysmem_push(pixelWords32b * sizeof(U32));
if (!picTemp->pixels)
{
return false;
}
for (i = 0; i < pixelWords32b; ++i)
{
U32 u32Temp;
if (sysfile_read(fp, &u32Temp, sizeof(u32Temp), 1) != 1)
{
return false;
}
picTemp->pixels[i] = letoh32(u32Temp);
}
return true;
}
static bool loadResourceTilesData(file_t fp)
{
size_t i, j, k;
U16 u16Temp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
tiles_nbr_banks = letoh16(u16Temp);
tiles_data = sysmem_push(tiles_nbr_banks * TILES_NBR_TILES * sizeof(*tiles_data));
if (!tiles_data)
{
return false;
}
for (i = 0; i < tiles_nbr_banks ; ++i)
{
for (j = 0; j < TILES_NBR_TILES; ++j)
{
for (k = 0; k < TILES_NBR_LINES ; ++k)
{
#ifdef GFXPC
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
tiles_data[i * TILES_NBR_TILES + j][k] = letoh16(u16Temp);
#endif /* GFXPC */
#ifdef GFXST
U32 u32Temp;
if (sysfile_read(fp, &u32Temp, sizeof(u32Temp), 1) != 1)
{
return false;
}
tiles_data[i * TILES_NBR_TILES + j][k] = letoh32(u32Temp);
#endif /* GFXST */
}
}
}
return true;
}
static int
load_icode_read(int fd, void *buf, size_t len, off_t offset) {
int ret;
if ((ret = sysfile_seek(fd, offset, LSEEK_SET)) != 0) {
return ret;
}
if ((ret = sysfile_read(fd, buf, len)) != len) {
return (ret < 0) ? ret : -1;
}
return 0;
}
int fread(void *ptr, size_t size, size_t nmemb, FILE *f) {
long count = size * nmemb;
long errorCode;
errorCode = sysfile_read(f, &count, ptr);
if (errorCode != 0) {
post("sysfile_read error %d - aren't you glad you asked?", errorCode);
}
return count/size;
}
static bool loadRawData(file_t fp, void ** buffer, const size_t size, size_t * count)
{
U16 u16Temp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
*count = letoh16(u16Temp);
*buffer = sysmem_push((*count) * size);
if (!(*buffer))
{
return false;
}
if (sysfile_read(fp, *buffer, size, *count) != (int)(*count))
{
return false;
}
return true;
}
static bool checkCrc32(const unsigned id)
{
int bytesRead;
U8 tempBuffer[1024];
U32 expectedCrc32, calculatedCrc32 = MZ_CRC32_INIT;
file_t fp = sysfile_open(resourceFiles[id]);
if (fp == NULL)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
bytesRead = sysfile_read(fp, tempBuffer, sizeof(U32), 1); /* prepare beginning of buffer for the following loop */
if (bytesRead != 1)
{
sys_error("(resources) not enough data for \"%s\"", resourceFiles[id]);
sysfile_close(fp);
return false;
}
do
{
bytesRead = sysfile_read(fp, tempBuffer + sizeof(U32), sizeof(U8), sizeof(tempBuffer) - sizeof(U32));
calculatedCrc32 = mz_crc32(calculatedCrc32, tempBuffer, bytesRead);
memcpy(tempBuffer, tempBuffer + bytesRead, sizeof(U32));
} while (bytesRead == sizeof(tempBuffer) - sizeof(U32));
sysfile_close(fp);
memcpy(&expectedCrc32, tempBuffer, sizeof(U32));
expectedCrc32 = letoh32(expectedCrc32);
if (expectedCrc32 != calculatedCrc32)
{
sys_error("(resources) crc check failed for \"%s\"", resourceFiles[id]);
return false;
}
return true;
}
static bool loadResourceEntdata(file_t fp)
{
size_t i;
U16 u16Temp;
resource_entdata_t dataTemp;
if (sysfile_read(fp, &u16Temp, sizeof(u16Temp), 1) != 1)
{
return false;
}
ent_nbr_entdata = letoh16(u16Temp);
ent_entdata = sysmem_push(ent_nbr_entdata * sizeof(*ent_entdata));
if (!ent_entdata)
{
return false;
}
for (i = 0; i < ent_nbr_entdata; ++i)
{
if (sysfile_read(fp, &dataTemp, sizeof(dataTemp), 1) != 1)
{
return false;
}
ent_entdata[i].w = dataTemp.w;
ent_entdata[i].h = dataTemp.h;
memcpy(&u16Temp, dataTemp.spr, sizeof(U16));
ent_entdata[i].spr = letoh16(u16Temp);
memcpy(&u16Temp, dataTemp.sni, sizeof(U16));
ent_entdata[i].sni = letoh16(u16Temp);
ent_entdata[i].trig_w = dataTemp.trig_w;
ent_entdata[i].trig_h = dataTemp.trig_h;
ent_entdata[i].snd = dataTemp.snd;
}
return true;
}
void filein_open(t_filein *x, char *name)
{
long size;
if (x->f_spool)
x->f_open = TRUE;
else {
sysfile_geteof(x->f_fh,&size);
if (!(x->f_data = (Byte **)sysmem_newhandle(size)))
object_error((t_object *)x, "%s too big to read",name);
else {
sysmem_lockhandle((t_handle)x->f_data,1);
sysfile_read(x->f_fh,&size,*x->f_data);
x->f_size = size;
}
sysfile_close(x->f_fh);
}
x->f_spool = FALSE;
}
void filein_in2(t_filein *x, long n) /* long access */
{
t_atom info;
unsigned long data[4];
long count;
OSErr err;
if (x->f_open) {
if (isr()) {
atom_setlong(&info,n);
defer(x,(method)filein_access,ps_in2,1,&info);
} else {
err = sysfile_setpos(x->f_fh,SYSFILE_FROMSTART,n);
if (err)
object_error((t_object *)x, "seek err %d",err);
else {
count = 4;
err = sysfile_read(x->f_fh,&count,data);
if (err)
object_error((t_object *)x, "read err %d",err);
else {
count = data[0];
outlet_int(x->f_out,count);
}
}
}
} else if (x->f_data) {
if (n < 0)
object_error((t_object *)x, "access out of range");
else if (n >= x->f_size)
outlet_bang(x->f_eof);
else {
sysmem_copyptr(*(x->f_data)+n,data,4L);
outlet_int(x->f_out,data[0]);
}
}
}
void filein_int(t_filein *x, long n) /* byte access */
{
t_atom info;
Byte data[16];
long count;
OSErr err;
if (x->f_open) {
if (isr()) {
atom_setlong(&info,n);
defer(x,(method)filein_access,ps_int,1,&info);
} else {
err = sysfile_setpos(x->f_fh,SYSFILE_FROMSTART,n);
if (err)
object_error((t_object *)x, "seek err %d",err);
else {
count = 1;
err = sysfile_read(x->f_fh,&count,data);
if (err)
object_error((t_object *)x, "read err %d",err);
else {
count = data[0];
outlet_int(x->f_out,count);
}
}
}
} else if (x->f_data) {
if (n < 0)
object_error((t_object *)x, "access out of range");
else if (n >= x->f_size)
outlet_bang(x->f_eof);
else {
count = *((*(x->f_data))+n);
outlet_int(x->f_out,count);
}
}
}
static bool loadSound(const unsigned id)
{
sound_t ** sound;
file_t fp;
wave_header_t header;
U16 u16Temp;
U32 u32Temp;
int bytesRead;
bool isHeaderValid;
if (!fromResourceIdToSound(id, &sound))
{
return false;
}
*sound = sysmem_push(sizeof(**sound));
if (!*sound)
{
return false;
}
(*sound)->buf = NULL;
(*sound)->dispose = true; /* sounds are "fire and forget" by default */
(*sound)->name = u_strdup(resourceFiles[id]);
if (!(*sound)->name)
{
return false;
}
fp = sysfile_open(resourceFiles[id]);
if (!fp)
{
sys_error("(resources) unable to open \"%s\"", resourceFiles[id]);
return false;
}
bytesRead = sysfile_read(fp, &header, sizeof(header), 1);
sysfile_close(fp);
if (bytesRead != 1)
{
sys_error("(resources) unable to read WAVE header from \"%s\"", resourceFiles[id]);
return false;
}
isHeaderValid = false;
for (;;)
{
if (memcmp(header.riffChunkId, "RIFF", 4) ||
memcmp(header.riffType, "WAVE", 4) ||
memcmp(header.formatChunkId, "fmt ", 4) ||
memcmp(header.dataChunkId, "data", 4))
{
break;
}
memcpy(&u16Temp, header.audioFormat, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_AUDIO_FORMAT)
{
break;
}
memcpy(&u16Temp, header.channelCount, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_CHANNEL_COUNT)
{
break;
}
memcpy(&u32Temp, header.sampleRate, sizeof(u32Temp));
if (letoh32(u32Temp) != Wave_SAMPLE_RATE)
{
isHeaderValid = false;
break;
}
memcpy(&u16Temp, header.bitsPerSample, sizeof(u16Temp));
if (letoh16(u16Temp) != Wave_BITS_PER_SAMPLE)
{
isHeaderValid = false;
break;
}
memcpy(&u32Temp, header.dataChunkSize, sizeof(u32Temp));
(*sound)->len = letoh32(u32Temp);
isHeaderValid = true;
break;
}
if (!isHeaderValid)
{
sys_error("(resources) incompatible WAVE header for \"%s\"", resourceFiles[id]);
return false;
}
return true;
}
