/* Return equals 0 to continue, -1 to stop, otherwise a number. */
int ListChoice(int hmm)
{
char buf[32];
if(!hmm)
{
int num=0;
tryagain:
CHEAT_printf(" <'Enter' to continue, (S)top, or #> ");
CHEAT_gets(buf,32);
if(buf[0]=='s' || buf[0]=='S') return(-1);
if(!buf[0]) return(0);
if(!trio_sscanf(buf,"%d",&num))
return(0);
if(num<1) goto tryagain;
return(num);
}
else
{
int num=0;
tryagain2:
CHEAT_printf(" <'Enter' to make no selection, or #> ");
CHEAT_gets(buf,32);
if(!buf[0]) return(0);
if(!trio_sscanf(buf,"%d",&num))
return(0);
if(num<1) goto tryagain2;
return(num);
}
}
static bool DecodePAR(const std::string& cheat_string, MemoryPatch* patch)
{
int boo[4];
if(cheat_string.size() != 8)
throw MDFN_Error(0, _("Pro Action Replay code is of an incorrect length."));
if(trio_sscanf(cheat_string.c_str(), "%02x%02x%02x%02x", boo, boo + 1, boo + 2, boo + 3) != 4)
throw MDFN_Error(0, _("Malformed Pro Action Replay code."));
if(boo[0])
{
patch->addr = (boo[3] << 8) | ((boo[2] + 0x7F) & 0xFF);
patch->val = boo[1];
patch->compare = 0;
patch->type = 'S';
}
else
{
patch->addr = ((boo[1] & 0x07) << 8) | (boo[2] << 0);
patch->val = boo[3];
patch->compare = 0;
patch->type = 'R';
}
patch->length = 1;
return(false);
}
static bool CC_server(const UTF8 *arg)
{
char server[300];
unsigned int port = 0;
server[0] = 0;
switch(trio_sscanf((char*)arg, "%.299s %u", server, &port))
{
default:
case 0:
break;
case 1:
MDFNI_SetSetting("netplay.host", (char*)server);
break;
case 2:
MDFNI_SetSetting("netplay.host", (char*)server);
MDFNI_SetSettingUI("netplay.port", port);
break;
}
MDFND_NetworkConnect();
return(false);
}
static void DoMenu(const std::vector<MENU>& men, bool topmost = 0)
{
bool MenuLoop = TRUE;
while(MenuLoop)
{
int x;
CHEAT_puts("");
for(x = 0; x < (int)men.size(); x++)
CHEAT_printf("%d) %s", x + 1, men[x].text.c_str());
CHEAT_puts("D) Display Menu");
if(!topmost)
CHEAT_puts("X) Return to Previous");
bool CommandLoop = TRUE;
while(CommandLoop)
{
char buf[32];
int c, c_numeral;
CHEAT_printf("Command> ");
CHEAT_gets(buf,32);
c = tolower(buf[0]);
if(c == 0)
continue;
else if(c == 'd')
{
CommandLoop = FALSE;
}
else if(c == 'x' && !topmost)
{
CommandLoop = FALSE;
MenuLoop = FALSE;
}
else if(trio_sscanf(buf, "%d", &c_numeral) == 1 && c_numeral <= x && c_numeral >= 1)
{
assert(!(men[c_numeral - 1].func_action && men[c_numeral - 1].menu_action));
if(men[c_numeral - 1].func_action)
men[c_numeral - 1].func_action(men[c_numeral - 1].data);
else if(men[c_numeral - 1].menu_action)
DoMenu(*men[c_numeral - 1].menu_action); /* Mmm...recursivey goodness. */
CommandLoop = FALSE;
}
else
{
CHEAT_puts("Invalid command.");
}
} // while(CommandLoop)
} // while(MenuLoop)
}
static void DoMenu(MENU *men, bool topmost = 0)
{
int x=0;
redisplay:
x=0;
CHEAT_puts("");
while(men[x].text)
{
CHEAT_printf("%d) %s",x+1,men[x].text);
x++;
}
CHEAT_puts("D) Display Menu");
if(!topmost)
CHEAT_puts("X) Return to Previous");
{
char buf[32];
int c;
recommand:
CHEAT_printf("Command> ");
CHEAT_gets(buf,32);
c=tolower(buf[0]);
if(c == 0)
goto recommand;
else if(c=='d')
goto redisplay;
else if(c=='x' && !topmost)
{
return;
}
else if(trio_sscanf(buf,"%d",&c))
{
if(c>x) goto invalid;
if(men[c-1].type)
{
void (*func)(void)=(void(*)())men[c-1].action;
func();
}
else
DoMenu((MENU*)men[c-1].action); /* Mmm...recursivey goodness. */
goto redisplay;
}
else
{
invalid:
CHEAT_puts("Invalid command.");
goto recommand;
}
}
}
static uint64 GetUI(uint64 def)
{
char buf[64];
memset(buf, 0, sizeof(buf));
CHEAT_gets(buf,64);
if(!buf[0])
return(def);
if(buf[0] == '$')
trio_sscanf(buf + 1, "%llx", &def); // $0FCE
else if(buf[0] == '0' && tolower(buf[1]) == 'x')
trio_sscanf(buf + 2, "%llx", &def); // 0x0FCE
else if(tolower(buf[strlen(buf) - 1]) == 'h') // 0FCEh
trio_sscanf(buf, "%llx", &def);
else
trio_sscanf(buf,"%lld", &def);
return def;
}
int64 PSFTags::GetTagI(const char *name)
{
std::map<std::string, std::string>::iterator it;
it = tags.find(name);
if(it != tags.end())
{
long long ret = 0;
std::string &tmp = tags[name];
trio_sscanf(tmp.c_str(), "%lld", &ret);
return(ret);
}
return(0); // INT64_MIN
}
int
benchmark (void)
{
trio_sscanf("123", "%d", &int_dest);
trio_sscanf("123 456", "%d %d", &int_dest, &int_dest);
trio_sscanf("000000123", "%d", &int_dest);
trio_sscanf("abcdefg", "%x", &int_dest);
trio_sscanf("FF", "%x",&int_dest);
trio_sscanf("abcdefg", "%[^f]%xg", char_dest, &int_dest);
return 0;
}
/* Rectangle, left, right(not inclusive), top, bottom(not inclusive). */
OpenGL_Blitter::OpenGL_Blitter(int scanlines, ShaderType pixshader, const int screen_w, const int screen_h, int *rs, int *gs, int *bs, int *as) : gl_screen_w(screen_w), gl_screen_h(screen_h)
{
try
{
const char *extensions;
const char *vendor;
const char *renderer;
const char *version;
uint32 version_h;
MaxTextureSize = 0;
SupportNPOT = false;
SupportARBSync = false;
PixelFormat = 0;
PixelType = 0;
for(unsigned i = 0; i < 4; i++)
textures[i] = 0;
rgb_mask = 0;
using_scanlines = 0;
last_w = 0;
last_h = 0;
OSDLastWidth = 0;
OSDLastHeight = 0;
shader = NULL;
DummyBlack = NULL;
DummyBlackSize = 0;
#define LFG(x) if(!(p_##x = (x##_Func) SDL_GL_GetProcAddress(#x))) { throw MDFN_Error(0, _("Error getting proc address for: %s\n"), #x); }
#define LFGN(x) p_##x = (x##_Func) SDL_GL_GetProcAddress(#x)
LFG(glGetError);
LFG(glBindTexture);
LFGN(glColorTableEXT);
LFG(glTexImage2D);
LFG(glBegin);
LFG(glVertex2f);
LFG(glTexCoord2f);
LFG(glEnd);
LFG(glEnable);
LFG(glBlendFunc);
LFG(glGetString);
LFG(glViewport);
LFG(glGenTextures);
LFG(glDeleteTextures);
LFG(glTexParameteri);
LFG(glClearColor);
LFG(glLoadIdentity);
LFG(glClear);
LFG(glMatrixMode);
LFG(glDisable);
LFG(glPixelStorei);
LFG(glTexSubImage2D);
LFG(glFinish);
LFG(glOrtho);
LFG(glPixelTransferf);
LFG(glColorMask);
LFG(glTexEnvf);
LFG(glGetIntegerv);
LFG(glTexGend);
LFG(glRasterPos2i);
LFG(glDrawPixels);
LFG(glPixelZoom);
LFG(glAccum);
LFG(glClearAccum);
LFG(glGetTexLevelParameteriv);
LFG(glPushMatrix);
LFG(glPopMatrix);
LFG(glRotated);
LFG(glScalef);
LFG(glReadPixels);
vendor = (const char *)p_glGetString(GL_VENDOR);
renderer = (const char *)p_glGetString(GL_RENDERER);
version = (const char *)p_glGetString(GL_VERSION);
{
int major = 0, minor = 0;
trio_sscanf(version, "%d.%d", &major, &minor);
if(minor < 0) minor = 0;
if(minor > 255) minor = 255;
version_h = (major << 8) | minor;
//printf("%08x\n", version_h);
}
MDFN_printf(_("OpenGL Implementation: %s %s %s\n"), vendor, renderer, version);
extensions = (const char*)p_glGetString(GL_EXTENSIONS);
MDFN_printf(_("Checking extensions:\n"));
MDFN_indent(1);
SupportNPOT = FALSE;
SupportARBSync = false;
if(CheckExtension(extensions, "GL_ARB_texture_non_power_of_two"))
{
MDFN_printf(_("GL_ARB_texture_non_power_of_two found.\n"));
SupportNPOT = TRUE;
}
if(CheckExtension(extensions, "GL_ARB_sync"))
{
MDFN_printf(_("GL_ARB_sync found.\n"));
LFG(glFenceSync);
LFG(glIsSync);
LFG(glDeleteSync);
LFG(glClientWaitSync);
LFG(glWaitSync);
LFG(glGetInteger64v);
LFG(glGetSynciv);
SupportARBSync = true;
}
MDFN_indent(-1);
// x,y specify LOWER left corner of the viewport.
p_glViewport(0, 0, gl_screen_w, gl_screen_h);
p_glGenTextures(4, &textures[0]);
p_glGenTextures(1, &rgb_mask);
using_scanlines = 0;
shader = NULL;
if(pixshader != SHADER_NONE)
{
LFG(glCreateShaderObjectARB);
LFG(glShaderSourceARB);
LFG(glCompileShaderARB);
LFG(glCreateProgramObjectARB);
LFG(glAttachObjectARB);
LFG(glLinkProgramARB);
LFG(glUseProgramObjectARB);
LFG(glUniform1fARB);
LFG(glUniform2fARB);
LFG(glUniform3fARB);
LFG(glUniform1iARB);
LFG(glUniform2iARB);
LFG(glUniform3iARB);
LFG(glUniformMatrix2fvARB);
LFG(glActiveTextureARB);
LFG(glGetInfoLogARB);
LFG(glGetUniformLocationARB);
LFG(glDeleteObjectARB);
LFG(glDetachObjectARB);
LFG(glGetObjectParameterivARB);
shader = new OpenGL_Blitter_Shader(this, pixshader);
SupportNPOT = 0; // Our pixel shaders don't work right with NPOT textures(for them to do so would probably necessitate rewriting them to use texelFetch)
p_glActiveTextureARB(GL_TEXTURE0_ARB);
}
// printf here because pixel shader code will set SupportNPOT to 0
if(SupportNPOT)
MDFN_printf(_("Using non-power-of-2 sized textures.\n"));
else
MDFN_printf(_("Using power-of-2 sized textures.\n"));
if(scanlines)
{
int slcount;
using_scanlines = scanlines;
p_glBindTexture(GL_TEXTURE_2D, textures[1]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
uint8 *buf=(uint8*)malloc(64 * (256 * 2) * 4);
slcount = 0;
for(int y=0;y<(256 * 2);y++)
{
for(int x=0;x<64;x++)
{
int sl_alpha;
if(slcount)
sl_alpha = 0xFF - (0xFF * abs(scanlines) / 100);
else
sl_alpha = 0xFF;
buf[y*64*4+x*4]=0;
buf[y*64*4+x*4+1]=0;
buf[y*64*4+x*4+2]=0;
buf[y*64*4+x*4+3] = sl_alpha;
//buf[y*256+x]=(y&1)?0x00:0xFF;
}
slcount ^= 1;
}
p_glPixelStorei(GL_UNPACK_ROW_LENGTH, 64);
p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 64, 256 * 2, 0, GL_RGBA,GL_UNSIGNED_BYTE,buf);
free(buf);
}
p_glBindTexture(GL_TEXTURE_2D, textures[3]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
p_glBindTexture(GL_TEXTURE_2D, textures[0]);
p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
//p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, 0x812F);
//p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, 0x812F);
p_glBindTexture(GL_TEXTURE_2D, textures[2]);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
p_glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
p_glEnable(GL_TEXTURE_2D);
p_glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Background color to black.
p_glMatrixMode(GL_MODELVIEW);
p_glLoadIdentity();
p_glFinish();
p_glDisable(GL_TEXTURE_1D);
p_glDisable(GL_FOG);
p_glDisable(GL_LIGHTING);
p_glDisable(GL_LOGIC_OP);
p_glDisable(GL_DITHER);
p_glDisable(GL_COLOR_MATERIAL);
p_glDisable(GL_NORMALIZE);
p_glDisable(GL_SCISSOR_TEST);
p_glDisable(GL_STENCIL_TEST);
p_glDisable(GL_ALPHA_TEST);
p_glDisable(GL_DEPTH_TEST);
p_glPixelTransferf(GL_RED_BIAS, 0);
p_glPixelTransferf(GL_GREEN_BIAS, 0);
p_glPixelTransferf(GL_BLUE_BIAS, 0);
p_glPixelTransferf(GL_ALPHA_BIAS, 0);
p_glPixelTransferf(GL_RED_SCALE, 1);
p_glPixelTransferf(GL_GREEN_SCALE, 1);
p_glPixelTransferf(GL_BLUE_SCALE, 1);
p_glPixelTransferf(GL_ALPHA_SCALE, 1);
p_glPixelTransferf(GL_MAP_COLOR, GL_FALSE);
p_glOrtho(0, gl_screen_w, gl_screen_h, 0, -1.0, 1.0);
last_w = 0;
last_h = 0;
OSDLastWidth = OSDLastHeight = 0;
MDFN_printf(_("Checking maximum texture size...\n"));
MDFN_indent(1);
p_glBindTexture(GL_TEXTURE_2D, textures[0]);
// Assume maximum texture width is the same as maximum texture height to greatly simplify things
MaxTextureSize = 32768;
while(MaxTextureSize)
{
GLint width_test = 0;
p_glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, MaxTextureSize, MaxTextureSize, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
p_glGetTexLevelParameteriv(GL_PROXY_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width_test);
if((unsigned int)width_test == MaxTextureSize)
break;
MaxTextureSize >>= 1;
}
MDFN_printf(_("Apparently it is at least: %d x %d\n"), MaxTextureSize, MaxTextureSize);
if(MaxTextureSize < 256)
{
MDFN_printf(_("Warning: Maximum texture size is reported as being less than 256, but we can't handle that.\n"));
MaxTextureSize = 256;
}
DummyBlack = NULL;
DummyBlackSize = 0;
MDFN_indent(-1);
if(!CheckAlternateFormat(version_h))
{
#ifdef LSB_FIRST
*rs = 0;
*gs = 8;
*bs = 16;
*as = 24;
#else
*rs = 24;
*gs = 16;
*bs = 8;
*as = 0;
#endif
PixelFormat = GL_RGBA;
PixelType = GL_UNSIGNED_BYTE;
MDFN_printf(_("Using GL_RGBA, GL_UNSIGNED_BYTE for texture source data.\n"));
}
else
{
*as = 24;
*rs = 16;
*gs = 8;
*bs = 0;
PixelFormat = GL_BGRA;
PixelType = GL_UNSIGNED_INT_8_8_8_8_REV;
MDFN_printf(_("Using GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV for texture source data.\n"));
}
}
catch(...)
{
Cleanup();
throw;
}
}
static void PCFXDBG_GetAddressSpaceBytes(const char *name, uint32 Address, uint32 Length, uint8 *Buffer)
{
int32 ws = 0;
if(!strcmp(name, "cpu"))
{
while(Length--)
{
Address &= 0xFFFFFFFF;
*Buffer = mem_rbyte(ws, Address);
Address++;
Buffer++;
}
}
else if(!strcmp(name, "ram"))
{
while(Length--)
{
Address &= 2048 * 1024 - 1;
*Buffer = RAM[Address];
Address++;
Buffer++;
}
}
else if(!strcmp(name, "backup"))
{
while(Length--)
{
Address &= 0x7FFF;
*Buffer = BackupRAM[Address];
Address++;
Buffer++;
}
}
else if(!strcmp(name, "exbackup"))
{
while(Length--)
{
Address &= 0x7FFF;
*Buffer = ExBackupRAM[Address];
Address++;
Buffer++;
}
}
else if(!strcmp(name, "bios"))
{
while(Length--)
{
Address &= 1024 * 1024 - 1;
*Buffer = BIOSROM[Address];
Address++;
Buffer++;
}
}
else if(!strncmp(name, "track", strlen("track")))
{
int disc = 0, track = 0, sector_base = 0;
trio_sscanf(name, "track%d-%d-%d", &disc, &track, §or_base);
while(Length--)
{
int32 sector = (Address / 2048) + sector_base;
int32 sector_offset = Address % 2048;
if((sector | (disc << 24)) != GAS_SectorCacheWhich)
{
if(!(*cdifs)[disc]->ReadSector(GAS_SectorCache, sector, 1))
memset(GAS_SectorCache, 0, 2048);
GAS_SectorCacheWhich = sector | (disc << 24);
}
*Buffer = GAS_SectorCache[sector_offset];
Address++;
Buffer++;
}
}
}
CDRFile *cdrfile_open(const char *path)
{
CDRFile *ret = (CDRFile *)calloc(1, sizeof(CDRFile));
struct stat stat_buf;
if(path == NULL || stat(path, &stat_buf) || !S_ISREG(stat_buf.st_mode))
{
CdIo *p_cdio;
char **devices;
char **parseit;
cdio_init();
GetFileBase("cdrom");
devices = cdio_get_devices(DRIVER_DEVICE);
parseit = devices;
if(parseit)
{
MDFN_printf(_("Connected physical devices:\n"));
MDFN_indent(1);
while(*parseit)
{
MDFN_printf("%s\n", *parseit);
parseit++;
}
MDFN_indent(-1);
}
if(!parseit || parseit == devices)
{
MDFN_PrintError(_("No CDROM drives detected(or no disc present)."));
if(devices)
cdio_free_device_list(devices);
free(ret);
return(NULL);
}
if(devices)
cdio_free_device_list(devices);
p_cdio = cdio_open_cd(path); //, DRIVER_UNKNOWN); //NULL, DRIVER_UNKNOWN);
if(!p_cdio)
{
free(ret);
return(NULL);
}
ret->p_cdio = p_cdio;
ret->FirstTrack = cdio_get_first_track_num(ret->p_cdio);
ret->NumTracks = cdio_get_num_tracks(ret->p_cdio);
ret->total_sectors = cdio_stat_size(ret->p_cdio);
if(ret->FirstTrack > 99)
{
MDFN_PrintError(_("Invalid first track: %d\n"), ret->FirstTrack);
free(ret);
cdio_destroy(p_cdio);
return(NULL);
}
if(ret->NumTracks > 100)
{
MDFN_PrintError(_("Invalid track count: %d\n"), ret->NumTracks);
free(ret);
cdio_destroy(p_cdio);
return(NULL);
}
for(track_t track = ret->FirstTrack; track < (ret->FirstTrack + ret->NumTracks); track++)
{
memset(&ret->Tracks[track], 0, sizeof(CDRFILE_TRACK_INFO));
ret->Tracks[track].sectors = cdio_get_track_sec_count(ret->p_cdio, track);
ret->Tracks[track].LSN = cdio_get_track_lsn(ret->p_cdio, track);
ret->Tracks[track].Format = cdio_get_track_format(ret->p_cdio, track);
}
return(ret);
}
FILE *fp = fopen(path, "rb");
bool IsTOC = FALSE;
// Assign opposite maximum values so our tests will work!
int FirstTrack = 99;
int LastTrack = 0;
if(!fp)
{
MDFN_PrintError(_("Error opening CUE sheet/TOC \"%s\": %m\n"), path, errno);
free(ret);
return(NULL);
}
GetFileBase(path);
char linebuf[512];
int32 active_track = -1;
int32 AutoTrackInc = 1; // For TOC
CDRFILE_TRACK_INFO TmpTrack;
memset(&TmpTrack, 0, sizeof(TmpTrack));
while(fgets(linebuf, 512, fp) > 0)
{
char cmdbuf[512], raw_args[512], args[4][512];
int argcount = 0;
raw_args[0] = 0;
cmdbuf[0] = 0;
args[0][0] = args[1][0] = args[2][0] = args[3][0] = 0;
if(!strncasecmp(linebuf, "CD_ROM", 6) || !strncasecmp(linebuf, "CD_DA", 5) || !strncasecmp(linebuf, "CD_ROM_XA", 9))
{
IsTOC = TRUE;
puts("TOC file detected.");
}
if(IsTOC)
{
char *ss_loc = strstr(linebuf, "//");
if(ss_loc)
{
ss_loc[0] = '\n'; // For consistency!
ss_loc[1] = 0;
}
}
trio_sscanf(linebuf, "%s %[^\r\n]", cmdbuf, raw_args);
if(!strcasecmp(cmdbuf, "CD_ROM") || !strcasecmp(cmdbuf, "CD_DA"))
IsTOC = TRUE;
UnQuotify(UnQuotify(UnQuotify(UnQuotify(raw_args, args[0]), args[1]), args[2]), args[3]);
if(args[0][0])
{
argcount++;
if(args[1][0])
{
argcount++;
if(args[2][0])
{
argcount++;
if(args[3][0])
{
argcount++;
}
}
}
}
if(IsTOC)
{
if(!strcasecmp(cmdbuf, "TRACK"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
memset(&TmpTrack, 0, sizeof(TmpTrack));
active_track = -1;
}
if(AutoTrackInc > 99)
{
MDFN_printf(_("Invalid track number: %d\n"), AutoTrackInc);
free(ret);
return(NULL);
}
active_track = AutoTrackInc++;
if(active_track < FirstTrack)
FirstTrack = active_track;
if(active_track > LastTrack)
LastTrack = active_track;
if(!strcasecmp(args[0], "AUDIO"))
{
TmpTrack.Format = TRACK_FORMAT_AUDIO;
TmpTrack.RawAudioMSBFirst = TRUE; // Silly cdrdao...
}
else if(!strcasecmp(args[0], "MODE1"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 0;
}
else if(!strcasecmp(args[0], "MODE1_RAW"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 1;
}
if(!strcasecmp(args[1], "RW"))
{
TmpTrack.SubchannelMode = CDRF_SUBM_RW;
MDFN_printf(_("\"RW\" format subchannel data not supported, only \"RW_RAW\" is!\n"));
free(ret);
return(0);
}
else if(!strcasecmp(args[1], "RW_RAW"))
TmpTrack.SubchannelMode = CDRF_SUBM_RW_RAW;
} // end to TRACK
else if(!strcasecmp(cmdbuf, "SILENCE"))
{
}
else if(!strcasecmp(cmdbuf, "ZERO"))
{
}
else if(!strcasecmp(cmdbuf, "FILE") || !strcasecmp(cmdbuf, "AUDIOFILE"))
{
const char *binoffset = NULL;
const char *msfoffset = NULL;
const char *length = NULL;
if(args[1][0] == '#')
{
binoffset = args[1] + 1;
msfoffset = args[2];
length = args[3];
}
else
{
msfoffset = args[1];
length = args[2];
}
//printf("%s, %s, %s, %s\n", args[0], binoffset, msfoffset, length);
if(!ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, msfoffset, length))
{
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "DATAFILE"))
{
const char *binoffset = NULL;
const char *length = NULL;
if(args[1][0] == '#')
{
binoffset = args[1] + 1;
length = args[2];
}
else
length = args[1];
if(!ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, NULL, length))
{
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "INDEX"))
{
}
else if(!strcasecmp(cmdbuf, "PREGAP"))
{
if(active_track < 0)
{
MDFN_printf(_("Command %s is outside of a TRACK definition!\n"), cmdbuf);
free(ret);
return(NULL);
}
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
} // end to PREGAP
else if(!strcasecmp(cmdbuf, "START"))
{
if(active_track < 0)
{
MDFN_printf(_("Command %s is outside of a TRACK definition!\n"), cmdbuf);
free(ret);
return(NULL);
}
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
}
} /*********** END TOC HANDLING ************/
else // now for CUE sheet handling
{
if(!strcasecmp(cmdbuf, "FILE"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
memset(&TmpTrack, 0, sizeof(TmpTrack));
active_track = -1;
}
std::string efn = MDFN_MakeFName(MDFNMKF_AUX, 0, args[0]);
if(NULL == (TmpTrack.fp = fopen(efn.c_str(), "rb")))
{
MDFN_printf(_("Could not open referenced file \"%s\": %m\n"), efn.c_str(), errno);
free(ret);
return(0);
}
TmpTrack.FirstFileInstance = 1;
if(!strcasecmp(args[1], "BINARY"))
{
//TmpTrack.Format = TRACK_FORMAT_DATA;
//struct stat stat_buf;
//fstat(fileno(TmpTrack.fp), &stat_buf);
//TmpTrack.sectors = stat_buf.st_size; // / 2048;
}
else if(!strcasecmp(args[1], "OGG") || !strcasecmp(args[1], "VORBIS") || !strcasecmp(args[1], "WAVE") || !strcasecmp(args[1], "WAV") || !strcasecmp(args[1], "PCM")
|| !strcasecmp(args[1], "MPC") || !strcasecmp(args[1], "MP+"))
{
TmpTrack.ovfile = (OggVorbis_File *) calloc(1, sizeof(OggVorbis_File));
if((TmpTrack.sf = sf_open_fd(fileno(TmpTrack.fp), SFM_READ, &TmpTrack.sfinfo, 0)))
{
free(TmpTrack.ovfile);
TmpTrack.ovfile = NULL;
}
else if(!lseek(fileno(TmpTrack.fp), 0, SEEK_SET) && !ov_open(TmpTrack.fp, TmpTrack.ovfile, NULL, 0))
{
//TmpTrack.Format = TRACK_FORMAT_AUDIO;
//TmpTrack.sectors = ov_pcm_total(&TmpTrack.ovfile, -1) / 588;
}
else
{
free(TmpTrack.ovfile);
TmpTrack.ovfile = NULL;
fseek(TmpTrack.fp, 0, SEEK_SET);
TmpTrack.MPCReaderFile = (mpc_reader_file *)calloc(1, sizeof(mpc_reader_file));
TmpTrack.MPCStreamInfo = (mpc_streaminfo *)calloc(1, sizeof(mpc_streaminfo));
TmpTrack.MPCDecoder = (mpc_decoder *)calloc(1, sizeof(mpc_decoder));
TmpTrack.MPCBuffer = (MPC_SAMPLE_FORMAT *)calloc(MPC_DECODER_BUFFER_LENGTH, sizeof(MPC_SAMPLE_FORMAT));
mpc_streaminfo_init(TmpTrack.MPCStreamInfo);
mpc_reader_setup_file_reader(TmpTrack.MPCReaderFile, TmpTrack.fp);
if(mpc_streaminfo_read(TmpTrack.MPCStreamInfo, &TmpTrack.MPCReaderFile->reader) != ERROR_CODE_OK)
{
MDFN_printf(_("Unsupported audio track file format: %s\n"), args[0]);
free(TmpTrack.MPCReaderFile);
free(TmpTrack.MPCStreamInfo);
free(TmpTrack.MPCDecoder);
free(TmpTrack.MPCBuffer);
free(ret);
return(0);
}
mpc_decoder_setup(TmpTrack.MPCDecoder, &TmpTrack.MPCReaderFile->reader);
if(!mpc_decoder_initialize(TmpTrack.MPCDecoder, TmpTrack.MPCStreamInfo))
{
MDFN_printf(_("Error initializing MusePack decoder: %s!\n"), args[0]);
free(TmpTrack.MPCReaderFile);
free(TmpTrack.MPCStreamInfo);
free(TmpTrack.MPCDecoder);
free(TmpTrack.MPCBuffer);
free(ret);
return(0);
}
}
}
else
{
MDFN_printf(_("Unsupported track format: %s\n"), args[1]);
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "TRACK"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
TmpTrack.FirstFileInstance = 0;
TmpTrack.pregap = 0;
}
active_track = atoi(args[0]);
if(active_track < FirstTrack)
FirstTrack = active_track;
if(active_track > LastTrack)
LastTrack = active_track;
if(!strcasecmp(args[1], "AUDIO"))
TmpTrack.Format = TRACK_FORMAT_AUDIO;
else if(!strcasecmp(args[1], "MODE1/2048"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 0;
}
else if(!strcasecmp(args[1], "MODE1/2352"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 1;
}
TmpTrack.sectors = GetSectorCount(&TmpTrack);
if(active_track < 0 || active_track > 99)
{
MDFN_printf(_("Invalid track number: %d\n"), active_track);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "INDEX"))
{
if(active_track >= 0 && (!strcasecmp(args[0], "01") || !strcasecmp(args[0], "1")))
{
int m,s,f;
trio_sscanf(args[1], "%d:%d:%d", &m, &s, &f);
TmpTrack.index = (m * 60 + s) * 75 + f;
}
}
else if(!strcasecmp(cmdbuf, "PREGAP"))
{
if(active_track >= 0)
{
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
}
}
} // end of CUE sheet handling
} // end of fgets() loop
if(ferror(fp))
{
if(IsTOC)
MDFN_printf(_("Error reading TOC file: %m\n"), errno);
else
MDFN_printf(_("Error reading CUE sheet: %m\n"), errno);
return(0);
}
if(active_track >= 0)
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
if(FirstTrack > LastTrack)
{
MDFN_printf(_("No tracks found!\n"));
return(0);
}
ret->FirstTrack = FirstTrack;
ret->NumTracks = 1 + LastTrack - FirstTrack;
lsn_t RunningLSN = 0;
lsn_t LastIndex = 0;
long FileOffset = 0;
for(int x = ret->FirstTrack; x < (ret->FirstTrack + ret->NumTracks); x++)
{
if(IsTOC)
{
RunningLSN += ret->Tracks[x].pregap;
ret->Tracks[x].LSN = RunningLSN;
RunningLSN += ret->Tracks[x].sectors;
}
else // else handle CUE sheet...
{
if(ret->Tracks[x].FirstFileInstance)
{
LastIndex = 0;
FileOffset = 0;
}
RunningLSN += ret->Tracks[x].pregap;
ret->Tracks[x].LSN = RunningLSN;
// Make sure this is set before the call to GetSectorCount() for the last track sector count fix.
ret->Tracks[x].FileOffset = FileOffset;
if((x + 1) >= (ret->FirstTrack + ret->NumTracks))
{
if(!(ret->Tracks[x].FirstFileInstance))
{
// This will fix the last sector count for CUE+BIN
ret->Tracks[x].sectors = GetSectorCount(&ret->Tracks[x]);
}
}
else if(ret->Tracks[x+1].FirstFileInstance)
{
//RunningLSN += ret->Tracks[x].sectors;
}
else
{
// Fix the sector count if we're CUE+BIN
ret->Tracks[x].sectors = ret->Tracks[x + 1].index - ret->Tracks[x].index;
}
//printf("Poo: %d %d\n", x, ret->Tracks[x].sectors);
RunningLSN += ret->Tracks[x].sectors;
//printf("%d, %ld %d %d %d %d\n", x, FileOffset, ret->Tracks[x].index, ret->Tracks[x].pregap, ret->Tracks[x].sectors, ret->Tracks[x].LSN);
if(ret->Tracks[x].Format == TRACK_FORMAT_AUDIO || TmpTrack.IsData2352)
FileOffset += ret->Tracks[x].sectors * 2352;
else
FileOffset += ret->Tracks[x].sectors * 2048;
} // end to cue sheet handling
} // end to track loop
LEC_Eval = MDFN_GetSettingB("cdrom.lec_eval");
if(LEC_Eval)
{
Init_LEC_Correct();
}
MDFN_printf(_("Raw rip data correction using L-EC: %s\n\n"), LEC_Eval ? _("Enabled") : _("Disabled"));
ret->total_sectors = RunningLSN; // Running LBA? Running LSN? arghafsdf...LSNBAN!#!$ -_-
return(ret);
}
static bool ParseTOCFileLineInfo(CDRFILE_TRACK_INFO *track, const int tracknum, const char *filename, const char *binoffset, const char *msfoffset, const char *length)
{
long offset = 0; // In bytes!
long tmp_long;
int m, s, f;
uint32 sector_mult;
long sectors;
std::string efn = MDFN_MakeFName(MDFNMKF_AUX, 0, filename);
if(NULL == (track->fp = fopen(efn.c_str(), "rb")))
{
MDFN_printf(_("Could not open referenced file \"%s\": %m\n"), efn.c_str(), errno);
return(0);
}
if(strlen(filename) >= 4 && !strcasecmp(filename + strlen(filename) - 4, ".wav"))
{
if((track->sf = sf_open_fd(fileno(track->fp), SFM_READ, &track->sfinfo, 0)))
{
}
}
if(track->Format == TRACK_FORMAT_AUDIO || track->IsData2352)
sector_mult = 2352;
else
sector_mult = 2048;
if(track->SubchannelMode)
sector_mult += 96;
if(binoffset && trio_sscanf(binoffset, "%ld", &tmp_long) == 1)
{
offset += tmp_long;
}
if(msfoffset && trio_sscanf(msfoffset, "%d:%d:%d", &m, &s, &f) == 3)
{
offset += ((m * 60 + s) * 75 + f) * sector_mult;
}
track->FileOffset = offset; // Make sure this is set before calling GetSectorCount()!
sectors = GetSectorCount(track);
//printf("Track: %d, offset: %ld, %ld\n", tracknum, offset, sectors);
if(length)
{
tmp_long = sectors;
if(trio_sscanf(length, "%d:%d:%d", &m, &s, &f) == 3)
tmp_long = (m * 60 + s) * 75 + f;
else if(track->Format == TRACK_FORMAT_AUDIO)
{
char *endptr = NULL;
tmp_long = strtol(length, &endptr, 10);
// Error?
if(endptr == length)
{
tmp_long = sectors;
}
else
tmp_long /= 588;
}
if(tmp_long > sectors)
{
MDFN_printf(_("Length specified in TOC file for track %d is too large by %d sectors!\n"), (int)tracknum, (int)(tmp_long - sectors));
return(FALSE);
}
sectors = tmp_long;
}
track->FirstFileInstance = 1;
track->sectors = sectors;
return(TRUE);
}
void MemDebuggerPrompt::TheEnd(const std::string &pstring)
{
if(error_string)
{
free(error_string);
error_string = NULL;
}
if(InPrompt == Goto || InPrompt == GotoDD)
{
unsigned long NewAddie;
if(trio_sscanf(pstring.c_str(), "%08lx", &NewAddie) == 1)
{
ASpacePos[CurASpace] = NewAddie;
LowNib = FALSE;
if(InPrompt == GotoDD)
GoGoPowerDD[CurASpace] = NewAddie;
}
}
else if(InPrompt == SetCharset)
{
if(ICV_Init(pstring.c_str()))
{
LockGameMutex(1);
MDFNI_SetSetting(std::string(std::string(CurGame->shortname) + "." + std::string("debugger.memcharenc")).c_str(), pstring.c_str());
LockGameMutex(0);
}
}
else if(InPrompt == DumpMem)
{
uint32 A1, A2, tmpsize;
char fname[256];
bool acceptable = FALSE;
if(trio_sscanf(pstring.c_str(), "%08x %08x %255[^\r\n]", &A1, &A2, fname) == 3)
acceptable = TRUE;
else if(trio_sscanf(pstring.c_str(), "%08x +%08x %255[^\r\n]", &A1, &tmpsize, fname) == 3)
{
acceptable = TRUE;
A2 = A1 + tmpsize - 1;
}
if(acceptable)
{
FILE *fp = fopen(fname, "wb");
if(fp)
{
uint8 write_buffer[256];
uint64 a = A1;
//printf("%08x %08x\n", A1, A2);
LockGameMutex(1);
while(a <= A2)
{
size_t to_write;
to_write = A2 - a + 1;
if(to_write > 256) to_write = 256;
ASpace->GetAddressSpaceBytes(ASpace->name, a, to_write, write_buffer);
if(fwrite(write_buffer, 1, to_write, fp) != to_write)
{
error_string = trio_aprintf("File write error: %m", errno);
error_time = SDL_GetTicks();
break;
}
a += to_write;
}
LockGameMutex(0);
fclose(fp);
}
else
{
error_string = trio_aprintf("File open error: %m", errno);
error_time = SDL_GetTicks();
}
}
}
else if(InPrompt == LoadMem)
{
uint32 A1, A2, tmpsize;
char fname[256];
bool acceptable = FALSE;
if(trio_sscanf(pstring.c_str(), "%08x %08x %255[^\r\n]", &A1, &A2, fname) == 3)
acceptable = TRUE;
else if(trio_sscanf(pstring.c_str(), "%08x +%08x %255[^\r\n]", &A1, &tmpsize, fname) == 3)
{
acceptable = TRUE;
A2 = A1 + tmpsize - 1;
}
if(acceptable)
{
FILE *fp = fopen(fname, "rb");
if(fp)
{
LockGameMutex(1);
uint8 read_buffer[256];
uint64 a = A1;
while(a <= A2)
{
size_t to_read;
size_t read_len;
to_read = A2 - a + 1;
if(to_read > 256) to_read = 256;
read_len = fread(read_buffer, 1, to_read, fp);
if(read_len > 0)
ASpace->PutAddressSpaceBytes(ASpace->name, a, read_len, 1, TRUE, read_buffer);
a += read_len;
if(read_len != to_read)
{
if(ferror(fp))
{
error_string = trio_aprintf("File read error: %m", errno);
error_time = SDL_GetTicks();
}
else if(feof(fp))
{
error_string = trio_aprintf("Warning: unexpected EOF(short by %08x byte(s))", A2 - a + 1);
error_time = SDL_GetTicks();
}
break;
}
}
LockGameMutex(0);
fclose(fp);
}
else
{
error_string = trio_aprintf("File open error: %m", errno);
error_time = SDL_GetTicks();
}
}
}
else if(InPrompt == TextSearch)
{
uint8 *thebytes;
uint32 bcount;
TS_String = pstring;
char *inbuf, *outbuf;
char *utf8_string;
size_t ibl, obl, obl_start;
size_t result;
utf8_string = strdup(pstring.c_str());
ibl = strlen(utf8_string);
obl_start = obl = (ibl + 1) * 8; // Hehe, ugly maximum estimation!
thebytes = (uint8 *)calloc(1, obl_start);
inbuf = utf8_string;
outbuf = (char*)thebytes;
result = iconv(ict, (ICONV_CONST char **)&inbuf, &ibl, &outbuf, &obl);
if(result == (size_t)-1)
{
error_string = trio_aprintf("iconv() error: %m", errno);
error_time = SDL_GetTicks();
InPrompt = None;
free(utf8_string);
free(thebytes);
return;
}
bcount = obl_start - obl;
free(utf8_string);
if(!DoBSSearch(bcount, thebytes))
{
error_string = trio_aprintf("String not found.");
error_time = SDL_GetTicks();
InPrompt = None;
}
free(thebytes);
}
else if(InPrompt == ByteStringSearch)
{
size_t byte_count;
uint8 *the_bytes;
BSS_String = pstring;
if(!(the_bytes = TextToBS(pstring.c_str(), &byte_count)))
return;
if(!DoBSSearch(byte_count, the_bytes))
{
free(the_bytes);
error_string = trio_aprintf("Bytestring \"%s\" not found.", pstring.c_str());
error_time = SDL_GetTicks();
InPrompt = None;
return;
}
free(the_bytes);
}
else if(InPrompt == RelSearch)
{
size_t byte_count;
uint8 *the_bytes;
RS_String = pstring;
if(!(the_bytes = TextToBS(pstring.c_str(), &byte_count)))
return;
if(!DoRSearch(byte_count, the_bytes))
{
free(the_bytes);
error_string = trio_aprintf("Bytestring \"%s\" not found.", pstring.c_str());
error_time = SDL_GetTicks();
InPrompt = None;
return;
}
free(the_bytes);
}
InPrompt = None;
}
