void S9xInitDisplay (int argc, char **argv)
{
if (allegro_init () < 0)
{
fprintf (stdout, "Unable to initialise Allegro library.\n");
S9xExit ();
}
extern int i_love_bill;
if (mode >= 9 || (mode < 0 && Settings.SixteenBit))
{
set_color_depth (16);
Settings.Transparency = TRUE;
Settings.SixteenBit = TRUE;
}
else
{
set_color_depth (8);
Settings.Transparency = FALSE;
Settings.SixteenBit = FALSE;
}
/*i_love_bill = FALSE;*/
off_screen = create_bitmap (IMAGE_WIDTH + 2, IMAGE_HEIGHT);
GFX.Screen = (uint8 *) off_screen->dat;
if (!GFX.Screen)
{
fprintf (stdout, "Cannot allocate screen buffer.\n");
S9xExit ();
}
GFX.Pitch = off_screen->w;
if (Settings.SixteenBit)
{
GFX.Pitch *= 2;
sub_screen = create_bitmap ((IMAGE_WIDTH + 2), IMAGE_HEIGHT);
Delta = new uint8 [(IMAGE_WIDTH + 2) * IMAGE_HEIGHT * 2];
if (!sub_screen || !Delta)
{
fprintf (stdout, "Cannot allocate screen buffer.\n");
S9xExit ();
}
GFX.SubScreen = (uint8 *) sub_screen->dat;
GFX.ZBuffer = (uint8 *) malloc (off_screen->w * IMAGE_HEIGHT);
GFX.SubZBuffer = (uint8 *) malloc (off_screen->w * IMAGE_HEIGHT);
}
else
{
GFX.SubScreen = GFX.Screen;
GFX.ZBuffer = (uint8 *) malloc (off_screen->w * IMAGE_HEIGHT);
GFX.SubZBuffer = NULL;
sub_screen = NULL;
Delta = NULL;
}
screen_pitch = off_screen->w;
}
void
S9xTerm (int signal)
{
S9xExit ();
return;
}
void
S9xHandlePortCommand (s9xcommand_t cmd, int16 data1, int16 data2)
{
static bool quit_binding_down = FALSE;
if (data1 == TRUE)
{
if (cmd.port[0] == PORT_QUIT)
quit_binding_down = TRUE;
}
if (data1 == FALSE) /* Release */
{
if (cmd.port[0] != PORT_QUIT)
{
quit_binding_down = FALSE;
}
if (cmd.port[0] == PORT_COMMAND_FULLSCREEN)
{
top_level->toggle_fullscreen_mode ();
}
else if (cmd.port[0] == PORT_COMMAND_SAVE_SPC)
{
top_level->save_spc_dialog ();
}
else if (cmd.port[0] == PORT_OPEN_ROM)
{
top_level->open_rom_dialog ();
}
else if (cmd.port[0] == PORT_PAUSE)
{
if (!(top_level->user_pause))
top_level->pause_from_user ();
else
top_level->unpause_from_user ();
}
else if (cmd.port[0] == PORT_SEEK_TO_FRAME)
{
top_level->movie_seek_dialog ();
}
else if (cmd.port[0] == PORT_SWAP_CONTROLLERS)
{
swap_controllers_1_2 ();
}
else if (cmd.port[0] == PORT_QUIT)
{
if (quit_binding_down)
S9xExit ();
}
}
return;
}
void S9xGraphicsMode ()
{
if (text_mode)
{
screen_width = modes [mode].width;
screen_height = modes [mode].height;
int ret = vga_setmode (modes [mode].mode);
if (ret < 0)
{
fprintf (stderr, "Unable to switch to requested screen mode/resolution:\n");
S9xExit ();
}
if (vga_setlinearaddressing () < 0)
{
if (info->flags & EXT_INFO_AVAILABLE)
video_page_size = info->aperture_size;
else
video_page_size = 64 * 1024;
}
else
video_page_size = ~0;
if (modes [mode].mode == G320x200x256 && screen_width == 256)
{
iopl(3);
outRegArray (scr256x256, sizeof (scr256x256) / sizeof (Register));
screen_pitch = screen_width;
}
gl_setcontextvga (modes [mode].mode);
if (keyboard_init ())
{
fprintf (stdout, "Keyboard initialisation failed.\n");
S9xExit ();
}
keyboard_seteventhandler(&_S9xSVGAKeyboardHandler);
text_mode = FALSE;
if (DeltaScreen)
memset (DeltaScreen, 0xff, GFX.Pitch * IMAGE_HEIGHT);
}
}
void
S9xXVDisplayDriver::update_image_size (int width, int height)
{
if (desired_width != width || desired_height != height)
{
XShmDetach (display, &shm);
XSync (display, 0);
shmctl (shm.shmid, IPC_RMID, 0);
shmdt (shm.shmaddr);
xv_image = XvShmCreateImage (display,
xv_portid,
format,
0,
width,
height,
&shm);
shm.shmid = shmget (IPC_PRIVATE, xv_image->data_size, IPC_CREAT | 0777);
for (int tries = 0; tries <= 10; tries++)
{
shm.shmaddr = (char *) shmat (shm.shmid, 0, 0);
if (shm.shmaddr == (void *) -1 && tries >= 10)
{
/* Can't recover, send exit. */
fprintf (stderr, "Couldn't reallocate shared memory.\n");
S9xExit ();
}
else if (shm.shmaddr != (void *) -1)
{
break;
}
}
shm.readOnly = FALSE;
xv_image->data = shm.shmaddr;
XShmAttach (display, &shm);
desired_width = width;
desired_height = height;
}
return;
}
void STOP(char* s)
{
char buffer[100];
#ifdef DEBUGGER
S9xAPUOPrint(buffer, IAPU.PC - IAPU.RAM);
#endif
sprintf(String, "Sound CPU in unknown state executing %s at %04lX\n%s\n", s, IAPU.PC - IAPU.RAM, buffer);
S9xMessage(S9X_ERROR, S9X_APU_STOPPED, String);
APU.TimerEnabled[0] = APU.TimerEnabled[1] = APU.TimerEnabled[2] = FALSE;
CPU.APU_APUExecuting = FALSE;
#ifdef DEBUGGER
CPU.Flags |= DEBUG_MODE_FLAG;
#else
S9xExit();
#endif
}
void S9xProcessEvents (bool8 block)
{
#ifdef USE_SDL
SDL_Event event;
bool8 quit_state = FALSE;
while ((block) || (SDL_PollEvent (&event) != 0))
{
switch (event.type) {
case SDL_KEYDOWN:
case SDL_KEYUP:
// domaemon: not sure it's the best idea, but reserving the SDLK_q for quit.
if (event.key.keysym.sym == SDLK_q)
{
quit_state = TRUE;
}
else
{
S9xReportButton(event.key.keysym.mod << 16 | // keyboard mod
event.key.keysym.sym, // keyboard ksym
event.type == SDL_KEYDOWN); // press or release
}
break;
case SDL_QUIT:
// domaemon: we come here when the window is getting closed.
quit_state = TRUE;
break;
}
}
if (quit_state == TRUE)
{
printf ("Quit Event. Bye.\n");
S9xExit();
}
#endif
}
void S9xInitDisplay (int argc, char **argv)
{
Screen *scrn;
XSetWindowAttributes xattr;
signal (SIGINT, quit);
signal (SIGTERM, quit);
if ((ourdisp = XOpenDisplay(NULL)) == NULL) {
printf ("Can't connect to X server!\n");
S9xExit ();
}
ourscreen = DefaultScreen (ourdisp);
scrn = DefaultScreenOfDisplay (ourdisp);
ourvideo.bitdepth = DefaultDepth (ourdisp, ourscreen);
ourvideo.screendepth = ourvideo.bitdepth / 8;
rootWindow = RootWindowOfScreen (scrn);
xattr.override_redirect = True;
inputwin = XCreateWindow (ourdisp, RootWindowOfScreen(scrn),
10, 10, 100, 100, 0, 0, InputOutput,
DefaultVisualOfScreen(scrn),
CWOverrideRedirect, &xattr);
XMapWindow (ourdisp, inputwin);
ourvideo.height = HeightOfScreen (scrn);
switch (ourvideo.bitdepth) {
case 8:
Settings.SixteenBit = FALSE;
Settings.Transparency = FALSE;
cmap = XCreateColormap (ourdisp, rootWindow,
DefaultVisualOfScreen (scrn),
AllocAll);
XSetWindowColormap (ourdisp, inputwin, cmap);
for (int i=0; i<256; i++) {
colors[i].pixel = i;
colors[i].flags = DoRed | DoGreen | DoBlue;
}
break;
case 16:
Settings.SixteenBit = TRUE;
if (!Settings.ForceNoTransparency)
Settings.Transparency = TRUE;
break;
case 24:
if (is32or24 == 32) {
ourvideo.bitdepth = 32;
ourvideo.screendepth = 4;
}
Settings.SixteenBit = TRUE;
if (!Settings.ForceNoTransparency)
Settings.Transparency = TRUE;
break;
default:
printf ("Color depth %d not supported!\n");
S9xExit ();
break;
}
printf ("Found %d bit display\n", ourvideo.bitdepth);
XFree(scrn);
XF86DGAGetVideo (ourdisp, ourscreen, &(ourvideo.vidMemBegin),
&(ourvideo.width), &(ourvideo.banksize),
&(ourvideo.memsize));
#ifdef USE_XF86VIDMODE
{
XF86VidModeModeInfo **all_modes;
int mode_count;
XF86VidModeModeLine mod_tmp;
int dotclock_tmp;
int x;
XF86VidModeGetModeLine (ourdisp, ourscreen, &dotclock_tmp, &mod_tmp);
orig_mode = ModeLine2ModeInfo (mod_tmp, dotclock_tmp);
if (orig_mode->hdisplay == 320 && orig_mode->vdisplay == 240) {
mod320x240 = orig_mode;
} else {
XF86VidModeGetAllModeLines (ourdisp,ourscreen, &mode_count,
&all_modes);
for (x = 0; x < mode_count; x++)
if (all_modes[x]->hdisplay == 320 &&
all_modes[x]->vdisplay == 240) {
mod320x240 = (XF86VidModeModeInfo *) malloc (
sizeof(XF86VidModeModeInfo));
*mod320x240 = *(all_modes[x]);
break;
} else
XFree (all_modes[x]->c_private);
if (mod320x240 == NULL) {
printf ("No 320x240 mode available!\n");
S9xExit ();
}
}
XFree(all_modes);
}
#endif
GFX.Pitch = IMAGE_WIDTH * (Settings.SixteenBit ? 2 : 1);
GFX.Screen = (uint8 *) malloc (IMAGE_HEIGHT * GFX.Pitch);
if (Settings.Transparency)
GFX.SubScreen = (uint8 *) malloc (IMAGE_HEIGHT * GFX.Pitch);
switch (ourvideo.bitdepth) {
case 8:
mWide = IMAGE_WIDTH / 4;
mHigh = IMAGE_HEIGHT;
mEtoE = (ourvideo.width - IMAGE_WIDTH) /4;
break;
case 16:
mWide = IMAGE_WIDTH / 2;
mHigh = IMAGE_HEIGHT;
mEtoE = (ourvideo.width - IMAGE_WIDTH) / 2;
break;
case 24:
mWide = IMAGE_WIDTH;
mHigh = IMAGE_HEIGHT;
mEtoE = (ourvideo.width - IMAGE_WIDTH) * 3;
break;
case 32:
mWide = IMAGE_WIDTH;
mHigh = IMAGE_HEIGHT;
mEtoE = (ourvideo.width - IMAGE_WIDTH) * 4;
default:
break;
}
ourvideo.scrnBegin = ourvideo.vidMemBegin + (320 - IMAGE_WIDTH) * ourvideo.screendepth / 2 + ourvideo.width * ourvideo.screendepth * 8;
}
void S9xHandlePortCommand (s9xcommand_t cmd, int16 data1, int16 data2)
{
static bool quit_binding_down = false;
if (data1 == true)
{
if (cmd.port[0] == PORT_QUIT)
quit_binding_down = true;
else if (cmd.port[0] == PORT_REWIND)
Settings.Rewinding = true;
}
if (data1 == false) /* Release */
{
if (cmd.port[0] != PORT_QUIT)
{
quit_binding_down = false;
}
if (cmd.port[0] == PORT_COMMAND_FULLSCREEN)
{
top_level->toggle_fullscreen_mode ();
}
else if (cmd.port[0] == PORT_COMMAND_SAVE_SPC)
{
top_level->save_spc_dialog ();
}
else if (cmd.port[0] == PORT_OPEN_ROM)
{
top_level->open_rom_dialog ();
}
else if (cmd.port[0] == PORT_PAUSE)
{
if (!(top_level->user_pause))
top_level->pause_from_user ();
else
top_level->unpause_from_user ();
}
else if (cmd.port[0] == PORT_REWIND)
{
Settings.Rewinding = false;
}
else if (cmd.port[0] == PORT_SEEK_TO_FRAME)
{
top_level->movie_seek_dialog ();
}
else if (cmd.port[0] == PORT_SWAP_CONTROLLERS)
{
swap_controllers_1_2 ();
}
else if (cmd.port[0] == PORT_QUIT)
{
if (quit_binding_down)
S9xExit ();
}
else if (cmd.port[0] >= PORT_QUICKLOAD0 && cmd.port[0] <= PORT_QUICKLOAD9)
{
S9xQuickLoadSlot (cmd.port[0] - PORT_QUICKLOAD0);
}
else if (cmd.port[0] == PORT_SAVESLOT)
{
S9xQuickSaveSlot (gui_config->current_save_slot);
}
else if (cmd.port[0] == PORT_LOADSLOT)
{
S9xQuickLoadSlot (gui_config->current_save_slot);
}
else if (cmd.port[0] == PORT_INCREMENTSAVESLOT)
{
change_slot (1);
S9xQuickSaveSlot (gui_config->current_save_slot);
}
else if (cmd.port[0] == PORT_DECREMENTLOADSLOT)
{
change_slot (-1);
S9xQuickLoadSlot (gui_config->current_save_slot);
}
else if (cmd.port[0] == PORT_INCREMENTSLOT)
{
change_slot (1);
}
else if (cmd.port[0] == PORT_DECREMENTSLOT)
{
change_slot (-1);
}
else if (cmd.port[0] == PORT_GRABMOUSE)
{
top_level->toggle_grab_mouse ();
}
}
}
void quit (int sig)
{
printf ("Received signal %d, quitting\n", sig);
S9xExit ();
}
void S9xInitDisplay (int /*argc*/, char ** /*argv*/)
{
#ifdef CAANOO
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK /*|(Settings.NextAPUEnabled ? SDL_INIT_AUDIO : 0)*/) < 0 )
#else
if (SDL_Init(SDL_INIT_VIDEO /*| (Settings.NextAPUEnabled ? SDL_INIT_AUDIO : 0)*/) < 0 )
#endif
{
printf("Could not initialize SDL(%s)\n", SDL_GetError());
S9xExit();
}
atexit(SDL_Quit);
// No more MOUSE-CURSOR
SDL_ShowCursor(SDL_DISABLE);
//screen = SDL_SetVideoMode(xs, ys, 16, SDL_HWSURFACE|SDL_DOUBLEBUF);
{
int i = 0; // 0 - 320x240, 1 - 400x240, 2 - 480x272
int surfacewidth, surfaceheight;
#define NUMOFVIDEOMODES 3
struct {
int x;
int y;
void (*p)(uint32_t *, uint32_t *, int);
} vm[NUMOFVIDEOMODES] = {
{320, 240, upscale_256x224_to_320x240},
{400, 240, upscale_256x224_to_384x240_for_400x240},
{480, 272, upscale_256x224_to_384x272_for_480x272}
};
// check 3 videomodes: 480x272, 400x240, 320x240
for(i = NUMOFVIDEOMODES-1; i >= 0; i--) {
if(SDL_VideoModeOK(vm[i].x, vm[i].y, 16, SDL_HWSURFACE|SDL_DOUBLEBUF) != 0) {
surfacewidth = vm[i].x;
surfaceheight = vm[i].y;
upscale_p = vm[i].p;
break;
}
}
screen = SDL_SetVideoMode(surfacewidth, surfaceheight, 16, SDL_HWSURFACE|SDL_DOUBLEBUF);
}
if (screen == NULL)
{
printf("Couldn't set video mode: %s\n", SDL_GetError());
S9xExit();
}
if (Settings.SupportHiRes)
{
gfxscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, 512, 480, 16, 0, 0, 0, 0);
GFX.Screen = (uint8 *)gfxscreen->pixels;
GFX.Pitch = 512 * 2;
}
else
{
gfxscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, 256, 240, 16, 0, 0, 0, 0);
GFX.Screen = (uint8 *)gfxscreen->pixels;
GFX.Pitch = 256 * 2;
}
GFX.SubScreen = (uint8 *)malloc(512 * 480 * 2);
GFX.ZBuffer = (uint8 *)malloc(512 * 480 * 2);
GFX.SubZBuffer = (uint8 *)malloc(512 * 480 * 2);
}
static void FatalError (const char *str)
{
fprintf(stderr, "%s\n", str);
S9xExit();
}
extern "C" int SIStartWithROM(char* rom_filename)
{
// notify that we're running
SI_EmulationIsRunning = 1;
// frameskip settings reset
SI_NextFrameTime = (timeval){0, 0};
SI_FrameTimeDebt = 0;
SI_SleptLastFrame = 0;
// ensure dirs exist
mode_t dir_mode = S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH;
mkdir(SI_SRAMPath, dir_mode);
// unix init
ZeroMemory(&Settings, sizeof(Settings));
Settings.MouseMaster = TRUE;
Settings.SuperScopeMaster = TRUE;
Settings.JustifierMaster = TRUE;
Settings.MultiPlayer5Master = TRUE;
Settings.FrameTimePAL = 20000;
Settings.FrameTimeNTSC = 16667;
Settings.SixteenBitSound = TRUE;
Settings.Stereo = TRUE;
//Settings.Stereo = FALSE;
Settings.SoundPlaybackRate = 32000;
//Settings.SoundPlaybackRate = 22050;
//Settings.SoundInputRate = 32000;
Settings.SoundInputRate = 32000;
Settings.SoundSync = FALSE;
Settings.SupportHiRes = TRUE;
Settings.Transparency = TRUE;
Settings.AutoDisplayMessages = TRUE;
Settings.InitialInfoStringTimeout = 120;
Settings.HDMATimingHack = 100;
Settings.BlockInvalidVRAMAccessMaster = TRUE;
Settings.StopEmulation = TRUE;
Settings.WrongMovieStateProtection = TRUE;
Settings.DumpStreamsMaxFrames = -1;
Settings.StretchScreenshots = 1;
Settings.SnapshotScreenshots = TRUE;
if(SI_AutoFrameskip)
Settings.SkipFrames = AUTO_FRAMERATE;
else
Settings.SkipFrames = SI_Frameskip;
//Settings.SkipFrames = 1;
Settings.TurboSkipFrames = 15;
Settings.CartAName[0] = 0;
Settings.CartBName[0] = 0;
#ifdef NETPLAY_SUPPORT
Settings.ServerName[0] = 0;
#endif
CPU.Flags = 0;
/*S9xLoadConfigFiles(argv, argc);
rom_filename = S9xParseArgs(argv, argc);
make_snes9x_dirs();*/
if (!Memory.Init() || !S9xInitAPU())
{
fprintf(stderr, "Snes9x: Memory allocation failure - not enough RAM/virtual memory available.\nExiting...\n");
Memory.Deinit();
S9xDeinitAPU();
exit(1);
}
int samplecount = Settings.SoundPlaybackRate/(Settings.PAL ? 50 : 60);
int soundBufferSize = samplecount<<(1+(Settings.Stereo?1:0));
S9xInitSound(soundBufferSize, 0);
S9xSetSoundMute(TRUE);
S9xReset();
S9xUnmapAllControls();
S9xSetController(0, CTL_JOYPAD, 0, 0, 0, 0);
//S9xSetController(1, CTL_JOYPAD, 1, 0, 0, 0);
s9xcommand_t cmd;
ASSIGN_BUTTONf(SIOS_X, "Joypad1 X");
ASSIGN_BUTTONf(SIOS_A, "Joypad1 A");
ASSIGN_BUTTONf(SIOS_B, "Joypad1 B");
ASSIGN_BUTTONf(SIOS_Y, "Joypad1 Y");
ASSIGN_BUTTONf(SIOS_L, "Joypad1 L");
ASSIGN_BUTTONf(SIOS_R, "Joypad1 R");
ASSIGN_BUTTONf(SIOS_SELECT, "Joypad1 Select");
ASSIGN_BUTTONf(SIOS_START, "Joypad1 Start");
ASSIGN_BUTTONf(SIOS_UP, "Joypad1 Up");
ASSIGN_BUTTONf(SIOS_DOWN, "Joypad1 Down");
ASSIGN_BUTTONf(SIOS_LEFT, "Joypad1 Left");
ASSIGN_BUTTONf(SIOS_RIGHT, "Joypad1 Right");
S9xReportControllers();
#ifdef GFX_MULTI_FORMAT
S9xSetRenderPixelFormat(RGB565);
#endif
uint32 saved_flags = CPU.Flags;
bool8 loaded = FALSE;
if (Settings.Multi)
{
loaded = Memory.LoadMultiCart(Settings.CartAName, Settings.CartBName);
if (!loaded)
{
char s1[PATH_MAX + 1], s2[PATH_MAX + 1];
char drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];
s1[0] = s2[0] = 0;
if (Settings.CartAName[0])
{
_splitpath(Settings.CartAName, drive, dir, fname, ext);
snprintf(s1, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s1) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s1, ".");
strcat(s1, ext);
}
}
if (Settings.CartBName[0])
{
_splitpath(Settings.CartBName, drive, dir, fname, ext);
snprintf(s2, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s2) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s2, ".");
strcat(s2, ext);
}
}
loaded = Memory.LoadMultiCart(s1, s2);
}
}
else
if (rom_filename)
{
char rom_path[1024] = {0};
sprintf(rom_path,"%s%s%s",SI_DocumentsPath,DIR_SEPERATOR,rom_filename);
loaded = Memory.LoadROM(rom_path);
/*if (!loaded && rom_filename[0])
{
char s[PATH_MAX + 1];
char drive[_MAX_DRIVE + 1], dir[_MAX_DIR + 1], fname[_MAX_FNAME + 1], ext[_MAX_EXT + 1];
_splitpath(rom_filename, drive, dir, fname, ext);
snprintf(s, PATH_MAX + 1, "%s%s%s", S9xGetDirectory(ROM_DIR), SLASH_STR, fname);
if (ext[0] && (strlen(s) <= PATH_MAX - 1 - strlen(ext)))
{
strcat(s, ".");
strcat(s, ext);
}
loaded = Memory.LoadROM(s);
}*/
}
if (!loaded)
{
fprintf(stderr, "Error opening the ROM file.\n");
exit(1);
}
//NSRTControllerSetup();
//Memory.LoadSRAM(S9xGetFilename(".srm", SRAM_DIR));
SILoadSRAM();
//S9xLoadCheatFile(S9xGetFilename(".cht", CHEAT_DIR));
CPU.Flags = saved_flags;
Settings.StopEmulation = FALSE;
#ifdef DEBUGGER
struct sigaction sa;
sa.sa_handler = sigbrkhandler;
#ifdef SA_RESTART
sa.sa_flags = SA_RESTART;
#else
sa.sa_flags = 0;
#endif
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
#endif
GFX.Pitch = SNES_WIDTH*2;
/*vrambuffer = (uint8*) malloc (GFX.Pitch * SNES_HEIGHT_EXTENDED*2);
memset (vrambuffer, 0, GFX.Pitch * SNES_HEIGHT_EXTENDED*2);
GFX.Screen = (uint16*)vrambuffer;*/
S9xGraphicsInit();
#ifdef NETPLAY_SUPPORT
if (strlen(Settings.ServerName) == 0)
{
char *server = getenv("S9XSERVER");
if (server)
{
strncpy(Settings.ServerName, server, 127);
Settings.ServerName[127] = 0;
}
}
char *port = getenv("S9XPORT");
if (Settings.Port >= 0 && port)
Settings.Port = atoi(port);
else
if (Settings.Port < 0)
Settings.Port = -Settings.Port;
if (Settings.NetPlay)
{
NetPlay.MaxFrameSkip = 10;
if (!S9xNPConnectToServer(Settings.ServerName, Settings.Port, Memory.ROMName))
{
fprintf(stderr, "Failed to connect to server %s on port %d.\n", Settings.ServerName, Settings.Port);
S9xExit();
}
fprintf(stderr, "Connected to server %s on port %d as player #%d playing %s.\n", Settings.ServerName, Settings.Port, NetPlay.Player, Memory.ROMName);
}
#endif
// HACK: disabling SMV
/*if (play_smv_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (S9xMovieOpen(play_smv_filename, TRUE) != SUCCESS)
exit(1);
CPU.Flags |= flags;
}
else
if (record_smv_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (S9xMovieCreate(record_smv_filename, 0xFF, MOVIE_OPT_FROM_RESET, NULL, 0) != SUCCESS)
exit(1);
CPU.Flags |= flags;
}
else
if (snapshot_filename)
{
uint32 flags = CPU.Flags & (DEBUG_MODE_FLAG | TRACE_FLAG);
if (!S9xUnfreezeGame(snapshot_filename))
exit(1);
CPU.Flags |= flags;
}*/
//S9xGraphicsMode();
sprintf(String, "\"%s\" %s: %s", Memory.ROMName, TITLE, VERSION);
//S9xSetTitle(String);
#ifdef JOYSTICK_SUPPORT
uint32 JoypadSkip = 0;
#endif
SILoadRunningStateForGameNamed(rom_filename);
SI_EmulationPaused = 0;
//if(SI_SoundOn)
SIDemuteSound(soundBufferSize);
S9xSetSoundMute(FALSE);
#ifdef NETPLAY_SUPPORT
bool8 NP_Activated = Settings.NetPlay;
#endif
while (1)
{
#ifdef NETPLAY_SUPPORT
if (NP_Activated)
{
if (NetPlay.PendingWait4Sync && !S9xNPWaitForHeartBeatDelay(100))
{
S9xProcessEvents(FALSE);
continue;
}
for (int J = 0; J < 8; J++)
old_joypads[J] = MovieGetJoypad(J);
for (int J = 0; J < 8; J++)
MovieSetJoypad(J, joypads[J]);
if (NetPlay.Connected)
{
if (NetPlay.PendingWait4Sync)
{
NetPlay.PendingWait4Sync = FALSE;
NetPlay.FrameCount++;
S9xNPStepJoypadHistory();
}
}
else
{
fprintf(stderr, "Lost connection to server.\n");
S9xExit();
}
}
#endif
#ifdef DEBUGGER
if (!Settings.Paused || (CPU.Flags & (DEBUG_MODE_FLAG | SINGLE_STEP_FLAG)))
#else
if (!Settings.Paused && !SI_EmulationPaused)
#endif
{
S9xMainLoop();
}
#ifdef NETPLAY_SUPPORT
if (NP_Activated)
{
for (int J = 0; J < 8; J++)
MovieSetJoypad(J, old_joypads[J]);
}
#endif
#ifdef DEBUGGER
if(Settings.Paused || (CPU.Flags & DEBUG_MODE_FLAG))
#else
if(Settings.Paused || SI_EmulationPaused)
#endif
S9xSetSoundMute(TRUE);
#ifdef DEBUGGER
if (CPU.Flags & DEBUG_MODE_FLAG)
S9xDoDebug();
else
#endif
if(Settings.Paused || SI_EmulationPaused || !SI_EmulationRun)
{
SISaveSRAM();
SISaveRunningStateForGameNamed(rom_filename);
SI_EmulationDidPause = 1;
do {
//S9xProcessEvents(FALSE);
if(!SI_EmulationRun)
break;
usleep(100000);
} while (SI_EmulationPaused);
if(!SI_EmulationRun)
{
SISaveSRAM();
SISaveRunningStateForGameNamed(rom_filename);
SIMuteSound();
S9xGraphicsDeinit();
Memory.Deinit();
S9xDeinitAPU();
break;
}
}
#ifdef JOYSTICK_SUPPORT
if (unixSettings.JoystickEnabled && (JoypadSkip++ & 1) == 0)
ReadJoysticks();
#endif
//S9xProcessEvents(FALSE);
#ifdef DEBUGGER
if(!Settings.Paused && !(CPU.Flags & DEBUG_MODE_FLAG))
#else
if(!Settings.Paused && !SI_EmulationPaused)
#endif
S9xSetSoundMute(FALSE);
}
SI_EmulationIsRunning = 0;
return (0);
}
void S9xInitDisplay (int /*argc*/, char ** /*argv*/)
{
if (vga_init() < 0)
{
fprintf (stdout, "Unable to initialise vga.\n");
S9xExit ();
}
S9xTextMode ();
if (mode < 0)
{
if (Settings.SixteenBit)
mode = 6;
else
mode = 2;
}
info = vga_getmodeinfo (modes [mode].mode);
if (info->flags & IS_MODEX)
planar = 1;
if (info->flags & CAPABLE_LINEAR)
video_page_size = ~0;
else
if (info->flags & EXT_INFO_AVAILABLE)
video_page_size = info->aperture_size;
else
video_page_size = 64 * 1024;
if (!screen_pitch)
screen_pitch = info->linewidth;
if (info->bytesperpixel > 1)
{
Settings.Transparency = TRUE;
Settings.SixteenBit = TRUE;
}
else
{
Settings.Transparency = FALSE;
Settings.SixteenBit = FALSE;
}
if (info->width >= 512 && info->height >= 578)
Settings.SupportHiRes = TRUE;
if (!Settings.SixteenBit || info->width < 512 || info->height < 240)
interpolation = FALSE;
if (interpolation)
{
GFX.Pitch = (IMAGE_WIDTH + 2) * 2;
GFX.Screen = (uint8 *) malloc (GFX.Pitch * IMAGE_HEIGHT);
GFX.SubScreen = (uint8 *) malloc (GFX.Pitch * IMAGE_HEIGHT);
DeltaScreen = (uint8 *) malloc (GFX.Pitch * IMAGE_HEIGHT);
GFX.ZBuffer = (uint8 *) malloc ((GFX.Pitch >> 1) * IMAGE_HEIGHT);
GFX.SubZBuffer = (uint8 *) malloc ((GFX.Pitch >> 1) * IMAGE_HEIGHT);
if (!GFX.Screen || !GFX.SubScreen || !DeltaScreen ||
!GFX.ZBuffer || !GFX.SubZBuffer)
{
fprintf (stdout, "Cannot allocate screen buffer.\n");
S9xExit ();
}
}
else
if (Settings.SixteenBit)
void S9xMainLoop (void)
{
for (;;)
{
#ifdef DEBUG_MAXCOUNT
CPU.GlobalLoopCount++;
if(Settings.MaxCount && CPU.GlobalLoopCount == Settings.MaxCount) {
fprintf(stderr, "Max loop count reached: %ld \n", Settings.MaxCount);
S9xExit();
}
#endif
APU_EXECUTE ();
if (CPU.Flags)
{
if (CPU.Flags & NMI_FLAG)
{
if (--CPU.NMICycleCount == 0)
{
CPU.Flags &= ~NMI_FLAG;
if (CPU.WaitingForInterrupt)
{
CPU.WaitingForInterrupt = FALSE;
CPU.PC++;
}
S9xOpcode_NMI ();
}
}
#ifdef DEBUGGER
if ((CPU.Flags & BREAK_FLAG) &&
!(CPU.Flags & SINGLE_STEP_FLAG))
{
for (int Break = 0; Break != 6; Break++)
{
if (S9xBreakpoint[Break].Enabled &&
S9xBreakpoint[Break].Bank == Registers.PB &&
S9xBreakpoint[Break].Address == CPU.PC - CPU.PCBase)
{
if (S9xBreakpoint[Break].Enabled == 2)
S9xBreakpoint[Break].Enabled = TRUE;
else
CPU.Flags |= DEBUG_MODE_FLAG;
}
}
}
#endif
CHECK_SOUND ();
if (CPU.Flags & IRQ_PENDING_FLAG)
{
if (CPU.IRQCycleCount == 0)
{
if (CPU.WaitingForInterrupt)
{
CPU.WaitingForInterrupt = FALSE;
CPU.PC++;
}
if (CPU.IRQActive && !Settings.DisableIRQ)
{
if (!CheckFlag (IRQ))
S9xOpcode_IRQ ();
}
else
CPU.Flags &= ~IRQ_PENDING_FLAG;
}
else
{
if(--CPU.IRQCycleCount==0 && CheckFlag (IRQ))
CPU.IRQCycleCount=1;
}
}
#ifdef DEBUGGER
if (CPU.Flags & DEBUG_MODE_FLAG)
break;
#endif
if (CPU.Flags & SCAN_KEYS_FLAG)
break;
#ifdef DEBUGGER
if (CPU.Flags & TRACE_FLAG)
S9xTrace ();
if (CPU.Flags & SINGLE_STEP_FLAG)
{
CPU.Flags &= ~SINGLE_STEP_FLAG;
CPU.Flags |= DEBUG_MODE_FLAG;
}
#endif
}
#ifdef CPU_SHUTDOWN
CPU.PCAtOpcodeStart = CPU.PC;
#endif
CPU.Cycles += CPU.MemSpeed;
(*ICPU.S9xOpcodes [*CPU.PC++].S9xOpcode) ();
S9xUpdateAPUTimer();
if (SA1.Executing)
S9xSA1MainLoop ();
DO_HBLANK_CHECK();
}
Registers.PC = CPU.PC - CPU.PCBase;
S9xPackStatus ();
APURegisters.PC = IAPU.PC - IAPU.RAM;
S9xAPUPackStatus ();
if (CPU.Flags & SCAN_KEYS_FLAG)
{
#ifdef DEBUGGER
if (!(CPU.Flags & FRAME_ADVANCE_FLAG))
#endif
S9xSyncSpeed ();
CPU.Flags &= ~SCAN_KEYS_FLAG;
}
#ifdef DETECT_NASTY_FX_INTERLEAVE
if (CPU.BRKTriggered && Settings.SuperFX && !CPU.TriedInterleavedMode2)
{
CPU.TriedInterleavedMode2 = TRUE;
CPU.BRKTriggered = FALSE;
S9xDeinterleaveMode2 ();
}
#endif
}
char* menu_romselector()
{
char *rom_filename = NULL;
int romcount = 0;
bool8_32 exit_loop = false;
uint8 *keyssnes = 0;
//Read ROM-Directory
romcount = FileDir("./roms", "sfc,smc");
Scale_org = Scale;
highres_current=Settings.SupportHiRes;
Scale = false;
Settings.SupportHiRes=FALSE;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
loadmenu_dispupdate(romcount);
sys_sleep(100000);
SDL_Event event;
do
{
loadmenu_dispupdate(romcount);
sys_sleep(100);
while(SDL_PollEvent(&event)==1)
{
//PANDORA & DINGOO & WIN32 -----------------------------------------------------
keyssnes = SDL_GetKeyState(NULL);
switch(event.type)
{
case SDL_KEYDOWN:
keyssnes = SDL_GetKeyState(NULL);
//UP
if(keyssnes[sfc_key[UP_1]] == SDL_PRESSED)
loadcursor--;
//DOWN
else if(keyssnes[sfc_key[DOWN_1]] == SDL_PRESSED)
loadcursor++;
// //LS
// else if(keyssnes[sfc_key[L_1]] == SDL_PRESSED)
// loadcursor=loadcursor-10;
// //RS
// else if(keyssnes[sfc_key[R_1]] == SDL_PRESSED)
// loadcursor=loadcursor+10;
//QUIT Emulator : press ESCAPE KEY
else if (keyssnes[sfc_key[SELECT_1]] == SDL_PRESSED)
S9xExit();
else if( (keyssnes[sfc_key[B_1]] == SDL_PRESSED) )
{
switch(loadcursor)
{
default:
if ((keyssnes[sfc_key[B_1]] == SDL_PRESSED))
{
if ((loadcursor>=0) && (loadcursor<(romcount)))
{
rom_filename=namelist[loadcursor]->d_name;
exit_loop = TRUE;
}
}
break;
}
}
break;
}
if(loadcursor==-1)
{
loadcursor=romcount-1;
}
else
if(loadcursor==romcount)
{
loadcursor=0;
}
break;
}
}
while( exit_loop!=TRUE && keyssnes[sfc_key[B_1]] != SDL_PRESSED );
// TODO:
///free(). namelist
Scale = Scale_org;
Settings.SupportHiRes=highres_current;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
return (rom_filename);
}
void VideoLogger(void *pixels, int width, int height, int depth)
{
int fc = S9xMovieGetFrameCounter();
if (fc > 0)
framecounter = fc;
else
framecounter++;
if (video)
{
// if (width != 256 || height != 224)
// {
// fprintf(stderr, "\nVideoLogger: Warning! width=%d, height=%d\n", width, height);
// breakpoint();
// }
// This stuff is only good for unix code, but since nitsuja broke unix, I might as well break windows
fwrite(pixels, 1024, 224, video);
fflush(video);
fflush(audio);
drift++;
if (maxframes > 0 && __builtin_expect(framecounter >= maxframes, 0))
{
printf("-maxframes hit\ndrift:%d\n",drift);
S9xExit();
}
}
if (Settings.DisplayPressedKeys || keypressscreen)
{
static char buffer[128];
sprintf(buffer, "%s %s %s %s %s %s %c%c%c%c%c%c",
IPPU.Joypads[0] & SNES_START_MASK ? "Start" : "_____",
IPPU.Joypads[0] & SNES_SELECT_MASK ? "Select" : "______",
IPPU.Joypads[0] & SNES_UP_MASK ? "Up" : "__",
IPPU.Joypads[0] & SNES_DOWN_MASK ? "Down" : "____",
IPPU.Joypads[0] & SNES_LEFT_MASK ? "Left" : "____",
IPPU.Joypads[0] & SNES_RIGHT_MASK ? "Right" : "_____",
IPPU.Joypads[0] & SNES_A_MASK ? 'A':'_',
IPPU.Joypads[0] & SNES_B_MASK ? 'B':'_',
IPPU.Joypads[0] & SNES_X_MASK ? 'X':'_',
IPPU.Joypads[0] & SNES_Y_MASK ? 'Y':'_',
IPPU.Joypads[0] & SNES_TL_MASK ? 'L':'_',
IPPU.Joypads[0] & SNES_TR_MASK ? 'R':'_'
/*framecounter*/);
if (Settings.DisplayPressedKeys)
fprintf(stderr, "%s %d \r", buffer, framecounter);
if (keypressscreen)
S9xSetInfoString(buffer);
}
if (__builtin_expect(messageframe >= 0 && framecounter == messageframe, 0))
{
S9xMessage(S9X_INFO, S9X_MOVIE_INFO, message);
GFX.InfoStringTimeout = 300;
messageframe = -1;
}
if (__builtin_expect(fastforwardpoint >= 0 && framecounter >= fastforwardpoint, 0))
{
// Settings.FramesToSkip = fastforwarddistance;
fastforwardpoint = -1;
}
}
void S9xProcessEvents (bool8 block)
{
static fd_set fds;
static struct timeval tv = { 0, 0 };
/*
if (joypads[0] & SNES_TL_MASK && joypads[0] & SNES_TR_MASK)
S9xExit();
*/
if (!is_graphics) {
while (True) {
char c;
if (read (0, &c, 1) >= 0)
if (c == '\n') {
S9xGraphicsMode ();
Settings.Paused ^= 1;
return;
}
}
}
while (block || XPending (ourdisp))
{
XEvent event;
XNextEvent (ourdisp, &event);
block = FALSE;
uint8 byte1 = 0;
uint8 byte2 = 0;
uint8 byte3 = 0;
uint8 byte4 = 0;
switch (event.type)
{
case KeyPress:
case KeyRelease:
{
int key;
switch (key = XKeycodeToKeysym (ourdisp, event.xkey.keycode, 0))
{
case XK_k:
case XK_Right: byte2 = 1; break;
case XK_h:
case XK_Left: byte2 = 2; break;
case XK_j:
case XK_n:
case XK_Down: byte2 = 4; break;
case XK_u:
case XK_Up: byte2 = 8; break;
case XK_Return: byte2 = 16; break; // Start
case XK_space: byte2 = 32; break; // Select
case XK_period:
case XK_t:
case XK_d: byte1 = 128; break; // A
case XK_slash:
case XK_y:
case XK_c: byte2 = 128; break; // B
case XK_m:
case XK_e:
case XK_s: byte1 = 64; break; // X
case XK_comma:
case XK_r:
case XK_x: byte2 = 64; break; // Y
case XK_v:
case XK_q:
case XK_a: byte1 = 32; break; // TL
case XK_b:
case XK_w:
case XK_z: byte1 = 16; break; // TR
case XK_KP_4: byte4 = 1; break;
case XK_KP_6: byte4 = 2; break;
case XK_KP_2: byte4 = 4; break;
case XK_KP_8: byte4 = 8; break;
case XK_KP_Enter: byte4 = 16; break; // Start
case XK_KP_Add: byte4 = 32; break; // Select
case XK_Prior: byte3 = 128; break; // A
case XK_Next: byte4 = 128; break; // B
case XK_Home: byte3 = 64; break; // X
case XK_End: byte4 = 64; break; // Y
case XK_Insert: byte3 = 32; break; // TL
case XK_Delete: byte3 = 16; break; // TR
case XK_Escape: S9xExit (); break;
case XK_0:
if (event.type == KeyPress)
Settings.DisableHDMA = !Settings.DisableHDMA;
break;
case XK_1:
if (event.type == KeyPress)
Settings.BG_Forced ^= 1;
break;
case XK_2:
if (event.type == KeyPress)
Settings.BG_Forced ^= 2;
break;
case XK_3:
if (event.type == KeyPress)
Settings.BG_Forced ^= 4;
break;
case XK_4:
if (event.type == KeyPress)
Settings.BG_Forced ^= 8;
break;
case XK_5:
if (event.type == KeyPress)
Settings.BG_Forced ^= 16;
break;
case XK_6:
if (event.type == KeyPress)
Settings.SwapJoypads = !Settings.SwapJoypads;
break;
case XK_9:
if (event.type == KeyPress)
if (Settings.SixteenBit)
Settings.Transparency = !Settings.Transparency;
break;
case XK_8:
if (event.type == KeyPress)
Settings.BGLayering = !Settings.BGLayering;
break;
case XK_7:
if (event.type == KeyPress)
S9xNextController ();
break;
case XK_minus:
if (event.type == KeyPress)
{
if (Settings.SkipFrames <= 1)
Settings.SkipFrames = AUTO_FRAMERATE;
else
if (Settings.SkipFrames != AUTO_FRAMERATE)
Settings.SkipFrames--;
}
break;
case XK_equal:
case XK_plus:
if (event.type == KeyPress)
{
if (Settings.SkipFrames == AUTO_FRAMERATE)
Settings.SkipFrames = 1;
else
if (Settings.SkipFrames < 10)
Settings.SkipFrames++;
}
break;
case XK_BackSpace:
if (event.type == KeyPress)
{
Settings.DisableGraphicWindows = !Settings.DisableGraphicWindows;
}
break;
case XK_Scroll_Lock:
case XK_Pause:
case XK_Break:
if (event.type == KeyPress) {
if (Settings.Paused)
S9xGraphicsMode ();
else
S9xTextMode ();
Settings.Paused ^= 1;
}
break;
/*
case XK_Tab:
if (event.type == KeyPress)
superscope_turbo = !superscope_turbo;
break;
case XK_grave:
superscope_pause = event.type == KeyPress;
break;
*/
case XK_F1:
#ifdef DEBUGGER
if (event.type == KeyPress && (event.xkey.state & Mod1Mask))
{
CPU.Flags |= DEBUG_MODE_FLAG;
break;
}
#endif
// Fall...
case XK_F2:
if (event.type == KeyPress && (event.xkey.state & Mod1Mask))
{
S9xLoadSnapshot (S9xChooseFilename (TRUE));
break;
}
// Fall...
case XK_F3:
if (event.type == KeyPress && (event.xkey.state & Mod1Mask))
{
Snapshot (S9xChooseFilename (FALSE));
break;
}
// Fall...
case XK_F4:
case XK_F5:
case XK_F6:
case XK_F7:
case XK_F8:
case XK_F9:
case XK_F10:
case XK_F11:
case XK_F12:
if (event.type == KeyPress)
{
if (!(event.xkey.state & (ShiftMask | Mod1Mask)))
{
if (key == XK_F11)
{
S9xLoadSnapshot (S9xChooseFilename (TRUE));
break;
}
else if (key == XK_F12)
{
Snapshot (S9xChooseFilename (FALSE));
break;
}
char def [PATH_MAX];
char filename [PATH_MAX];
char drive [_MAX_DRIVE];
char dir [_MAX_DIR];
char ext [_MAX_EXT];
_splitpath (Memory.ROMFilename, drive, dir, def, ext);
sprintf (filename, "%s%s%s.%03d",
S9xGetSnapshotDirectory (), SLASH_STR, def,
key - XK_F1);
S9xLoadSnapshot (filename);
}
else
if (event.xkey.state & Mod1Mask)
{
if (key >= XK_F4)
S9xToggleSoundChannel (key - XK_F4);
}
else
{
char def [PATH_MAX];
char filename [PATH_MAX];
char drive [_MAX_DRIVE];
char dir [_MAX_DIR];
char ext [_MAX_EXT];
_splitpath (Memory.ROMFilename, drive, dir, def, ext);
sprintf (filename, "%s%s%s.%03d",
S9xGetSnapshotDirectory (), SLASH_STR, def,
key - XK_F1);
Snapshot (filename);
}
}
break;
}
if (event.type == KeyPress)
{
joypads [0] |= byte1;
joypads [0] |= (byte2 << 8);
joypads [1] |= byte3;
joypads [1] |= (byte4 << 8);
}
else
{
joypads [0] &= ~byte1;
joypads [0] &= ~(byte2 << 8);
joypads [1] &= ~byte3;
joypads [1] &= ~(byte4 << 8);
}
break;
}
#if 0
case ButtonPress:
mouse_buttons = (event.xbutton.state | (1 << event.xbutton.button)) & 0x1f;
break;
case ButtonRelease:
mouse_buttons = (event.xbutton.state & ~(1 << event.xbutton.button)) & 0x1f;
break;
#endif
}
}
}
void S9xGraphicsMode ()
{
if (in_text_mode)
{
if (mode < 0)
{
if (Settings.SixteenBit)
{
if (Settings.SupportHiRes || interpolate)
mode = 10;
else
mode = 9;
}
else
{
if (Settings.SupportHiRes)
mode = 3;
else
mode = 2;
}
}
int ret;
do
{
screen_width = modes [mode].width;
screen_height = modes [mode].height;
set_color_depth (Settings.SixteenBit ? 16: 8);
if (modes [mode].mode == GFX_VGA)
ret = set_gfx_mode (modes [mode].mode, 320, 200, 0, 0);
else
ret = set_gfx_mode (modes [mode].mode, modes [mode].width,
modes [mode].height, 0, 0);
} while (ret < 0 && ++mode < COUNT(modes));
planar = modes [mode].mode == GFX_MODEX;
if (ret < 0)
{
fprintf (stderr, "Unable to switch to requested screen mode/resolution:\n%s\n",
allegro_error);
S9xExit ();
}
if (modes [mode].mode == GFX_VGA && screen_width == 256)
{
outRegArray (scr256x256, sizeof (scr256x256) / sizeof (Register));
screen->w = screen->cr = 256;
screen->h = screen->cb = 256;
for (int i = 1; i < 256; i++)
screen->line[i] = screen->line[i - 1] + 256;
}
clear_to_color (screen, 0);
if (install_keyboard ())
{
set_gfx_mode (GFX_TEXT, 0, 0, 0, 0);
fprintf (stdout, "Keyboard initialisation failed.\n");
S9xExit ();
}
if (!install_mouse ())
{
mouse_installed = TRUE;
set_mouse_range (0, 0, screen_width, screen_height);
position_mouse (screen_width / 2, screen_height / 2);
prev_mouse_x = mouse_x;
prev_mouse_y = mouse_y;
}
else
mouse_installed = FALSE;
in_text_mode = FALSE;
}
}
void menu_loop(void)
{
bool8_32 exit_loop = false;
char fname[256], ext[8];
char snapscreen_tmp[17120];
uint8 *keyssnes = 0;
SaveSlotNum_old = -1;
Scale_org = Scale;
highres_current=Settings.SupportHiRes;
capt_screenshot();
memcpy(snapscreen_tmp,snapscreen,17120);
Scale = false;
Settings.SupportHiRes=FALSE;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
menu_dispupdate();
sys_sleep(100000);
SDL_Event event;
do
{
while(SDL_PollEvent(&event)==1)
{
//PANDORA & DINGOO & WIN32 -----------------------------------------------------
keyssnes = SDL_GetKeyState(NULL);
if(keyssnes[sfc_key[UP_1]] == SDL_PRESSED)
cursor--;
else if(keyssnes[sfc_key[DOWN_1]] == SDL_PRESSED)
cursor++;
else if( (keyssnes[sfc_key[A_1]] == SDL_PRESSED) ||
(keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED) ||
(keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED) )
{
switch(cursor)
{
case 2: //exit snes9x
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
S9xExit();
break;
case 3: //reset snes9x
if ((keyssnes[sfc_key[A_1]] == SDL_PRESSED))
{
//make sure the sram is stored before resetting the console
//it should work without, but better safe than sorry...
Memory.SaveSRAM (S9xGetFilename (".srm"));
S9xReset();
exit_loop = TRUE;
}
break;
case 4:
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
ShowCredit();
break;
case 6: //save state
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
{
memcpy(snapscreen,snapscreen_tmp,16050);
show_screenshot();
strcpy(fname," Saving...");
S9xDisplayString (temp, GFX.Screen +320/*280*/, 640,80/*204*/);
S9xDeinitUpdate (320, 240);
sprintf(ext, ".s0%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
save_screenshot(fname);
sprintf(ext, ".00%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
S9xFreezeGame (fname);
sync();
exit_loop = TRUE;
}
break;
case 7: //load state
if (keyssnes[sfc_key[A_1]] == SDL_PRESSED)
{
sprintf(ext, ".00%d", SaveSlotNum);
strcpy(fname, S9xGetFilename (ext));
S9xLoadSnapshot (fname);
exit_loop = TRUE;
}
break;
case 8: //select save state slot
if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
{
if ( SaveSlotNum == 0 )
SaveSlotNum = MAX_SAVE_SLOTS-1; // slots start at 0, so 10 slots means slot 0 to 9
else
--SaveSlotNum;
}
else
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
{
if ( SaveSlotNum == MAX_SAVE_SLOTS-1 ) // slots start at 0, so 10 slots means slot 0 to 9
SaveSlotNum = 0;
else
++SaveSlotNum;
}
break;
case 10: // rotate through scalers
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
{
do
{
g_scale = (blit_scaler_e) ( ( g_scale + 1 ) % bs_max );
} while ( ( blit_scalers [ g_scale ].valid == bs_invalid )
|| ( highres_current && !(blit_scalers [ g_scale ].support_hires) ) );
} else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
{
do
{
g_scale = (blit_scaler_e) ( g_scale - 1 );
if (g_scale < 1) g_scale = (blit_scaler_e)(bs_max-1);
} while ( ( blit_scalers [ g_scale ].valid == bs_invalid )
|| ( highres_current && !(blit_scalers [ g_scale ].support_hires) ) );
}
// now force update the display, so that the new scaler is directly used (fixes some glitches)
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 11: // set frameskip
if (Settings.SkipFrames == AUTO_FRAMERATE)
Settings.SkipFrames = 10;
if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED)
Settings.SkipFrames--;
else
Settings.SkipFrames++;
if(Settings.SkipFrames<=0 || Settings.SkipFrames==10)
Settings.SkipFrames = AUTO_FRAMERATE;
else if (Settings.SkipFrames>=11)
Settings.SkipFrames = 1;
break;
case 12: // set vsync
if (g_vsync)
g_vsync = 0;
else
g_vsync = 1;
break;
case 13: // set display fps
Settings.DisplayFrameRate = !Settings.DisplayFrameRate;
break;
case 14: // set transparency
Settings.Transparency = !Settings.Transparency;
break;
case 15: // cut lines from top
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_top++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_top>0)
cut_top--;
// now force update the display, so that the new scaler is directly used (fixes some glitches)
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 16: // cut lines from bottom
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_bottom++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_bottom>0)
cut_bottom--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 17: // cut from the left
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_left++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_left>0)
cut_left--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 18: // cut from the right
if (keyssnes[sfc_key[RIGHT_1]] == SDL_PRESSED)
cut_right++;
else if (keyssnes[sfc_key[LEFT_1]] == SDL_PRESSED && cut_right>0)
cut_right--;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
break;
case 20:
//offer an option to change to alternative sample decoding
//cf. http://www.gp32x.com/board/index.php?/topic/55378-snes9x4d4p-another-new-build-now-with-hi-res-and-new-rom-picker/page__view__findpost__p__958860
if (Settings.AltSampleDecode)
Settings.AltSampleDecode = 0;
else
Settings.AltSampleDecode = 1;
break;
}
}
if(cursor==1)
cursor=20;
else if(cursor==21)
cursor=2;
if(cursor==5 || cursor==9 || cursor==19) {
if(keyssnes[sfc_key[UP_1]] == SDL_PRESSED)
cursor--;
else if(keyssnes[sfc_key[DOWN_1]] == SDL_PRESSED)
cursor++;
}
menu_dispupdate();
sys_sleep(1000);
break;
}
}
while( exit_loop!=TRUE && keyssnes[sfc_key[B_1]] != SDL_PRESSED );
Scale = Scale_org;
Settings.SupportHiRes=highres_current;
S9xDeinitDisplay();
S9xInitDisplay(0, 0);
}
void quit (int sig)
{
S9xTracef( "Print f: Received signal %d, quitting\n", sig);
S9xExit ();
}
void VideoLogger(void *pixels, int width, int height, int depth, int bytes_per_line)
{
int fc = S9xMovieGetFrameCounter();
if (fc > 0)
framecounter = fc;
else
framecounter++;
if (video)
{
int i;
char *data = (char*)pixels;
static int lastwidth = width; // first resolution
static int lastheight = height;
if (lastwidth != width || lastheight != height) // this is just for informing the encoder that something has changed
{
printf("Frame %d, resolution changed from %dx%d to %dx%d!\n", fc, lastwidth, lastheight, width, height);
lastwidth = width;
lastheight = height;
}
for (i=0; i < height; i++)
fwrite(data + i*bytes_per_line, depth, width, video);
fflush(video);
fflush(audio);
drift++;
if (maxframes > 0 && __builtin_expect((unsigned)framecounter >= maxframes, 0))
{
printf("-maxframes hit\ndrift:%d\n",drift);
S9xExit();
}
}
if (Settings.DisplayPressedKeys==1 || keypressscreen)
{
uint16 MovieGetJoypad(int i);
int buttons = MovieGetJoypad(0);
static char buffer[128];
// This string spacing pattern is optimized for the 256 pixel wide screen.
sprintf(buffer, "%s %s %s %s %s %s %c%c%c%c%c%c",
buttons & SNES_START_MASK ? "Start" : "_____",
buttons & SNES_SELECT_MASK ? "Select" : "______",
buttons & SNES_UP_MASK ? "Up" : "__",
buttons & SNES_DOWN_MASK ? "Down" : "____",
buttons & SNES_LEFT_MASK ? "Left" : "____",
buttons & SNES_RIGHT_MASK ? "Right" : "_____",
buttons & SNES_A_MASK ? 'A':'_',
buttons & SNES_B_MASK ? 'B':'_',
buttons & SNES_X_MASK ? 'X':'_',
buttons & SNES_Y_MASK ? 'Y':'_',
buttons & SNES_TL_MASK ? 'L':'_',
buttons & SNES_TR_MASK ? 'R':'_'
/*framecounter*/);
if (Settings.DisplayPressedKeys==1)
fprintf(stderr, "%s %d \r", buffer, framecounter);
//if (keypressscreen)
S9xSetInfoString(buffer);
}
if (__builtin_expect(messageframe >= 0 && framecounter == messageframe, 0))
{
S9xMessage(S9X_INFO, S9X_MOVIE_INFO, message);
GFX.InfoStringTimeout = 300;
messageframe = -1;
}
/* if (__builtin_expect(fastforwardpoint >= 0 && framecounter >= fastforwardpoint, 0))
{
Settings.FramesToSkip = fastforwarddistance;
fastforwardpoint = -1;
}*/
}
void S9xProcessEvents (bool8 block)
{
static char prev_keystate[128];
extern volatile char key[128];
#ifdef GRIP_SUPPORT
ReadGrip ();
#endif
#ifdef SIDEWINDER_SUPPORT
if (num_sidewinders)
ReadSidewinders ();
#endif
char key1[128];
char *keystate = (char *) key1;
int fn = 0;
memcpy (key1, (char *) key, sizeof (key1));
#undef KEY_DOWN
#define KEY_DOWN(a) (keystate[a])
#undef KEY_PRESS
#define KEY_PRESS(a) (keystate[a] && !prev_keystate[a])
#undef KEY_WASPRESSED
#define KEY_WASPRESSED(a) (prev_keystate[a] && !keystate[a])
#undef PROCESS_KEY
#define PROCESS_KEY(k, b, v)\
if (KEY_PRESS(k)) b |= v;\
if (KEY_WASPRESSED(k)) b &= ~v;
if (KEY_PRESS (SCANCODE_ESCAPE))
S9xExit ();
// Joypad 1:
PROCESS_KEY(SCANCODE_K, joypads [0], SNES_RIGHT_MASK)
PROCESS_KEY(SCANCODE_CURSORRIGHT, joypads [0], SNES_RIGHT_MASK)
PROCESS_KEY(SCANCODE_H, joypads [0], SNES_LEFT_MASK)
PROCESS_KEY(SCANCODE_CURSORLEFT, joypads [0], SNES_LEFT_MASK)
PROCESS_KEY(SCANCODE_N, joypads [0], SNES_DOWN_MASK)
PROCESS_KEY(SCANCODE_J, joypads [0], SNES_DOWN_MASK)
PROCESS_KEY(SCANCODE_CURSORDOWN, joypads [0], SNES_DOWN_MASK)
PROCESS_KEY(SCANCODE_U, joypads [0], SNES_UP_MASK)
PROCESS_KEY(SCANCODE_CURSORUP, joypads [0], SNES_UP_MASK)
PROCESS_KEY(SCANCODE_ENTER, joypads [0], SNES_START_MASK)
PROCESS_KEY(SCANCODE_SPACE, joypads [0], SNES_SELECT_MASK)
PROCESS_KEY(SCANCODE_A, joypads [0], SNES_TL_MASK)
PROCESS_KEY(SCANCODE_V, joypads [0], SNES_TL_MASK)
PROCESS_KEY(SCANCODE_Q, joypads [0], SNES_TL_MASK)
PROCESS_KEY(SCANCODE_Z, joypads [0], SNES_TR_MASK)
PROCESS_KEY(SCANCODE_B, joypads [0], SNES_TR_MASK)
PROCESS_KEY(SCANCODE_W, joypads [0], SNES_TR_MASK)
PROCESS_KEY(SCANCODE_S, joypads [0], SNES_X_MASK)
PROCESS_KEY(SCANCODE_M, joypads [0], SNES_X_MASK)
PROCESS_KEY(SCANCODE_E, joypads [0], SNES_X_MASK)
PROCESS_KEY(SCANCODE_X, joypads [0], SNES_Y_MASK)
PROCESS_KEY(SCANCODE_COMMA, joypads [0], SNES_Y_MASK)
PROCESS_KEY(SCANCODE_R, joypads [0], SNES_Y_MASK)
PROCESS_KEY(SCANCODE_D, joypads [0], SNES_A_MASK)
PROCESS_KEY(SCANCODE_PERIOD, joypads [0], SNES_A_MASK)
PROCESS_KEY(SCANCODE_T, joypads [0], SNES_A_MASK)
PROCESS_KEY(SCANCODE_C, joypads [0], SNES_B_MASK)
PROCESS_KEY(SCANCODE_SLASH, joypads [0], SNES_B_MASK)
PROCESS_KEY(SCANCODE_Y, joypads [0], SNES_B_MASK)
// Joypad 2:
// PROCESS_KEY(SCANCODE_CURSORRIGHT, joypads [1], SNES_RIGHT_MASK)
// PROCESS_KEY(SCANCODE_CURSORLEFT, joypads [1], SNES_LEFT_MASK)
// PROCESS_KEY(SCANCODE_CURSORDOWN, joypads [1], SNES_DOWN_MASK)
// PROCESS_KEY(SCANCODE_CURSORUP, joypads [1], SNES_UP_MASK)
PROCESS_KEY(SCANCODE_KEYPADENTER, joypads [0], SNES_START_MASK)
PROCESS_KEY(SCANCODE_KEYPADPLUS, joypads [0], SNES_SELECT_MASK)
PROCESS_KEY(SCANCODE_INSERT, joypads [0], SNES_X_MASK)
PROCESS_KEY(SCANCODE_REMOVE, joypads [0], SNES_Y_MASK)
PROCESS_KEY(SCANCODE_HOME, joypads [0], SNES_A_MASK)
PROCESS_KEY(SCANCODE_END, joypads [0], SNES_B_MASK)
PROCESS_KEY(SCANCODE_PAGEUP, joypads [0], SNES_TL_MASK)
PROCESS_KEY(SCANCODE_PAGEDOWN, joypads [0], SNES_TR_MASK)
if (KEY_PRESS (SCANCODE_0))
Settings.DisableHDMA = !Settings.DisableHDMA;
if (KEY_PRESS (SCANCODE_1))
PPU.BG_Forced ^= 1;
if (KEY_PRESS (SCANCODE_2))
PPU.BG_Forced ^= 2;
if (KEY_PRESS (SCANCODE_3))
PPU.BG_Forced ^= 4;
if (KEY_PRESS (SCANCODE_4))
PPU.BG_Forced ^= 8;
if (KEY_PRESS (SCANCODE_5))
PPU.BG_Forced ^= 16;
if (KEY_PRESS (SCANCODE_6))
Settings.SwapJoypads = !Settings.SwapJoypads;
if (KEY_PRESS (SCANCODE_7))
{
if (IPPU.Controller == SNES_SUPERSCOPE)
show_mouse (NULL);
S9xNextController ();
if (IPPU.Controller == SNES_SUPERSCOPE)
show_mouse (screen);
}
if (KEY_PRESS (SCANCODE_8))
Settings.BGLayering = !Settings.BGLayering;
if (KEY_PRESS (SCANCODE_9))
if (Settings.SixteenBit)
Settings.Transparency = !Settings.Transparency;
if (KEY_PRESS(SCANCODE_TAB))
superscope_turbo = !superscope_turbo;
PROCESS_KEY(SCANCODE_GRAVE, superscope_pause, 1);
if (KEY_PRESS(SCANCODE_F1))
fn = 1;
if (KEY_PRESS(SCANCODE_F2))
fn = 2;
if (KEY_PRESS(SCANCODE_F3))
fn = 3;
if (KEY_PRESS(SCANCODE_F4))
fn = 4;
if (KEY_PRESS(SCANCODE_F5))
fn = 5;
if (KEY_PRESS(SCANCODE_F6))
fn = 6;
if (KEY_PRESS(SCANCODE_F7))
fn = 7;
if (KEY_PRESS(SCANCODE_F8))
fn = 8;
if (KEY_PRESS(SCANCODE_F9))
fn = 9;
if (KEY_PRESS(SCANCODE_F10))
fn = 10;
if (KEY_PRESS(SCANCODE_F11))
fn = 11;
if (KEY_PRESS(SCANCODE_F12))
fn = 12;
if (fn > 0)
{
if (!KEY_DOWN(SCANCODE_LEFTALT) && !KEY_DOWN(SCANCODE_LEFTSHIFT))
{
if (fn == 11)
{
S9xLoadSnapshot (S9xChooseFilename (TRUE));
}
else if (fn == 12)
{
Snapshot (S9xChooseFilename (FALSE));
}
else
{
char def [PATH_MAX];
char filename [PATH_MAX];
char drive [_MAX_DRIVE];
char dir [_MAX_DIR];
char ext [_MAX_EXT];
_splitpath (Memory.ROMFilename, drive, dir, def, ext);
sprintf (filename, "%s%s%s.%03d",
S9xGetSnapshotDirectory (), SLASH_STR, def,
fn - 1);
S9xLoadSnapshot (filename);
}
}
else if (KEY_DOWN(SCANCODE_LEFTALT))
{
if (fn >= 4)
S9xToggleSoundChannel (fn - 4);
#ifdef DEBUGGER
else if (fn == 1)
CPU.Flags |= DEBUG_MODE_FLAG;
#endif
else if (fn == 2)
S9xLoadSnapshot (S9xChooseFilename (TRUE));
else if (fn == 3)
Snapshot (S9xChooseFilename (FALSE));
}
else
{
char def [PATH_MAX];
char filename [PATH_MAX];
char drive [_MAX_DRIVE];
char dir [_MAX_DIR];
char ext [_MAX_EXT];
_splitpath (Memory.ROMFilename, drive, dir, def, ext);
sprintf (filename, "%s%s%s.%03d",
S9xGetSnapshotDirectory (), SLASH_STR, def,
fn - 1);
Snapshot (filename);
}
}
if (KEY_PRESS (SCANCODE_BREAK) || KEY_PRESS (SCANCODE_BREAK_ALTERNATIVE) ||
KEY_PRESS (SCANCODE_SCROLLLOCK))
Settings.Paused ^= 1;
if (KEY_PRESS (SCANCODE_PRINTSCREEN))
SaveScreenshot ();
if (KEY_PRESS (SCANCODE_MINUS))
{
if (Settings.SkipFrames <= 1)
Settings.SkipFrames = AUTO_FRAMERATE;
else
if (Settings.SkipFrames != AUTO_FRAMERATE)
Settings.SkipFrames--;
}
if (KEY_PRESS (SCANCODE_EQUAL))
{
if (Settings.SkipFrames == AUTO_FRAMERATE)
Settings.SkipFrames = 1;
else
if (Settings.SkipFrames < 10)
Settings.SkipFrames++;
}
memcpy (prev_keystate, keystate, sizeof (prev_keystate));
if (block)
__dpmi_yield ();
}
