bool
fileExists2(uio_DirHandle *dir, const char *fileName)
{
uio_Stream *stream;
stream = uio_fopen (dir, fileName, "rb");
if (stream == NULL)
return 0;
uio_fclose (stream);
return 1;
}
uio_Stream *
res_OpenResFile (uio_DirHandle *dir, const char *filename, const char *mode)
{
uio_Stream *fp;
struct stat sb;
if (uio_stat (dir, filename, &sb) == 0 && S_ISDIR(sb.st_mode))
return ((uio_Stream *) ~0);
fp = uio_fopen (dir, filename, mode);
return (fp);
}
BOOLEAN
DoSaveTeam (MELEE_STATE *pMS)
{
STAMP MsgStamp;
char file[NAME_MAX];
uio_Stream *stream;
CONTEXT OldContext;
bool saveOk = false;
snprintf (file, sizeof file, "%s.mle",
MeleeSetup_getTeamName (pMS->meleeSetup, pMS->side));
LockMutex (GraphicsLock);
OldContext = SetContext (ScreenContext);
ConfirmSaveLoad (&MsgStamp);
// Show the "Saving . . ." message.
UnlockMutex (GraphicsLock);
stream = uio_fopen (meleeDir, file, "wb");
if (stream != NULL)
{
saveOk = (MeleeTeam_serialize (&pMS->meleeSetup->teams[pMS->side],
stream) == 0);
uio_fclose (stream);
if (!saveOk)
uio_unlink (meleeDir, file);
}
pMS->load.top = 0;
pMS->load.cur = 0;
// Undo the screen damage done by the "Saving . . ." message.
LockMutex (GraphicsLock);
DrawStamp (&MsgStamp);
DestroyDrawable (ReleaseDrawable (MsgStamp.frame));
SetContext (OldContext);
UnlockMutex (GraphicsLock);
if (!saveOk)
SaveProblem ();
// Update the team list; a previously existing team may have been
// deleted when save failed.
LoadTeamList (pMS);
SelectTeamByFileName (pMS, file);
return (stream != 0);
}
static bool
moda_Open (THIS_PTR, uio_DirHandle *dir, const char *filename)
{
TFB_ModSoundDecoder* moda = (TFB_ModSoundDecoder*) This;
uio_Stream *fp;
MREADER* reader;
MODULE* mod;
fp = uio_fopen (dir, filename, "rb");
if (!fp)
{
moda->last_error = errno;
return false;
}
reader = moda_new_uioReader (fp);
if (!reader)
{
moda->last_error = -1;
uio_fclose (fp);
return false;
}
mod = Player_LoadGeneric (reader, 8, 0);
// can already dispose of reader and fileh
moda_delete_uioReader (reader);
uio_fclose (fp);
if (!mod)
{
log_add (log_Warning, "moda_Open(): could not load %s", filename);
return false;
}
moda->module = mod;
mod->extspd = 1;
mod->panflag = 1;
mod->wrap = 0;
mod->loop = 1;
This->format = moda_formats->stereo16;
This->frequency = md_mixfreq;
This->length = 0; // FIXME way to obtain this from mikmod?
moda->last_error = 0;
return true;
}
SDL_Surface *
sdluio_loadImage (uio_DirHandle *dir, const char *fileName) {
uio_Stream *stream;
SDL_RWops *rwops;
SDL_Surface *result;
stream = uio_fopen (dir, fileName, "rb");
if (stream == NULL)
{
SDL_SetError ("Couldn't open '%s': %s", fileName,
strerror(errno));
return NULL;
}
rwops = sdluio_makeRWops (stream);
result = IMG_Load_RW (rwops, 1);
return result;
}
static bool
LoadTeamImage (DIRENTRY DirEntry, MeleeTeam *team)
{
const char *fileName;
uio_Stream *stream;
fileName = GetDirEntryAddress (DirEntry);
stream = uio_fopen (meleeDir, fileName, "rb");
if (stream == NULL)
return false;
if (MeleeTeam_deserialize (team, stream) == -1)
return false;
uio_fclose (stream);
return true;
}
static bool
wava_Open (THIS_PTR, uio_DirHandle *dir, const char *filename)
{
TFB_WaveSoundDecoder* wava = (TFB_WaveSoundDecoder*) This;
WAVFileHdr_Struct FileHdr;
WAVChunkHdr_Struct ChunkHdr;
wava->fp = uio_fopen (dir, filename, "rb");
if (!wava->fp)
{
wava->last_error = errno;
return false;
}
wava->data_size = 0;
wava->data_ofs = 0;
// read wave header
if (!wava_readFileHeader (wava, &FileHdr))
{
wava->last_error = errno;
wava_Close (This);
return false;
}
if (FileHdr.Id != RIFF || FileHdr.Type != WAVE)
{
log_add (log_Warning, "wava_Open(): "
"not a wave file, ID 0x%08x, Type 0x%08x",
FileHdr.Id, FileHdr.Type);
wava_Close (This);
return false;
}
for (FileHdr.Size = ((FileHdr.Size + 1) & ~1) - 4; FileHdr.Size != 0;
FileHdr.Size -= (((ChunkHdr.Size + 1) & ~1) + 8))
{
if (!wava_readChunkHeader (wava, &ChunkHdr))
{
wava->last_error = errno;
wava_Close (This);
return false;
}
if (ChunkHdr.Id == FMT)
{
if (!wava_readFormatHeader (wava, &wava->FmtHdr))
{
wava->last_error = errno;
wava_Close (This);
return false;
}
uio_fseek (wava->fp, ChunkHdr.Size - 16, SEEK_CUR);
}
else
{
if (ChunkHdr.Id == DATA)
{
wava->data_size = ChunkHdr.Size;
wava->data_ofs = uio_ftell (wava->fp);
}
uio_fseek (wava->fp, ChunkHdr.Size, SEEK_CUR);
}
uio_fseek (wava->fp, ChunkHdr.Size & 1, SEEK_CUR);
}
if (!wava->data_size || !wava->data_ofs)
{
log_add (log_Warning, "wava_Open(): bad wave file,"
" no DATA chunk found");
wava_Close (This);
return false;
}
if (wava->FmtHdr.Format == 0x0001)
{
This->format = (wava->FmtHdr.Channels == 1 ?
(wava->FmtHdr.BitsPerSample == 8 ?
wava_formats->mono8 : wava_formats->mono16)
:
(wava->FmtHdr.BitsPerSample == 8 ?
wava_formats->stereo8 : wava_formats->stereo16)
);
This->frequency = wava->FmtHdr.SamplesPerSec;
}
else
{
log_add (log_Warning, "wava_Open(): unsupported format %x",
wava->FmtHdr.Format);
wava_Close (This);
return false;
}
uio_fseek (wava->fp, wava->data_ofs, SEEK_SET);
wava->max_pcm = wava->data_size / wava->FmtHdr.BlockAlign;
wava->cur_pcm = 0;
This->length = (float) wava->max_pcm / wava->FmtHdr.SamplesPerSec;
wava->last_error = 0;
return true;
}
void *
_GetCelData (uio_Stream *fp, DWORD length)
{
int cel_total, cel_index, n;
DWORD opos;
char CurrentLine[1024], filename[PATH_MAX];
TFB_Canvas *img;
AniData *ani;
DRAWABLE Drawable;
uio_MountHandle *aniMount = 0;
uio_DirHandle *aniDir = 0;
uio_Stream *aniFile = 0;
opos = uio_ftell (fp);
{
char *s1, *s2;
char aniDirName[PATH_MAX];
const char *aniFileName;
uint8 buf[4] = { 0, 0, 0, 0 };
uint32 header;
if (_cur_resfile_name == 0
|| (((s2 = 0), (s1 = strrchr (_cur_resfile_name, '/')) == 0)
&& (s2 = strrchr (_cur_resfile_name, '\\')) == 0))
{
n = 0;
}
else
{
if (s2 > s1)
s1 = s2;
n = s1 - _cur_resfile_name + 1;
}
uio_fread(buf, 4, 1, fp);
header = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
if (_cur_resfile_name && header == 0x04034b50)
{
// zipped ani file
if (n)
{
strncpy (aniDirName, _cur_resfile_name, n - 1);
aniDirName[n - 1] = 0;
aniFileName = _cur_resfile_name + n;
}
else
{
strcpy(aniDirName, ".");
aniFileName = _cur_resfile_name;
}
aniDir = uio_openDir (repository, aniDirName, 0);
aniMount = uio_mountDir (repository, aniDirName, uio_FSTYPE_ZIP,
aniDir, aniFileName, "/", autoMount,
uio_MOUNT_RDONLY | uio_MOUNT_TOP,
NULL);
aniFile = uio_fopen (aniDir, aniFileName, "r");
opos = 0;
n = 0;
}
else
{
// unpacked ani file
strncpy (filename, _cur_resfile_name, n);
aniFile = fp;
aniDir = contentDir;
}
}
cel_total = 0;
uio_fseek (aniFile, opos, SEEK_SET);
while (uio_fgets (CurrentLine, sizeof (CurrentLine), aniFile))
{
++cel_total;
}
img = HMalloc (sizeof (TFB_Canvas) * cel_total);
ani = HMalloc (sizeof (AniData) * cel_total);
if (!img || !ani)
{
log_add (log_Warning, "Couldn't allocate space for '%s'", _cur_resfile_name);
if (aniMount)
{
uio_fclose(aniFile);
uio_closeDir(aniDir);
uio_unmountDir(aniMount);
}
HFree (img);
HFree (ani);
return NULL;
}
cel_index = 0;
uio_fseek (aniFile, opos, SEEK_SET);
while (uio_fgets (CurrentLine, sizeof (CurrentLine), aniFile) && cel_index < cel_total)
{
sscanf (CurrentLine, "%s %d %d %d %d", &filename[n],
&ani[cel_index].transparent_color, &ani[cel_index].colormap_index,
&ani[cel_index].hotspot_x, &ani[cel_index].hotspot_y);
img[cel_index] = TFB_DrawCanvas_LoadFromFile (aniDir, filename);
if (img[cel_index] == NULL)
{
const char *err;
err = TFB_DrawCanvas_GetError ();
log_add (log_Warning, "_GetCelData: Unable to load image!");
if (err != NULL)
log_add (log_Warning, "Gfx Driver reports: %s", err);
}
else
{
++cel_index;
}
if ((int)uio_ftell (aniFile) - (int)opos >= (int)length)
break;
}
Drawable = NULL;
if (cel_index && (Drawable = AllocDrawable (cel_index)))
{
if (!Drawable)
{
while (cel_index--)
TFB_DrawCanvas_Delete (img[cel_index]);
HFree (Drawable);
Drawable = NULL;
}
else
{
FRAME FramePtr;
Drawable->Flags = WANT_PIXMAP;
Drawable->MaxIndex = cel_index - 1;
FramePtr = &Drawable->Frame[cel_index];
while (--FramePtr, cel_index--)
process_image (FramePtr, img, ani, cel_index);
}
}
if (Drawable == NULL)
log_add (log_Warning, "Couldn't get cel data for '%s'",
_cur_resfile_name);
if (aniMount)
{
uio_fclose(aniFile);
uio_closeDir(aniDir);
uio_unmountDir(aniMount);
}
HFree (img);
HFree (ani);
return Drawable;
}
void
_GetConversationData (const char *path, RESOURCE_DATA *resdata)
{
uio_Stream *fp;
long dataLen;
void *result;
int n, path_len, num_data_sets;
DWORD opos,
slen[MAX_STRINGS], StringOffs, tot_string_size,
clen[MAX_STRINGS], ClipOffs, tot_clip_size,
tslen[MAX_STRINGS], TSOffs, tot_ts_size;
char CurrentLine[1024], paths[1024], *clip_path, *ts_path,
*strdata, *clipdata, *ts_data;
uio_Stream *timestamp_fp = NULL;
/* Parse out the conversation components. */
strncpy (paths, path, 1023);
paths[1023] = '\0';
clip_path = strchr (paths, ':');
if (clip_path == NULL)
{
ts_path = NULL;
}
else
{
*clip_path = '\0';
clip_path++;
ts_path = strchr (clip_path, ':');
if (ts_path != NULL)
{
*ts_path = '\0';
ts_path++;
}
}
fp = res_OpenResFile (contentDir, paths, "rb");
if (fp == NULL)
{
log_add (log_Warning, "Warning: Can't open '%s'", paths);
resdata->ptr = NULL;
return;
}
dataLen = LengthResFile (fp);
log_add (log_Info, "\t'%s' -- conversation phrases -- %lu bytes", paths, dataLen);
if (clip_path)
log_add (log_Info, "\t'%s' -- voice clip directory", clip_path);
else
log_add (log_Info, "\tNo associated voice clips");
if (ts_path)
log_add (log_Info, "\t'%s' -- timestamps", ts_path);
else
log_add (log_Info, "\tNo associated timestamp file");
if (dataLen == 0)
{
log_add (log_Warning, "Warning: Trying to load empty file '%s'.", path);
goto err;
}
if ((strdata = HMalloc (tot_string_size = POOL_SIZE)) == 0)
goto err;
if ((clipdata = HMalloc (tot_clip_size = POOL_SIZE)) == 0)
{
HFree (strdata);
goto err;
}
ts_data = NULL;
path_len = clip_path ? strlen (clip_path) : 0;
if (ts_path && (timestamp_fp = uio_fopen (contentDir, ts_path,
"rb")))
{
if ((ts_data = HMalloc (tot_ts_size = POOL_SIZE)) == 0)
goto err;
}
opos = uio_ftell (fp);
n = -1;
StringOffs = ClipOffs = TSOffs = 0;
while (uio_fgets (CurrentLine, sizeof (CurrentLine), fp) && n < MAX_STRINGS - 1)
{
int l;
if (CurrentLine[0] == '#')
{
char CopyLine[1024];
char *s;
strcpy (CopyLine, CurrentLine);
s = strtok (&CopyLine[1], "()");
if (s)
{
if (n >= 0)
{
while (slen[n] > 1 &&
(strdata[StringOffs - 2] == '\n' ||
strdata[StringOffs - 2] == '\r'))
{
--slen[n];
--StringOffs;
strdata[StringOffs - 1] = '\0';
}
}
slen[++n] = 0;
// now lets check for timestamp data
if (timestamp_fp)
{
char TimeStampLine[1024], *tsptr;
BOOLEAN ts_ok = FALSE;
uio_fgets (TimeStampLine, sizeof (TimeStampLine), timestamp_fp);
if (TimeStampLine[0] == '#')
{
tslen[n] = 0;
if ((tsptr = strstr (TimeStampLine,s))
&& (tsptr += strlen(s))
&& (++tsptr))
{
ts_ok = TRUE;
while (! strcspn(tsptr," \t\r\n") && *tsptr)
tsptr++;
if (*tsptr)
{
l = strlen (tsptr) + 1;
if (TSOffs + l > tot_ts_size
&& (ts_data = HRealloc (ts_data,
tot_ts_size += POOL_SIZE)) == 0)
{
HFree (strdata);
goto err;
}
strcpy (&ts_data[TSOffs], tsptr);
TSOffs += l;
tslen[n] = l;
}
}
}
if (!ts_ok)
{
// timestamp data is invalid, remove all of it
log_add (log_Warning, "Invalid timestamp data "
"for '%s'. Disabling timestamps", s);
HFree (ts_data);
ts_data = NULL;
uio_fclose (timestamp_fp);
timestamp_fp = NULL;
TSOffs = 0;
}
}
clen[n] = 0;
s = strtok (NULL, " \t\r\n)");
if (s)
{
l = path_len + strlen (s) + 1;
if (ClipOffs + l > tot_clip_size
&& (clipdata = HRealloc (clipdata,
tot_clip_size += POOL_SIZE)) == 0)
{
HFree (strdata);
goto err;
}
if (clip_path)
strcpy (&clipdata[ClipOffs], clip_path);
strcpy (&clipdata[ClipOffs + path_len], s);
ClipOffs += l;
clen[n] = l;
}
}
}
else if (n >= 0)
{
char *s;
l = strlen (CurrentLine) + 1;
if (StringOffs + l > tot_string_size
&& (strdata = HRealloc (strdata,
tot_string_size += POOL_SIZE)) == 0)
{
HFree (clipdata);
goto err;
}
if (slen[n])
{
--slen[n];
--StringOffs;
}
s = &strdata[StringOffs];
slen[n] += l;
StringOffs += l;
strcpy (s, CurrentLine);
}
if ((int)uio_ftell (fp) - (int)opos >= (int)dataLen)
break;
}
if (n >= 0)
{
while (slen[n] > 1 && (strdata[StringOffs - 2] == '\n'
|| strdata[StringOffs - 2] == '\r'))
{
--slen[n];
--StringOffs;
strdata[StringOffs - 1] = '\0';
}
}
if (timestamp_fp)
uio_fclose (timestamp_fp);
result = NULL;
num_data_sets = (ClipOffs ? 1 : 0) + (TSOffs ? 1 : 0) + 1;
if (++n)
{
int flags = 0;
if (ClipOffs)
flags |= HAS_SOUND_CLIPS;
if (TSOffs)
flags |= HAS_TIMESTAMP;
result = AllocStringTable (n, flags);
if (result)
{
int StringIndex, ClipIndex, TSIndex;
STRING_TABLE_DESC *lpST;
lpST = (STRING_TABLE) result;
StringIndex = 0;
ClipIndex = n;
TSIndex = n * ((flags & HAS_SOUND_CLIPS) ? 2 : 1);
StringOffs = ClipOffs = TSOffs = 0;
for (n = 0; n < (int)lpST->size;
++n, ++StringIndex, ++ClipIndex, ++TSIndex)
{
set_strtab_entry(lpST, StringIndex, strdata + StringOffs, slen[n]);
StringOffs += slen[n];
if (lpST->flags & HAS_SOUND_CLIPS)
{
set_strtab_entry(lpST, ClipIndex, clipdata + ClipOffs, clen[n]);
ClipOffs += clen[n];
}
if (lpST->flags & HAS_TIMESTAMP)
{
set_strtab_entry(lpST, TSIndex, ts_data + TSOffs, tslen[n]);
TSOffs += tslen[n];
}
}
}
}
HFree (strdata);
HFree (clipdata);
if (ts_data)
HFree (ts_data);
resdata->ptr = result;
return;
err:
res_CloseResFile (fp);
resdata->ptr = NULL;
}
static bool
wava_Open (THIS_PTR, uio_DirHandle *dir, const char *filename)
{
TFB_WaveSoundDecoder* wava = (TFB_WaveSoundDecoder*) This;
wave_FileHeader fileHdr;
wave_ChunkHeader chunkHdr;
wava->fp = uio_fopen (dir, filename, "rb");
if (!wava->fp)
{
wava->last_error = errno;
return false;
}
wava->data_size = 0;
wava->data_ofs = 0;
// read wave header
if (!wava_readFileHeader (wava, &fileHdr))
{
wava->last_error = errno;
wava_Close (This);
return false;
}
if (fileHdr.id != wave_RiffID || fileHdr.type != wave_WaveID)
{
log_add (log_Warning, "wava_Open(): "
"not a wave file, ID 0x%08x, Type 0x%08x",
fileHdr.id, fileHdr.type);
wava_Close (This);
return false;
}
for (fileHdr.size = ((fileHdr.size + 1) & ~1) - 4; fileHdr.size != 0;
fileHdr.size -= (((chunkHdr.size + 1) & ~1) + 8))
{
if (!wava_readChunkHeader (wava, &chunkHdr))
{
wava_Close (This);
return false;
}
if (chunkHdr.id == wave_FmtID)
{
if (!wava_readFormatHeader (wava, &wava->fmtHdr))
{
wava_Close (This);
return false;
}
uio_fseek (wava->fp, chunkHdr.size - 16, SEEK_CUR);
}
else
{
if (chunkHdr.id == wave_DataID)
{
wava->data_size = chunkHdr.size;
wava->data_ofs = uio_ftell (wava->fp);
}
uio_fseek (wava->fp, chunkHdr.size, SEEK_CUR);
}
// 2-align the file ptr
// XXX: I do not think this is necessary in WAVE files;
// possibly a remnant of ported AIFF reader
uio_fseek (wava->fp, chunkHdr.size & 1, SEEK_CUR);
}
if (!wava->data_size || !wava->data_ofs)
{
log_add (log_Warning, "wava_Open(): bad wave file,"
" no DATA chunk found");
wava_Close (This);
return false;
}
if (wava->fmtHdr.format != 0x0001)
{ // not a PCM format
log_add (log_Warning, "wava_Open(): unsupported format %x",
wava->fmtHdr.format);
wava_Close (This);
return false;
}
if (wava->fmtHdr.channels != 1 && wava->fmtHdr.channels != 2)
{
log_add (log_Warning, "wava_Open(): unsupported number of channels %u",
(unsigned)wava->fmtHdr.channels);
wava_Close (This);
return false;
}
This->format = (wava->fmtHdr.channels == 1 ?
(wava->fmtHdr.bitsPerSample == 8 ?
wava_formats->mono8 : wava_formats->mono16)
:
(wava->fmtHdr.bitsPerSample == 8 ?
wava_formats->stereo8 : wava_formats->stereo16)
);
This->frequency = wava->fmtHdr.samplesPerSec;
uio_fseek (wava->fp, wava->data_ofs, SEEK_SET);
wava->max_pcm = wava->data_size / wava->fmtHdr.blockAlign;
wava->cur_pcm = 0;
This->length = (float) wava->max_pcm / wava->fmtHdr.samplesPerSec;
wava->last_error = 0;
return true;
}
static int
debugCmdFwriteTest(DebugContext *debugContext, int argc, char *argv[]) {
uio_Stream *stream;
const char testString[] = "0123456789\n";
if (argc != 2) {
fprintf(debugContext->err, "Invalid number of arguments.\n");
return 1;
}
stream = uio_fopen(debugContext->cwd, argv[1], "w+b");
if (stream == NULL) {
fprintf(debugContext->err, "Could not open file: %s\n",
strerror(errno));
goto err;
}
if (uio_fwrite(testString, strlen(testString), 1, stream) != 1) {
fprintf(debugContext->err, "uio_fwrite() failed: %s\n",
strerror(errno));
goto err;
}
if (uio_fputs(testString, stream) == EOF) {
fprintf(debugContext->err, "uio_fputs() failed: %s\n",
strerror(errno));
goto err;
}
if (uio_fseek(stream, 15, SEEK_SET) != 0) {
fprintf(debugContext->err, "uio_fseek() failed: %s\n",
strerror(errno));
goto err;
}
if (uio_fputc('A', stream) != 'A') {
fprintf(debugContext->err, "uio_fputc() failed: %s\n",
strerror(errno));
goto err;
}
if (uio_fseek(stream, 0, SEEK_SET) != 0) {
fprintf(debugContext->err, "uio_fseek() failed: %s\n",
strerror(errno));
goto err;
}
{
char buf[6];
char *ptr;
int i;
i = 1;
while (1) {
ptr = uio_fgets(buf, sizeof buf, stream);
if (ptr == NULL)
break;
fprintf(debugContext->out, "%d: [%s]\n", i, ptr);
i++;
}
if (uio_ferror(stream)) {
fprintf(debugContext->err, "uio_fgets() failed: %s\n",
strerror(errno));
goto err;
}
uio_clearerr(stream);
}
if (uio_fseek(stream, 4, SEEK_END) != 0) {
fprintf(debugContext->err, "uio_fseek() failed: %s\n",
strerror(errno));
goto err;
}
{
char buf[2000];
memset(buf, 'Q', sizeof buf);
if (uio_fwrite(buf, 100, 20, stream) != 20) {
fprintf(debugContext->err, "uio_fwrite() failed: %s\n",
strerror(errno));
goto err;
}
}
if (uio_fseek(stream, 5, SEEK_SET) != 0) {
fprintf(debugContext->err, "uio_fseek() failed: %s\n",
strerror(errno));
goto err;
}
if (uio_fputc('B', stream) != 'B') {
fprintf(debugContext->err, "uio_fputc() failed: %s\n",
strerror(errno));
goto err;
}
uio_fclose(stream);
return 0;
err:
uio_fclose(stream);
return 1;
}
