int mame_ungetc(int c, mame_file *file)
{
/* switch off the file type */
switch (file->type)
{
case PLAIN_FILE:
if (osd_feof(file->file))
{
if (osd_fseek(file->file, 0, SEEK_CUR))
return c;
}
else
{
if (osd_fseek(file->file, -1, SEEK_CUR))
return c;
}
return EOF;
case RAM_FILE:
case ZIPPED_FILE:
if (file->eof)
file->eof = 0;
else if (file->offset > 0)
{
file->offset--;
return c;
}
return EOF;
}
return EOF;
}
/* Seek zip->fp to compressed data
return:
==0 success
<0 error
*/
int seekcompresszip(ZIP* zip, struct zipent* ent) {
char buf[ZIPNAME];
long offset;
if (!zip->fp) {
if (!revivezip(zip))
return -1;
}
if (osd_fseek(zip->fp, ent->offset_lcl_hdr_frm_frst_disk, SEEK_SET)!=0) {
errormsg ("Seeking to header", ERROR_CORRUPT, zip->zip);
return -1;
}
if (osd_fread(zip->fp, buf, ZIPNAME)!=ZIPNAME) {
errormsg ("Reading header", ERROR_CORRUPT, zip->zip);
return -1;
}
{
UINT16 filename_length = read_word (buf+ZIPFNLN);
UINT16 extra_field_length = read_word (buf+ZIPXTRALN);
/* calculate offset to data and osd_fseek() there */
offset = ent->offset_lcl_hdr_frm_frst_disk + ZIPNAME + filename_length + extra_field_length;
if (osd_fseek(zip->fp, offset, SEEK_SET) != 0) {
errormsg ("Seeking to compressed data", ERROR_CORRUPT, zip->zip);
return -1;
}
}
return 0;
}
int mame_fseek(mame_file *file, INT64 offset, int whence)
{
int err = 0;
/* switch off the file type */
switch (file->type)
{
case PLAIN_FILE:
return osd_fseek(file->file, offset, whence);
case ZIPPED_FILE:
case RAM_FILE:
switch (whence)
{
case SEEK_SET:
file->offset = offset;
break;
case SEEK_CUR:
file->offset += offset;
break;
case SEEK_END:
file->offset = file->length + offset;
break;
}
file->eof = 0;
break;
}
return err;
}
/* Read ecd data in zip structure
in:
zip->fp, zip->length zip file
out:
zip->ecd, zip->ecd_length ecd data
*/
static int ecd_read(ZIP* zip) {
char* buf;
int buf_length = 1024; /* initial buffer length */
while (1) {
int offset;
if (buf_length > zip->length)
buf_length = zip->length;
if (osd_fseek(zip->fp, zip->length - buf_length, SEEK_SET) != 0) {
return -1;
}
/* allocate buffer */
buf = (char*)malloc( buf_length );
if (!buf) {
return -1;
}
if (osd_fread( zip->fp, buf, buf_length ) != buf_length) {
free(buf);
return -1;
}
if (ecd_find_sig(buf, buf_length, &offset)) {
zip->ecd_length = buf_length - offset;
zip->ecd = (char*)malloc( zip->ecd_length );
if (!zip->ecd) {
free(buf);
return -1;
}
memcpy(zip->ecd, buf + offset, zip->ecd_length);
free(buf);
return 0;
}
free(buf);
if (buf_length < zip->length) {
/* double buffer */
buf_length = 2*buf_length;
logerror("Retry reading of zip ecd for %d bytes\n",buf_length);
} else {
return -1;
}
}
}
UINT64 mame_fsize(mame_file *file)
{
/* switch off the file type */
switch (file->type)
{
case PLAIN_FILE:
{
int size, offs;
offs = osd_ftell(file->file);
osd_fseek(file->file, 0, SEEK_END);
size = osd_ftell(file->file);
osd_fseek(file->file, offs, SEEK_SET);
return size;
}
case RAM_FILE:
case ZIPPED_FILE:
return file->length;
}
return 0;
}
void osd_rewind( OSD_FILE *stream )
{
(void)osd_fseek( stream, 0L, SEEK_SET );
osd_fflush( stream );
}
int wave_open(int id, int mode, void *args)
{
struct wave_file *w = &wave[id];
struct wave_args *wa = args;
int result;
/* wave already opened? */
if( w->file )
wave_close(id);
w->file = wa->file;
w->mode = mode;
w->fill_wave = wa->fill_wave;
w->smpfreq = wa->smpfreq;
w->display = wa->display;
if( w->mode )
{
w->resolution = 16;
w->samples = w->smpfreq;
w->length = w->samples * w->resolution / 8;
w->data = malloc(w->length);
if( !w->data )
{
logerror("WAVE malloc(%d) failed\n", w->length);
memset(w, 0, sizeof(struct wave_file));
return WAVE_ERR;
}
return INIT_OK;
}
else
{
result = wave_read(id);
if( result == WAVE_OK )
{
/* return sample frequency in the user supplied structure */
wa->smpfreq = w->smpfreq;
w->offset = 0;
return INIT_OK;
}
if( result == WAVE_FMT )
{
UINT8 *data;
int bytes, pos, length;
/* User supplied fill_wave function? */
if( w->fill_wave == NULL )
{
logerror("WAVE no fill_wave callback, failing now\n");
return WAVE_ERR;
}
logerror("WAVE creating wave using fill_wave() callback\n");
/* sanity check: default chunk size is one byte */
if( wa->chunk_size == 0 )
{
wa->chunk_size = 1;
logerror("WAVE chunk_size defaults to %d\n", wa->chunk_size);
}
if( wa->smpfreq == 0 )
{
wa->smpfreq = 11025;
logerror("WAVE smpfreq defaults to %d\n", w->smpfreq);
}
/* allocate a buffer for the binary data */
data = malloc(wa->chunk_size);
if( !data )
{
free(w->data);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
/* determine number of samples */
length =
wa->header_samples +
((osd_fsize(w->file) + wa->chunk_size - 1) / wa->chunk_size) * wa->chunk_samples +
wa->trailer_samples;
w->smpfreq = wa->smpfreq;
w->resolution = 16;
w->samples = length;
w->length = length * 2; /* 16 bits per sample */
w->data = malloc(w->length);
if( !w->data )
{
logerror("WAVE failed to malloc %d bytes\n", w->length);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
logerror("WAVE creating max %d:%02d samples (%d) at %d Hz\n", (w->samples/w->smpfreq)/60, (w->samples/w->smpfreq)%60, w->samples, w->smpfreq);
pos = 0;
/* if there has to be a header */
if( wa->header_samples > 0 )
{
length = (*w->fill_wave)((INT16 *)w->data + pos, w->samples - pos, CODE_HEADER);
if( length < 0 )
{
logerror("WAVE conversion aborted at header\n");
free(w->data);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
logerror("WAVE header %d samples\n", length);
pos += length;
}
/* convert the file data to samples */
bytes = 0;
osd_fseek(w->file, 0, SEEK_SET);
while( pos < w->samples )
{
length = osd_fread(w->file, data, wa->chunk_size);
if( length == 0 )
break;
bytes += length;
length = (*w->fill_wave)((INT16 *)w->data + pos, w->samples - pos, data);
if( length < 0 )
{
logerror("WAVE conversion aborted at %d bytes (%d samples)\n", bytes, pos);
free(w->data);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
pos += length;
}
logerror("WAVE converted %d data bytes to %d samples\n", bytes, pos);
/* if there has to be a trailer */
if( wa->trailer_samples )
{
if( pos < w->samples )
{
length = (*w->fill_wave)((INT16 *)w->data + pos, w->samples - pos, CODE_TRAILER);
if( length < 0 )
{
logerror("WAVE conversion aborted at trailer\n");
free(w->data);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
logerror("WAVE trailer %d samples\n", length);
pos += length;
}
}
if( pos < w->samples )
{
/* what did the fill_wave() calls really fill into the buffer? */
w->samples = pos;
w->length = pos * 2; /* 16 bits per sample */
w->data = realloc(w->data, w->length);
/* failure in the last step? how sad... */
if( !w->data )
{
logerror("WAVE realloc(%d) failed\n", w->length);
/* zap the wave structure */
memset(&wave[id], 0, sizeof(struct wave_file));
return WAVE_ERR;
}
}
logerror("WAVE %d samples - %d:%02d\n", w->samples, (w->samples/w->smpfreq)/60, (w->samples/w->smpfreq)%60);
/* hooray! :-) */
return INIT_OK;
}
}
return WAVE_ERR;
}
/*****************************************************************************
* helper functions
*****************************************************************************/
static int wave_read(int id)
{
struct wave_file *w = &wave[id];
UINT32 offset = 0;
UINT32 filesize, temp32;
UINT16 channels, bits, temp16;
char buf[32];
if( !w->file )
return WAVE_ERR;
/* read the core header and make sure it's a WAVE file */
offset += osd_fread(w->file, buf, 4);
if( offset < 4 )
{
logerror("WAVE read error at offs %d\n", offset);
return WAVE_ERR;
}
if( memcmp (&buf[0], "RIFF", 4) != 0 )
{
logerror("WAVE header not 'RIFF'\n");
return WAVE_FMT;
}
/* get the total size */
offset += osd_fread(w->file, &temp32, 4);
if( offset < 8 )
{
logerror("WAVE read error at offs %d\n", offset);
return WAVE_ERR;
}
filesize = intelLong(temp32);
logerror("WAVE filesize %u bytes\n", filesize);
/* read the RIFF file type and make sure it's a WAVE file */
offset += osd_fread(w->file, buf, 4);
if( offset < 12 )
{
logerror("WAVE read error at offs %d\n", offset);
return WAVE_ERR;
}
if( memcmp (&buf[0], "WAVE", 4) != 0 )
{
logerror("WAVE RIFF type not 'WAVE'\n");
return WAVE_FMT;
}
/* seek until we find a format tag */
while( 1 )
{
offset += osd_fread(w->file, buf, 4);
offset += osd_fread(w->file, &temp32, 4);
w->length = intelLong(temp32);
if( memcmp(&buf[0], "fmt ", 4) == 0 )
break;
/* seek to the next block */
osd_fseek(w->file, w->length, SEEK_CUR);
offset += w->length;
if( offset >= filesize )
{
logerror("WAVE no 'fmt ' tag found\n");
return WAVE_ERR;
}
}
/* read the format -- make sure it is PCM */
offset += osd_fread_lsbfirst(w->file, &temp16, 2);
if( temp16 != 1 )
{
logerror("WAVE format %d not supported (not = 1 PCM)\n", temp16);
return WAVE_ERR;
}
logerror("WAVE format %d (PCM)\n", temp16);
/* number of channels -- only mono is supported */
offset += osd_fread_lsbfirst(w->file, &channels, 2);
if( channels != 1 && channels != 2 )
{
logerror("WAVE channels %d not supported (only 1 mono or 2 stereo)\n", channels);
return WAVE_ERR;
}
logerror("WAVE channels %d\n", channels);
/* sample rate */
offset += osd_fread(w->file, &temp32, 4);
w->smpfreq = intelLong(temp32);
logerror("WAVE sample rate %d Hz\n", w->smpfreq);
/* bytes/second and block alignment are ignored */
offset += osd_fread(w->file, buf, 6);
/* bits/sample */
offset += osd_fread_lsbfirst(w->file, &bits, 2);
if( bits != 8 && bits != 16 )
{
logerror("WAVE %d bits/sample not supported (only 8/16)\n", bits);
return WAVE_ERR;
}
logerror("WAVE bits/sample %d\n", bits);
w->resolution = bits;
/* seek past any extra data */
osd_fseek(w->file, w->length - 16, SEEK_CUR);
offset += w->length - 16;
/* seek until we find a data tag */
while( 1 )
{
offset += osd_fread(w->file, buf, 4);
offset += osd_fread(w->file, &temp32, 4);
w->length = intelLong(temp32);
if( memcmp(&buf[0], "data", 4) == 0 )
break;
/* seek to the next block */
osd_fseek(w->file, w->length, SEEK_CUR);
offset += w->length;
if( offset >= filesize )
{
logerror("WAVE not 'data' tag found\n");
return WAVE_ERR;
}
}
/* allocate the game sample */
w->data = malloc(w->length);
if( w->data == NULL )
{
logerror("WAVE failed to malloc %d bytes\n", w->length);
return WAVE_ERR;
}
/* read the data in */
if( w->resolution == 8 )
{
if( osd_fread(w->file, w->data, w->length) != w->length )
{
logerror("WAVE failed read %d data bytes\n", w->length);
free(w->data);
return WAVE_ERR;
}
if( channels == 2 )
{
UINT8 *src = w->data;
INT8 *dst = w->data;
logerror("WAVE mixing 8-bit unsigned stereo to 8-bit signed mono\n");
/* convert stereo 8-bit data to mono signed samples */
for( temp32 = 0; temp32 < w->length/2; temp32++ )
{
*dst = ((src[0] + src[1]) / 2) ^ 0x80;
dst += 1;
src += 2;
}
w->length /= 2;
w->data = realloc(w->data, w->length);
if( w->data == NULL )
{
logerror("WAVE failed to malloc %d bytes\n", w->length);
return WAVE_ERR;
}
}
else
{
UINT8 *src = w->data;
INT8 *dst = w->data;
logerror("WAVE converting 8-bit unsigned to 8-bit signed\n");
/* convert 8-bit data to signed samples */
for( temp32 = 0; temp32 < w->length; temp32++ )
*dst++ = *src++ ^ 0x80;
}
}
else
{
/* 16-bit data is fine as-is */
if( osd_fread_lsbfirst(w->file, w->data, w->length) != w->length )
{
logerror("WAVE failed read %d data bytes\n", w->length);
free(w->data);
return WAVE_ERR;
}
if( channels == 2 )
{
INT16 *src = w->data;
INT16 *dst = w->data;
logerror("WAVE mixing 16-bit stereo to 16-bit mono\n");
/* convert stereo 16-bit data to mono */
for( temp32 = 0; temp32 < w->length/2; temp32++ )
{
*dst = ((INT32)src[0] + (INT32)src[1]) / 2;
dst += 1;
src += 2;
}
w->length /= 2;
w->data = realloc(w->data, w->length);
if( w->data == NULL )
{
logerror("WAVE failed to malloc %d bytes\n", w->length);
return WAVE_ERR;
}
}
else
{
logerror("WAVE using 16-bit signed samples as is\n");
}
}
w->samples = w->length * 8 / w->resolution;
logerror("WAVE %d samples - %d:%02d\n", w->samples, (w->samples/w->smpfreq)/60, (w->samples/w->smpfreq)%60);
return WAVE_OK;
}
int main (int argc, char **argv)
{
int res, i, j = 0, game_index;
char *playbackname = NULL;
int use_cyclone=0;
int use_drz80=0;
int use_drz80_snd=0;
extern int video_scale;
extern int video_border;
extern int video_aspect;
extern int throttle;
extern int wiz_ram_tweaks;
extern int wiz_rotated_video;
memset(&options,0,sizeof(options));
/* these two are not available in mame.cfg */
errorlog = 0;
game_index = -1;
for (i = 1;i < argc;i++) /* V.V_121997 */
{
if (strcasecmp(argv[i],"-log") == 0)
errorlog = fopen("error.log","wa");
if (strcasecmp(argv[i],"-cyclone") == 0)
use_cyclone=1;
if (strcasecmp(argv[i],"-drz80") == 0)
use_drz80=1;
if (strcasecmp(argv[i],"-drz80_snd") == 0)
use_drz80_snd=1;
if (strcasecmp(argv[i],"-scale") == 0)
video_scale=1;
if (strcasecmp(argv[i],"-border") == 0)
video_border=1;
if (strcasecmp(argv[i],"-aspect") == 0)
video_aspect=1;
if (strcasecmp(argv[i],"-nothrottle") == 0)
throttle=0;
if (strcasecmp(argv[i],"-ramtweaks") == 0)
wiz_ram_tweaks=1;
if ((strcasecmp(argv[i],"-clock") == 0) && (i<argc-1))
wiz_clock=atoi(argv[i+1]);
if (strcasecmp(argv[i],"-wiz_rotated_video") == 0)
wiz_rotated_video=1;
if (strcasecmp(argv[i],"-playback") == 0)
{
i++;
if (i < argc) /* point to inp file name */
playbackname = argv[i];
}
}
/* WIZ Initialization */
wiz_init(8,22050,16,0);
/* check for frontend options */
res = frontend_help (argc, argv);
/* if frontend options were used, return to DOS with the error code */
if (res != 1234)
{
wiz_deinit();
execl("mame.gpe", "mame.gpe", "cache", NULL);
exit (res);
}
/* handle playback which is not available in mame.cfg */
init_inpdir(); /* Init input directory for opening .inp for playback */
if (playbackname != NULL)
options.playback = osd_fopen(playbackname,0,OSD_FILETYPE_INPUTLOG,0);
/* check for game name embedded in .inp header */
if (options.playback)
{
INP_HEADER inp_header;
/* read playback header */
osd_fread(options.playback, &inp_header, sizeof(INP_HEADER));
if (!isalnum(inp_header.name[0])) /* If first byte is not alpha-numeric */
osd_fseek(options.playback, 0, SEEK_SET); /* old .inp file - no header */
else
{
for (i = 0; (drivers[i] != 0); i++) /* find game and play it */
{
if (strcmp(drivers[i]->name, inp_header.name) == 0)
{
game_index = i;
printf("Playing back previously recorded game %s (%s) [press return]\n",
drivers[game_index]->name,drivers[game_index]->description);
getchar();
break;
}
}
}
}
/* If not playing back a new .inp file */
if (game_index == -1)
{
/* take the first commandline argument without "-" as the game name */
for (j = 1; j < argc; j++)
{
if (argv[j][0] != '-') break;
}
{
for (i = 0; drivers[i] && (game_index == -1); i++)
{
if (strcasecmp(argv[j],drivers[i]->name) == 0)
{
game_index = i;
break;
}
}
/* educated guess on what the user wants to play */
if (game_index == -1)
{
int fuzz = 9999; /* best fuzz factor so far */
for (i = 0; (drivers[i] != 0); i++)
{
int tmp;
tmp = fuzzycmp(argv[j], drivers[i]->description);
/* continue if the fuzz index is worse */
if (tmp > fuzz)
continue;
/* on equal fuzz index, we prefer working, original games */
if (tmp == fuzz)
{
/* game is a clone */
if (drivers[i]->clone_of != 0
&& !(drivers[i]->clone_of->flags & NOT_A_DRIVER))
{
/* if the game we already found works, why bother. */
/* and broken clones aren't very helpful either */
if ((!drivers[game_index]->flags & GAME_NOT_WORKING) ||
(drivers[i]->flags & GAME_NOT_WORKING))
continue;
}
else continue;
}
/* we found a better match */
game_index = i;
fuzz = tmp;
}
if (game_index != -1)
printf("fuzzy name compare, running %s\n",drivers[game_index]->name);
}
}
if (game_index == -1)
{
printf("Game \"%s\" not supported\n", argv[j]);
return 1;
}
}
/* parse generic (os-independent) options */
parse_cmdline (argc, argv, game_index);
{ /* Mish: I need sample rate initialised _before_ rom loading for optional rom regions */
extern int soundcard;
if (soundcard == 0) { /* silence, this would be -1 if unknown in which case all roms are loaded */
Machine->sample_rate = 0; /* update the Machine structure to show that sound is disabled */
options.samplerate=0;
}
}
/* handle record which is not available in mame.cfg */
for (i = 1; i < argc; i++)
{
if (strcasecmp(argv[i],"-record") == 0)
{
i++;
if (i < argc)
options.record = osd_fopen(argv[i],0,OSD_FILETYPE_INPUTLOG,1);
}
}
if (options.record)
{
INP_HEADER inp_header;
memset(&inp_header, '\0', sizeof(INP_HEADER));
strcpy(inp_header.name, drivers[game_index]->name);
/* MAME32 stores the MAME version numbers at bytes 9 - 11
* MAME DOS keeps this information in a string, the
* Windows code defines them in the Makefile.
*/
/*
inp_header.version[0] = 0;
inp_header.version[1] = VERSION;
inp_header.version[2] = BETA_VERSION;
*/
osd_fwrite(options.record, &inp_header, sizeof(INP_HEADER));
}
/* Replace M68000 by CYCLONE */
if (use_cyclone)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
#ifdef NEOMAME
if (((*type)&0xff)==CPU_M68000)
#else
if (((*type)&0xff)==CPU_M68000 || ((*type)&0xff)==CPU_M68010 )
#endif
{
*type=((*type)&(~0xff))|CPU_CYCLONE;
}
}
}
/* Replace Z80 by DRZ80 */
if (use_drz80)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_Z80)
{
*type=((*type)&(~0xff))|CPU_DRZ80;
}
}
}
/* Replace Z80 with DRZ80 only for sound CPUs */
if (use_drz80_snd)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if ((((*type)&0xff)==CPU_Z80) && ((*type)&CPU_AUDIO_CPU))
{
*type=((*type)&(~0xff))|CPU_DRZ80;
}
}
}
/*
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_V30)
{
*type=((*type)&(~0xff))|CPU_ARMV30;
}
}
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_V33)
{
*type=((*type)&(~0xff))|CPU_ARMV33;
}
}
*/
// Remove the mouse usage for certain games
if ( (strcasecmp(drivers[game_index]->name,"hbarrel")==0) || (strcasecmp(drivers[game_index]->name,"hbarrelw")==0) ||
(strcasecmp(drivers[game_index]->name,"midres")==0) || (strcasecmp(drivers[game_index]->name,"midresu")==0) ||
(strcasecmp(drivers[game_index]->name,"midresj")==0) || (strcasecmp(drivers[game_index]->name,"tnk3")==0) ||
(strcasecmp(drivers[game_index]->name,"tnk3j")==0) || (strcasecmp(drivers[game_index]->name,"ikari")==0) ||
(strcasecmp(drivers[game_index]->name,"ikarijp")==0) || (strcasecmp(drivers[game_index]->name,"ikarijpb")==0) ||
(strcasecmp(drivers[game_index]->name,"victroad")==0) || (strcasecmp(drivers[game_index]->name,"dogosoke")==0) ||
(strcasecmp(drivers[game_index]->name,"gwar")==0) || (strcasecmp(drivers[game_index]->name,"gwarj")==0) ||
(strcasecmp(drivers[game_index]->name,"gwara")==0) || (strcasecmp(drivers[game_index]->name,"gwarb")==0) ||
(strcasecmp(drivers[game_index]->name,"bermudat")==0) || (strcasecmp(drivers[game_index]->name,"bermudaj")==0) ||
(strcasecmp(drivers[game_index]->name,"bermudaa")==0) || (strcasecmp(drivers[game_index]->name,"mplanets")==0) ||
(strcasecmp(drivers[game_index]->name,"forgottn")==0) || (strcasecmp(drivers[game_index]->name,"lostwrld")==0) ||
(strcasecmp(drivers[game_index]->name,"gondo")==0) || (strcasecmp(drivers[game_index]->name,"makyosen")==0) ||
(strcasecmp(drivers[game_index]->name,"topgunr")==0) || (strcasecmp(drivers[game_index]->name,"topgunbl")==0) ||
(strcasecmp(drivers[game_index]->name,"tron")==0) || (strcasecmp(drivers[game_index]->name,"tron2")==0) ||
(strcasecmp(drivers[game_index]->name,"kroozr")==0) ||(strcasecmp(drivers[game_index]->name,"crater")==0) ||
(strcasecmp(drivers[game_index]->name,"dotron")==0) || (strcasecmp(drivers[game_index]->name,"dotrone")==0) ||
(strcasecmp(drivers[game_index]->name,"zwackery")==0) || (strcasecmp(drivers[game_index]->name,"ikari3")==0) ||
(strcasecmp(drivers[game_index]->name,"searchar")==0) || (strcasecmp(drivers[game_index]->name,"sercharu")==0) ||
(strcasecmp(drivers[game_index]->name,"timesold")==0) || (strcasecmp(drivers[game_index]->name,"timesol1")==0) ||
(strcasecmp(drivers[game_index]->name,"btlfield")==0) || (strcasecmp(drivers[game_index]->name,"aztarac")==0))
{
extern int use_mouse;
use_mouse=0;
}
/* go for it */
printf ("%s (%s)...\n",drivers[game_index]->description,drivers[game_index]->name);
res = run_game (game_index);
/* close open files */
if (errorlog) fclose (errorlog);
if (options.playback) osd_fclose (options.playback);
if (options.record) osd_fclose (options.record);
if (options.language_file) osd_fclose (options.language_file);
if (res!=0)
{
/* wait a key press */
wiz_video_flip_single();
wiz_joystick_press(0);
}
wiz_deinit();
#ifndef PROFILE_GENERATE
execl("mame.gpe", "mame.gpe", "cache", NULL);
#endif
exit (res);
}
/* Opens a zip stream for reading
return:
!=0 success, zip stream
==0 error
*/
ZIP* openzip(int pathtype, int pathindex, const char* zipfile) {
/* allocate */
ZIP* zip = (ZIP*)malloc( sizeof(ZIP) );
if (!zip) {
return 0;
}
/* open */
zip->fp = osd_fopen(pathtype, pathindex, zipfile, "rb");
if (!zip->fp) {
errormsg ("Opening for reading", ERROR_FILESYSTEM, zipfile);
free(zip);
return 0;
}
/* go to end */
if (osd_fseek(zip->fp, 0L, SEEK_END) != 0) {
errormsg ("Seeking to end", ERROR_FILESYSTEM, zipfile);
osd_fclose(zip->fp);
free(zip);
return 0;
}
/* get length */
zip->length = osd_ftell(zip->fp);
if (zip->length < 0) {
errormsg ("Get file size", ERROR_FILESYSTEM, zipfile);
osd_fclose(zip->fp);
free(zip);
return 0;
}
if (zip->length == 0) {
errormsg ("Empty file", ERROR_CORRUPT, zipfile);
osd_fclose(zip->fp);
free(zip);
return 0;
}
/* read ecd data */
if (ecd_read(zip)!=0) {
errormsg ("Reading ECD (end of central directory)", ERROR_CORRUPT, zipfile);
osd_fclose(zip->fp);
free(zip);
return 0;
}
/* compile ecd info */
zip->end_of_cent_dir_sig = read_dword (zip->ecd+ZIPESIG);
zip->number_of_this_disk = read_word (zip->ecd+ZIPEDSK);
zip->number_of_disk_start_cent_dir = read_word (zip->ecd+ZIPECEN);
zip->total_entries_cent_dir_this_disk = read_word (zip->ecd+ZIPENUM);
zip->total_entries_cent_dir = read_word (zip->ecd+ZIPECENN);
zip->size_of_cent_dir = read_dword (zip->ecd+ZIPECSZ);
zip->offset_to_start_of_cent_dir = read_dword (zip->ecd+ZIPEOFST);
zip->zipfile_comment_length = read_word (zip->ecd+ZIPECOML);
zip->zipfile_comment = zip->ecd+ZIPECOM;
/* verify that we can work with this zipfile (no disk spanning allowed) */
if ((zip->number_of_this_disk != zip->number_of_disk_start_cent_dir) ||
(zip->total_entries_cent_dir_this_disk != zip->total_entries_cent_dir) ||
(zip->total_entries_cent_dir < 1)) {
errormsg("Cannot span disks", ERROR_UNSUPPORTED, zipfile);
free(zip->ecd);
osd_fclose(zip->fp);
free(zip);
return 0;
}
if (osd_fseek(zip->fp, zip->offset_to_start_of_cent_dir, SEEK_SET)!=0) {
errormsg ("Seeking to central directory", ERROR_CORRUPT, zipfile);
free(zip->ecd);
osd_fclose(zip->fp);
free(zip);
return 0;
}
/* read from start of central directory */
zip->cd = (char*)malloc( zip->size_of_cent_dir );
if (!zip->cd) {
free(zip->ecd);
osd_fclose(zip->fp);
free(zip);
return 0;
}
if (osd_fread(zip->fp, zip->cd, zip->size_of_cent_dir)!=zip->size_of_cent_dir) {
errormsg ("Reading central directory", ERROR_CORRUPT, zipfile);
free(zip->cd);
free(zip->ecd);
osd_fclose(zip->fp);
free(zip);
return 0;
}
/* reset ent */
zip->ent.name = 0;
/* rewind */
zip->cd_pos = 0;
/* file name */
zip->zip = (char*)malloc(strlen(zipfile)+1);
if (!zip->zip) {
free(zip->cd);
free(zip->ecd);
osd_fclose(zip->fp);
free(zip);
return 0;
}
strcpy(zip->zip, zipfile);
zip->pathtype = pathtype;
zip->pathindex = pathindex;
return zip;
}
static struct GameSample *read_wav_sample(void *f)
{
unsigned long offset = 0;
UINT32 length, rate, filesize, temp32;
UINT16 bits, temp16;
char buf[32];
struct GameSample *result;
/* read the core header and make sure it's a WAVE file */
offset += osd_fread(f, buf, 4);
if (offset < 4)
return NULL;
if (memcmp(&buf[0], "RIFF", 4) != 0)
return NULL;
/* get the total size */
offset += osd_fread(f, &filesize, 4);
if (offset < 8)
return NULL;
filesize = intelLong(filesize);
/* read the RIFF file type and make sure it's a WAVE file */
offset += osd_fread(f, buf, 4);
if (offset < 12)
return NULL;
if (memcmp(&buf[0], "WAVE", 4) != 0)
return NULL;
/* seek until we find a format tag */
while (1)
{
offset += osd_fread(f, buf, 4);
offset += osd_fread(f, &length, 4);
length = intelLong(length);
if (memcmp(&buf[0], "fmt ", 4) == 0)
break;
/* seek to the next block */
osd_fseek(f, length, SEEK_CUR);
offset += length;
if (offset >= filesize)
return NULL;
}
/* read the format -- make sure it is PCM */
offset += osd_fread_lsbfirst(f, &temp16, 2);
if (temp16 != 1)
return NULL;
/* number of channels -- only mono is supported */
offset += osd_fread_lsbfirst(f, &temp16, 2);
if (temp16 != 1)
return NULL;
/* sample rate */
offset += osd_fread(f, &rate, 4);
rate = intelLong(rate);
/* bytes/second and block alignment are ignored */
offset += osd_fread(f, buf, 6);
/* bits/sample */
offset += osd_fread_lsbfirst(f, &bits, 2);
if (bits != 8 && bits != 16)
return NULL;
/* seek past any extra data */
osd_fseek(f, length - 16, SEEK_CUR);
offset += length - 16;
/* seek until we find a data tag */
while (1)
{
offset += osd_fread(f, buf, 4);
offset += osd_fread(f, &length, 4);
length = intelLong(length);
if (memcmp(&buf[0], "data", 4) == 0)
break;
/* seek to the next block */
osd_fseek(f, length, SEEK_CUR);
offset += length;
if (offset >= filesize)
return NULL;
}
/* allocate the game sample */
result = malloc(sizeof(struct GameSample) + length);
if (result == NULL)
return NULL;
/* fill in the sample data */
result->length = length;
result->smpfreq = rate;
result->resolution = bits;
/* read the data in */
if (bits == 8)
{
osd_fread(f, result->data, length);
/* convert 8-bit data to signed samples */
for (temp32 = 0; temp32 < length; temp32++)
result->data[temp32] ^= 0x80;
}
else
{
/* 16-bit data is fine as-is */
osd_fread_lsbfirst(f, result->data, length);
}
return result;
}
int readroms(void)
{
int region;
const struct RomModule *romp;
int warning = 0;
int fatalerror = 0;
int total_roms,current_rom;
char buf[4096] = "";
total_roms = current_rom = 0;
romp = Machine->gamedrv->rom;
if (!romp) return 0;
while (romp->name || romp->offset || romp->length)
{
if (romp->name && romp->name != (char *)-1)
total_roms++;
romp++;
}
romp = Machine->gamedrv->rom;
for (region = 0;region < MAX_MEMORY_REGIONS;region++)
Machine->memory_region[region] = 0;
region = 0;
while (romp->name || romp->offset || romp->length)
{
unsigned int region_size;
const char *name;
/* Mish: An 'optional' rom region, only loaded if sound emulation is turned on */
if (Machine->sample_rate==0 && (romp->crc & REGIONFLAG_SOUNDONLY)) {
logerror("readroms(): Ignoring rom region %d\n",region);
Machine->memory_region_type[region] = romp->crc;
region++;
romp++;
while (romp->name || romp->length)
romp++;
continue;
}
if (romp->name || romp->length)
{
printf("Error in RomModule definition: expecting ROM_REGION\n");
goto getout;
}
region_size = romp->offset;
if ((Machine->memory_region[region] = (unsigned char *) malloc(region_size)) == 0)
{
printf("readroms(): Unable to allocate %d bytes of RAM\n",region_size);
goto getout;
}
Machine->memory_region_length[region] = region_size;
Machine->memory_region_type[region] = romp->crc;
/* some games (i.e. Pleiades) want the memory clear on startup */
if (region_size <= 0x400000) /* don't clear large regions which will be filled anyway */
memset(Machine->memory_region[region],0,region_size);
romp++;
while (romp->length)
{
void *f;
int expchecksum = romp->crc;
int explength = 0;
if (romp->name == 0)
{
printf("Error in RomModule definition: ROM_CONTINUE not preceded by ROM_LOAD\n");
goto getout;
}
else if (romp->name == (char *)-1)
{
printf("Error in RomModule definition: ROM_RELOAD not preceded by ROM_LOAD\n");
goto getout;
}
name = romp->name;
/* update status display */
if (osd_display_loading_rom_message(name,++current_rom,total_roms) != 0)
goto getout;
{
const struct GameDriver *drv;
drv = Machine->gamedrv;
do
{
f = osd_fopen(drv->name,name,OSD_FILETYPE_ROM,0);
drv = drv->clone_of;
} while (f == 0 && drv);
if (f == 0)
{
/* NS981003: support for "load by CRC" */
char crc[9];
sprintf(crc,"%08x",romp->crc);
drv = Machine->gamedrv;
do
{
f = osd_fopen(drv->name,crc,OSD_FILETYPE_ROM,0);
drv = drv->clone_of;
} while (f == 0 && drv);
}
}
if (f)
{
do
{
unsigned char *c;
unsigned int i;
int length = romp->length & ~ROMFLAG_MASK;
if (romp->name == (char *)-1)
osd_fseek(f,0,SEEK_SET); /* ROM_RELOAD */
else
explength += length;
if (romp->offset + length > region_size ||
(!(romp->length & ROMFLAG_NIBBLE) && (romp->length & ROMFLAG_ALTERNATE)
&& (romp->offset&~1) + 2*length > region_size))
{
printf("Error in RomModule definition: %s out of memory region space\n",name);
osd_fclose(f);
goto getout;
}
if (romp->length & ROMFLAG_NIBBLE)
{
unsigned char *temp;
temp = (unsigned char *) malloc(length);
if (!temp)
{
printf("Out of memory reading ROM %s\n",name);
osd_fclose(f);
goto getout;
}
if (osd_fread(f,temp,length) != length)
{
printf("Unable to read ROM %s\n",name);
}
/* ROM_LOAD_NIB_LOW and ROM_LOAD_NIB_HIGH */
c = Machine->memory_region[region] + romp->offset;
if (romp->length & ROMFLAG_ALTERNATE)
{
/* Load into the high nibble */
for (i = 0;i < length;i ++)
{
c[i] = (c[i] & 0x0f) | ((temp[i] & 0x0f) << 4);
}
}
else
{
/* Load into the low nibble */
for (i = 0;i < length;i ++)
{
c[i] = (c[i] & 0xf0) | (temp[i] & 0x0f);
}
}
free(temp);
}
else if (romp->length & ROMFLAG_ALTERNATE)
{
/* ROM_LOAD_EVEN and ROM_LOAD_ODD */
/* copy the ROM data */
#ifdef LSB_FIRST
c = Machine->memory_region[region] + (romp->offset ^ 1);
#else
c = Machine->memory_region[region] + romp->offset;
#endif
if (osd_fread_scatter(f,c,length,2) != length)
{
printf("Unable to read ROM %s\n",name);
}
}
else if (romp->length & ROMFLAG_QUAD) {
static int which_quad=0; /* This is multi session friendly, as we only care about the modulus */
unsigned char *temp;
int base=0;
temp = (unsigned char *) malloc(length); /* Need to load rom to temporary space */
osd_fread(f,temp,length);
/* Copy quad to region */
c = Machine->memory_region[region] + romp->offset;
#ifdef LSB_FIRST
switch (which_quad%4) {
case 0: base=1; break;
case 1: base=0; break;
case 2: base=3; break;
case 3: base=2; break;
}
#else
switch (which_quad%4) {
case 0: base=0; break;
case 1: base=1; break;
case 2: base=2; break;
case 3: base=3; break;
}
#endif
for (i=base; i< length*4; i += 4)
c[i]=temp[i/4];
which_quad++;
free(temp);
}
else
{
int wide = romp->length & ROMFLAG_WIDE;
#ifdef LSB_FIRST
int swap = (romp->length & ROMFLAG_SWAP) ^ ROMFLAG_SWAP;
#else
int swap = romp->length & ROMFLAG_SWAP;
#endif
osd_fread(f,Machine->memory_region[region] + romp->offset,length);
/* apply swappage */
c = Machine->memory_region[region] + romp->offset;
if (wide && swap)
{
for (i = 0; i < length; i += 2)
{
int temp = c[i];
c[i] = c[i+1];
c[i+1] = temp;
}
}
}
romp++;
} while (romp->length && (romp->name == 0 || romp->name == (char *)-1));
if (explength != osd_fsize (f))
{
sprintf (&buf[strlen(buf)], "%-12s WRONG LENGTH (expected: %08x found: %08x)\n",
name,explength,osd_fsize(f));
warning = 1;
}
if (expchecksum != osd_fcrc (f))
{
warning = 1;
if (expchecksum == 0)
sprintf(&buf[strlen(buf)],"%-12s NO GOOD DUMP KNOWN\n",name);
else if (expchecksum == BADCRC(osd_fcrc(f)))
sprintf(&buf[strlen(buf)],"%-12s ROM NEEDS REDUMP\n",name);
else
sprintf(&buf[strlen(buf)], "%-12s WRONG CRC (expected: %08x found: %08x)\n",
name,expchecksum,osd_fcrc(f));
}
osd_fclose(f);
}
else if (romp->length & ROMFLAG_OPTIONAL)
{
sprintf (&buf[strlen(buf)], "OPTIONAL %-12s NOT FOUND\n",name);
romp ++;
}
else
{
/* allow for a NO GOOD DUMP KNOWN rom to be missing */
if (expchecksum == 0)
{
sprintf (&buf[strlen(buf)], "%-12s NOT FOUND (NO GOOD DUMP KNOWN)\n",name);
warning = 1;
}
else
{
sprintf (&buf[strlen(buf)], "%-12s NOT FOUND\n",name);
fatalerror = 1;
}
do
{
if (fatalerror == 0)
{
int i;
/* fill space with random data */
if (romp->length & ROMFLAG_ALTERNATE)
{
unsigned char *c;
/* ROM_LOAD_EVEN and ROM_LOAD_ODD */
#ifdef LSB_FIRST
c = Machine->memory_region[region] + (romp->offset ^ 1);
#else
c = Machine->memory_region[region] + romp->offset;
#endif
for (i = 0;i < (romp->length & ~ROMFLAG_MASK);i++)
c[2*i] = rand();
}
else
{
for (i = 0;i < (romp->length & ~ROMFLAG_MASK);i++)
Machine->memory_region[region][romp->offset + i] = rand();
}
}
romp++;
} while (romp->length && (romp->name == 0 || romp->name == (char *)-1));
}
}
region++;
}
/* final status display */
osd_display_loading_rom_message(0,current_rom,total_roms);
if (warning || fatalerror)
{
extern int bailing;
if (fatalerror)
{
strcat (buf, "ERROR: required files are missing, the game cannot be run.\n");
bailing = 1;
}
else
strcat (buf, "WARNING: the game might not run correctly.\n");
printf ("%s", buf);
if (!options.gui_host && !bailing)
{
printf ("Press any key to continue\n");
keyboard_read_sync();
if (keyboard_pressed(KEYCODE_LCONTROL) && keyboard_pressed(KEYCODE_C))
return 1;
}
}
if (fatalerror) return 1;
else return 0;
getout:
/* final status display */
osd_display_loading_rom_message(0,current_rom,total_roms);
for (region = 0;region < MAX_MEMORY_REGIONS;region++)
{
free(Machine->memory_region[region]);
Machine->memory_region[region] = 0;
}
return 1;
}
int main (int argc, char **argv)
{
int res, i, j = 0, game_index;
char *playbackname = NULL;
char gamenameselection[32];
int use_cyclone=1;
int use_drz80_save=0;
int use_drz80_snd_save=1;
int use_drz80;
int use_drz80_snd;
extern int video_scale;
extern int video_border;
extern int video_aspect;
extern int throttle;
extern int soundcard;
int use_gui=0;
int first_run=1;
kiosk_mode=0;
{
char *abspath = (char*)malloc(PATH_MAX);
if (!abspath) {
logerror("Out of memory\n");
}
realpath(argv[0], abspath);
char *dirsep = strrchr(abspath, '/');
if( dirsep != 0 ) *dirsep = 0;
chdir(abspath);
free(abspath);
}
memset(&options,0,sizeof(options));
/* these two are not available in mame.cfg */
errorlog = 0;
game_index = -1;
soundcard=-1;
for (i = 1;i < argc;i++) /* V.V_121997 */
{
if (strcasecmp(argv[i],"-log") == 0)
errorlog = fopen("error.log","wa");
if (strcasecmp(argv[i],"-nocyclone") == 0)
use_cyclone=0;
if (strcasecmp(argv[i],"-drz80") == 0)
use_drz80_save=1;
if (strcasecmp(argv[i],"-nodrz80_snd") == 0)
use_drz80_snd_save=0;
if (strcasecmp(argv[i],"-scale") == 0)
video_scale=1;
if (strcasecmp(argv[i],"-border") == 0)
video_border=1;
if (strcasecmp(argv[i],"-aspect") == 0)
video_aspect=1;
if (strcasecmp(argv[i],"-nothrottle") == 0)
throttle=0;
if (strcasecmp(argv[i],"-nosound") == 0)
soundcard=0;
if (strcasecmp(argv[i],"-playback") == 0)
{
i++;
if (i < argc) /* point to inp file name */
playbackname = argv[i];
}
}
if (argc == 1)
use_gui=1;
/* check for frontend options */
if(!use_gui) {
res = frontend_help (argc, argv);
/* if frontend options were used, return to DOS with the error code */
if (res != 1234)
{
exit (res);
}
}
for (j = 1; j < argc; j++)
{
if (argv[j][0] != '-') {
strcpy(gamenameselection, argv[j]);
break;
}
}
if(init_SDL()==0) {
exit(1);
};
gui_loop:
if(use_gui) {
usleep(1000000/2);
gp2x_joystick_clear();
//Normally read in the game start but we need some vars
//setting for the frontend.
parse_cmdline (argc, argv, 1);
frontend_gui(gamenameselection, first_run);
first_run=0;
usleep(1000000/2);
//Clear input queue
gp2x_joystick_clear();
}
/* handle playback which is not available in mame.cfg */
init_inpdir(); /* Init input directory for opening .inp for playback */
if (playbackname != NULL)
options.playback = osd_fopen(playbackname,0,OSD_FILETYPE_INPUTLOG,0);
/* check for game name embedded in .inp header */
if (options.playback)
{
INP_HEADER inp_header;
/* read playback header */
osd_fread(options.playback, &inp_header, sizeof(INP_HEADER));
if (!isalnum(inp_header.name[0])) /* If first byte is not alpha-numeric */
osd_fseek(options.playback, 0, SEEK_SET); /* old .inp file - no header */
else
{
for (i = 0; (drivers[i] != 0); i++) /* find game and play it */
{
if (strcmp(drivers[i]->name, inp_header.name) == 0)
{
game_index = i;
printf("Playing back previously recorded game %s (%s) [press return]\n",
drivers[game_index]->name,drivers[game_index]->description);
getchar();
break;
}
}
}
}
/* If not playing back a new .inp file */
if (game_index == -1)
{
/* do we have a driver for this? */
{
for (i = 0; drivers[i] && (game_index == -1); i++)
{
if (strcasecmp(gamenameselection,drivers[i]->name) == 0)
{
game_index = i;
break;
}
}
}
if (game_index == -1)
{
printf("Game \"%s\" not supported\n", argv[j]);
return 1;
}
}
/* parse generic (os-independent) options */
parse_cmdline (argc, argv, game_index);
{ /* Mish: I need sample rate initialised _before_ rom loading for optional rom regions */
extern int soundcard;
if (soundcard == 0) { /* silence, this would be -1 if unknown in which case all roms are loaded */
Machine->sample_rate = 0; /* update the Machine structure to show that sound is disabled */
options.samplerate=0;
}
}
/* handle record which is not available in mame.cfg */
for (i = 1; i < argc; i++)
{
if (strcasecmp(argv[i],"-record") == 0)
{
i++;
if (i < argc)
options.record = osd_fopen(argv[i],0,OSD_FILETYPE_INPUTLOG,1);
}
}
if (options.record)
{
INP_HEADER inp_header;
memset(&inp_header, '\0', sizeof(INP_HEADER));
strcpy(inp_header.name, drivers[game_index]->name);
/* MAME32 stores the MAME version numbers at bytes 9 - 11
* MAME DOS keeps this information in a string, the
* Windows code defines them in the Makefile.
*/
/*
inp_header.version[0] = 0;
inp_header.version[1] = VERSION;
inp_header.version[2] = BETA_VERSION;
*/
osd_fwrite(options.record, &inp_header, sizeof(INP_HEADER));
}
/* Replace M68000 by CYCLONE */
if (use_cyclone)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_M68000 || ((*type)&0xff)==CPU_M68010 )
{
*type=((*type)&(~0xff))|CPU_CYCLONE;
}
}
}
use_drz80_snd = use_drz80_snd_save;
use_drz80 = use_drz80_save;
// Do not use the DrZ80 core for games that are listed as not compatible
// in the frontend list
for (i=0;i<NUMGAMES;i++)
{
if (strcmp(drivers[game_index]->name,fe_drivers[i].name)==0)
{
/* ASM cores: 0=None,1=Cyclone,2=DrZ80,3=Cyclone+DrZ80,4=DrZ80(snd),5=Cyclone+DrZ80(snd) */
if(fe_drivers[i].cores == 0 || fe_drivers[i].cores == 1)
{
use_drz80_snd=0;
use_drz80=0;
break;
}
}
}
#if (HAS_DRZ80)
/* Replace Z80 by DRZ80 */
if (use_drz80)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_Z80)
{
*type=((*type)&(~0xff))|CPU_DRZ80;
}
}
}
/* Replace Z80 with DRZ80 only for sound CPUs */
if (use_drz80_snd)
{
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if ((((*type)&0xff)==CPU_Z80) && ((*type)&CPU_AUDIO_CPU))
{
*type=((*type)&(~0xff))|CPU_DRZ80;
}
}
}
#endif
/*
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_V30)
{
*type=((*type)&(~0xff))|CPU_ARMV30;
}
}
for (i=0;i<MAX_CPU;i++)
{
int *type=(int*)&(drivers[game_index]->drv->cpu[i].cpu_type);
if (((*type)&0xff)==CPU_V33)
{
*type=((*type)&(~0xff))|CPU_ARMV33;
}
}
*/
// Remove the mouse usage for certain games
if ( (strcasecmp(drivers[game_index]->name,"hbarrel")==0) || (strcasecmp(drivers[game_index]->name,"hbarrelw")==0) ||
(strcasecmp(drivers[game_index]->name,"midres")==0) || (strcasecmp(drivers[game_index]->name,"midresu")==0) ||
(strcasecmp(drivers[game_index]->name,"midresj")==0) || (strcasecmp(drivers[game_index]->name,"tnk3")==0) ||
(strcasecmp(drivers[game_index]->name,"tnk3j")==0) || (strcasecmp(drivers[game_index]->name,"ikari")==0) ||
(strcasecmp(drivers[game_index]->name,"ikarijp")==0) || (strcasecmp(drivers[game_index]->name,"ikarijpb")==0) ||
(strcasecmp(drivers[game_index]->name,"victroad")==0) || (strcasecmp(drivers[game_index]->name,"dogosoke")==0) ||
(strcasecmp(drivers[game_index]->name,"gwar")==0) || (strcasecmp(drivers[game_index]->name,"gwarj")==0) ||
(strcasecmp(drivers[game_index]->name,"gwara")==0) || (strcasecmp(drivers[game_index]->name,"gwarb")==0) ||
(strcasecmp(drivers[game_index]->name,"bermudat")==0) || (strcasecmp(drivers[game_index]->name,"bermudaj")==0) ||
(strcasecmp(drivers[game_index]->name,"bermudaa")==0) || (strcasecmp(drivers[game_index]->name,"mplanets")==0) ||
(strcasecmp(drivers[game_index]->name,"forgottn")==0) || (strcasecmp(drivers[game_index]->name,"lostwrld")==0) ||
(strcasecmp(drivers[game_index]->name,"gondo")==0) || (strcasecmp(drivers[game_index]->name,"makyosen")==0) ||
(strcasecmp(drivers[game_index]->name,"topgunr")==0) || (strcasecmp(drivers[game_index]->name,"topgunbl")==0) ||
(strcasecmp(drivers[game_index]->name,"tron")==0) || (strcasecmp(drivers[game_index]->name,"tron2")==0) ||
(strcasecmp(drivers[game_index]->name,"kroozr")==0) ||(strcasecmp(drivers[game_index]->name,"crater")==0) ||
(strcasecmp(drivers[game_index]->name,"dotron")==0) || (strcasecmp(drivers[game_index]->name,"dotrone")==0) ||
(strcasecmp(drivers[game_index]->name,"zwackery")==0) || (strcasecmp(drivers[game_index]->name,"ikari3")==0) ||
(strcasecmp(drivers[game_index]->name,"searchar")==0) || (strcasecmp(drivers[game_index]->name,"sercharu")==0) ||
(strcasecmp(drivers[game_index]->name,"timesold")==0) || (strcasecmp(drivers[game_index]->name,"timesol1")==0) ||
(strcasecmp(drivers[game_index]->name,"btlfield")==0) || (strcasecmp(drivers[game_index]->name,"aztarac")==0))
{
extern int use_mouse;
use_mouse=0;
}
/* go for it */
printf ("%s (%s)...\n",drivers[game_index]->description,drivers[game_index]->name);
res = run_game (game_index);
/* close open files */
if (errorlog) fclose (errorlog);
if (options.playback) osd_fclose (options.playback);
if (options.record) osd_fclose (options.record);
if (options.language_file) osd_fclose (options.language_file);
gp2x_deinit();
game_index = -1;
if(use_gui) goto gui_loop;
deinit_SDL();
exit (res);
}
//-----------------------------------
// Constructor
//-----------------------------------
CSystem_IniFile::CSystem_IniFile( const CStdString &strFullPath ) :
m_dirtyFlag( FALSE )
{
if( strFullPath == "" )
return;
m_fileName = strFullPath;
std::vector< std::string > inputVector;
// Read the entire file into RAM, as reads/writes are unbuffered
osd_file *file = osd_fopen( FILETYPE_MAMEOX_FULLPATH, 0, m_fileName.c_str(), "r" );
if( !file )
return;
osd_fseek( file, 0, SEEK_END );
UINT32 fileSize = osd_ftell( file );
osd_fseek( file, 0, SEEK_SET );
char *buffer = new char[fileSize];
if( !buffer )
return;
osd_fread( file, buffer, fileSize );
osd_fclose( file );
// Break the file up into a vector of lines
UINT32 i = 0;
while( i < fileSize )
{
char buf[8192];
UINT32 j = 0;
for( ; buffer[i] != '\n' && buffer[i] != '\r' && j < 8192; ++i, ++j )
buf[j] = buffer[i];
// Skip paired \r\n's
while( buffer[i+1] == '\n' || buffer[i+1] == '\r' )
++i;
if( j == 8192 )
{
PRINTMSG(( T_ERROR, "Corrupt INI file, read 8k chars before finding a \\n!" ));
return;
}
else
buf[j] = 0;
// Catch no newline at end of file
if( buffer[i] == '\n' || buffer[i] == '\r' )
{
++i;
std::string inputStr = buf;
inputVector.push_back( CSystem_StringModifier::KillLeadingWhitespaceStr( inputStr ) );
}
else
break;
}
// The file data is no longer needed
delete[] buffer;
// Break each line up
std::vector<std::string>::iterator it = inputVector.begin();
for( ; it != inputVector.end(); ++it )
{
// Check to see if the current string is a new section
if( (*it)[0] == '[' )
{
std::string sectionHeader = (*it);
std::vector<std::string> temp;
for( ;(it+1) != inputVector.end() && (*(it+1))[0] != '['; ++it )
{
if( (*(it+1)).size() ) // Don't bother storing blank lines
temp.push_back( (*(it+1)) );
}
m_data[sectionHeader] = temp;
}
}
}