source/mupen64plus-core/src/main/main.c

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  *   Mupen64plus - main.c                                                  *
   3  *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
   4  *   Copyright (C) 2012 CasualJames                                        *
   5  *   Copyright (C) 2008-2009 Richard Goedeken                              *
   6  *   Copyright (C) 2008 Ebenblues Nmn Okaygo Tillin9                       *
   7  *   Copyright (C) 2002 Hacktarux                                          *
   8  *                                                                         *
   9  *   This program is free software; you can redistribute it and/or modify  *
  10  *   it under the terms of the GNU General Public License as published by  *
  11  *   the Free Software Foundation; either version 2 of the License, or     *
  12  *   (at your option) any later version.                                   *
  13  *                                                                         *
  14  *   This program is distributed in the hope that it will be useful,       *
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  17  *   GNU General Public License for more details.                          *
  18  *                                                                         *
  19  *   You should have received a copy of the GNU General Public License     *
  20  *   along with this program; if not, write to the                         *
  21  *   Free Software Foundation, Inc.,                                       *
  22  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
  23  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  24
  25 /* This is MUPEN64's main entry point. It contains code that is common
  26  * to both the gui and non-gui versions of mupen64. See
  27  * gui subdirectories for the gui-specific code.
  28  * if you want to implement an interface, you should look here
  29  */
  30
  31 #include <string.h>
  32 #include <stdlib.h>
  33
  34 #include <SDL.h>
  35
  36 #define M64P_CORE_PROTOTYPES 1
  37 #include "api/m64p_types.h"
  38 #include "api/callbacks.h"
  39 #include "api/config.h"
  40 #include "api/m64p_config.h"
  41 #include "api/debugger.h"
  42 #include "api/vidext.h"
  43
  44 #include "main.h"
  45 #include "eventloop.h"
  46 #include "rom.h"
  47 #include "savestates.h"
  48 #include "util.h"
  49
  50 #include "memory/memory.h"
  51 #include "osal/files.h"
  52 #include "osal/preproc.h"
  53 #include "osd/osd.h"
  54 #include "osd/screenshot.h"
  55 #include "plugin/plugin.h"
  56 #include "r4300/r4300.h"
  57 #include "r4300/interupt.h"
  58 #include "r4300/reset.h"
  59
  60 #ifdef DBG
  61 #include "debugger/dbg_types.h"
  62 #include "debugger/debugger.h"
  63 #endif
  64
  65 #ifdef WITH_LIRC
  66 #include "lirc.h"
  67 #endif //WITH_LIRC
  68
  69 /* version number for Core config section */
  70 #define CONFIG_PARAM_VERSION 1.01
  71
  72 /** globals **/
  73 m64p_handle g_CoreConfig = NULL;
  74
  75 m64p_frame_callback g_FrameCallback = NULL;
  76
  77 int         g_MemHasBeenBSwapped = 0;   // store byte-swapped flag so we don't swap twice when re-playing game
  78 int         g_EmulatorRunning = 0;      // need separate boolean to tell if emulator is running, since --nogui doesn't use a thread
  79
  80 /** static (local) variables **/
  81 static int   l_CurrentFrame = 0;         // frame counter
  82 static int   l_TakeScreenshot = 0;       // Tell OSD Rendering callback to take a screenshot just before drawing the OSD
  83 static int   l_SpeedFactor = 100;        // percentage of nominal game speed at which emulator is running
  84 static int   l_FrameAdvance = 0;         // variable to check if we pause on next frame
  85 static int   l_MainSpeedLimit = 1;       // insert delay during vi_interrupt to keep speed at real-time
  86
  87 static osd_message_t *l_msgVol = NULL;
  88 static osd_message_t *l_msgFF = NULL;
  89 static osd_message_t *l_msgPause = NULL;
  90
  91 /*********************************************************************************************************
  92 * static functions
  93 */
  94
  95 static const char *get_savepathdefault(const char *configpath)
  96 {
  97     static char path[1024];
  98
  99     if (!configpath || (strlen(configpath) == 0)) {
 100         snprintf(path, 1024, "%ssave%c", ConfigGetUserDataPath(), OSAL_DIR_SEPARATORS[0]);
 101         path[1023] = 0;
 102     } else {
 103         snprintf(path, 1024, "%s%c", configpath, OSAL_DIR_SEPARATORS[0]);
 104         path[1023] = 0;
 105     }
 106
 107     /* create directory if it doesn't exist */
 108     osal_mkdirp(path, 0700);
 109
 110     return path;
 111 }
 112
 113
 114 /*********************************************************************************************************
 115 * helper functions
 116 */
 117
 118
 119 const char *get_savestatepath(void)
 120 {
 121     /* try to get the SaveStatePath string variable in the Core configuration section */
 122     return get_savepathdefault(ConfigGetParamString(g_CoreConfig, "SaveStatePath"));
 123 }
 124
 125 const char *get_savesrampath(void)
 126 {
 127     /* try to get the SaveSRAMPath string variable in the Core configuration section */
 128     return get_savepathdefault(ConfigGetParamString(g_CoreConfig, "SaveSRAMPath"));
 129 }
 130
 131 void main_message(m64p_msg_level level, unsigned int corner, const char *format, ...)
 132 {
 133     va_list ap;
 134     char buffer[2049];
 135     va_start(ap, format);
 136     vsnprintf(buffer, 2047, format, ap);
 137     buffer[2048]='\0';
 138     va_end(ap);
 139
 140     /* send message to on-screen-display if enabled */
 141     if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
 142         osd_new_message((enum osd_corner) corner, "%s", buffer);
 143     /* send message to front-end */
 144     DebugMessage(level, "%s", buffer);
 145 }
 146
 147
 148 /*********************************************************************************************************
 149 * global functions, for adjusting the core emulator behavior
 150 */
 151
 152 int main_set_core_defaults(void)
 153 {
 154     float fConfigParamsVersion;
 155     int bSaveConfig = 0, bUpgrade = 0;
 156
 157     if (ConfigGetParameter(g_CoreConfig, "Version", M64TYPE_FLOAT, &fConfigParamsVersion, sizeof(float)) != M64ERR_SUCCESS)
 158     {
 159         DebugMessage(M64MSG_WARNING, "No version number in 'Core' config section. Setting defaults.");
 160         ConfigDeleteSection("Core");
 161         ConfigOpenSection("Core", &g_CoreConfig);
 162         bSaveConfig = 1;
 163     }
 164     else if (((int) fConfigParamsVersion) != ((int) CONFIG_PARAM_VERSION))
 165     {
 166         DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in 'Core' config section: current is %.2f. Setting defaults.", fConfigParamsVersion, (float) CONFIG_PARAM_VERSION);
 167         ConfigDeleteSection("Core");
 168         ConfigOpenSection("Core", &g_CoreConfig);
 169         bSaveConfig = 1;
 170     }
 171     else if ((CONFIG_PARAM_VERSION - fConfigParamsVersion) >= 0.0001f)
 172     {
 173         float fVersion = (float) CONFIG_PARAM_VERSION;
 174         ConfigSetParameter(g_CoreConfig, "Version", M64TYPE_FLOAT, &fVersion);
 175         DebugMessage(M64MSG_INFO, "Updating parameter set version in 'Core' config section to %.2f", fVersion);
 176         bUpgrade = 1;
 177         bSaveConfig = 1;
 178     }
 179
 180     /* parameters controlling the operation of the core */
 181     ConfigSetDefaultFloat(g_CoreConfig, "Version", (float) CONFIG_PARAM_VERSION,  "Mupen64Plus Core config parameter set version number.  Please don't change this version number.");
 182     ConfigSetDefaultBool(g_CoreConfig, "OnScreenDisplay", 1, "Draw on-screen display if True, otherwise don't draw OSD");
 183 #if defined(DYNAREC)
 184     ConfigSetDefaultInt(g_CoreConfig, "R4300Emulator", 2, "Use Pure Interpreter if 0, Cached Interpreter if 1, or Dynamic Recompiler if 2 or more");
 185 #else
 186     ConfigSetDefaultInt(g_CoreConfig, "R4300Emulator", 1, "Use Pure Interpreter if 0, Cached Interpreter if 1, or Dynamic Recompiler if 2 or more");
 187 #endif
 188     ConfigSetDefaultBool(g_CoreConfig, "NoCompiledJump", 0, "Disable compiled jump commands in dynamic recompiler (should be set to False) ");
 189     ConfigSetDefaultBool(g_CoreConfig, "DisableExtraMem", 0, "Disable 4MB expansion RAM pack. May be necessary for some games");
 190     ConfigSetDefaultBool(g_CoreConfig, "AutoStateSlotIncrement", 0, "Increment the save state slot after each save operation");
 191     ConfigSetDefaultBool(g_CoreConfig, "EnableDebugger", 0, "Activate the R4300 debugger when ROM execution begins, if core was built with Debugger support");
 192     ConfigSetDefaultInt(g_CoreConfig, "CurrentStateSlot", 0, "Save state slot (0-9) to use when saving/loading the emulator state");
 193     ConfigSetDefaultString(g_CoreConfig, "ScreenshotPath", "", "Path to directory where screenshots are saved. If this is blank, the default value of ${UserConfigPath}/screenshot will be used");
 194     ConfigSetDefaultString(g_CoreConfig, "SaveStatePath", "", "Path to directory where emulator save states (snapshots) are saved. If this is blank, the default value of ${UserConfigPath}/save will be used");
 195     ConfigSetDefaultString(g_CoreConfig, "SaveSRAMPath", "", "Path to directory where SRAM/EEPROM data (in-game saves) are stored. If this is blank, the default value of ${UserConfigPath}/save will be used");
 196     ConfigSetDefaultString(g_CoreConfig, "SharedDataPath", "", "Path to a directory to search when looking for shared data files");
 197     ConfigSetDefaultBool(g_CoreConfig, "DelaySI", 0, "Delay interrupt after DMA SI read/write");
 198     ConfigSetDefaultInt(g_CoreConfig, "CountPerOp", 2, "Force number of cycles per emulated instruction");
 199
 200     /* handle upgrades */
 201     if (bUpgrade)
 202     {
 203         if (fConfigParamsVersion < 1.01f)
 204         {  // added separate SaveSRAMPath parameter in v1.01
 205             const char *pccSaveStatePath = ConfigGetParamString(g_CoreConfig, "SaveStatePath");
 206             if (pccSaveStatePath != NULL)
 207                 ConfigSetParameter(g_CoreConfig, "SaveSRAMPath", M64TYPE_STRING, pccSaveStatePath);
 208         }
 209     }
 210
 211     if (bSaveConfig)
 212         ConfigSaveSection("Core");
 213
 214     /* set config parameters for keyboard and joystick commands */
 215     return event_set_core_defaults();
 216 }
 217
 218 void main_speeddown(int percent)
 219 {
 220     if (l_SpeedFactor - percent > 10)  /* 10% minimum speed */
 221     {
 222         l_SpeedFactor -= percent;
 223         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "%s %d%%", "Playback speed:", l_SpeedFactor);
 224         audio.setSpeedFactor(l_SpeedFactor);
 225         StateChanged(M64CORE_SPEED_FACTOR, l_SpeedFactor);
 226     }
 227 }
 228
 229 void main_speedup(int percent)
 230 {
 231     if (l_SpeedFactor + percent < 300) /* 300% maximum speed */
 232     {
 233         l_SpeedFactor += percent;
 234         main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "%s %d%%", "Playback speed:", l_SpeedFactor);
 235         audio.setSpeedFactor(l_SpeedFactor);
 236         StateChanged(M64CORE_SPEED_FACTOR, l_SpeedFactor);
 237     }
 238 }
 239
 240 static void main_speedset(int percent)
 241 {
 242     if (percent < 1 || percent > 1000)
 243     {
 244         DebugMessage(M64MSG_WARNING, "Invalid speed setting %i percent", percent);
 245         return;
 246     }
 247     // disable fast-forward if it's enabled
 248     main_set_fastforward(0);
 249     // set speed
 250     l_SpeedFactor = percent;
 251     main_message(M64MSG_STATUS, OSD_BOTTOM_LEFT, "%s %d%%", "Playback speed:", l_SpeedFactor);
 252     audio.setSpeedFactor(l_SpeedFactor);
 253     StateChanged(M64CORE_SPEED_FACTOR, l_SpeedFactor);
 254 }
 255
 256 void main_set_fastforward(int enable)
 257 {
 258     static int ff_state = 0;
 259     static int SavedSpeedFactor = 100;
 260
 261     if (enable && !ff_state)
 262     {
 263         ff_state = 1; /* activate fast-forward */
 264         SavedSpeedFactor = l_SpeedFactor;
 265         l_SpeedFactor = 250;
 266         audio.setSpeedFactor(l_SpeedFactor);
 267         StateChanged(M64CORE_SPEED_FACTOR, l_SpeedFactor);
 268         // set fast-forward indicator
 269         l_msgFF = osd_new_message(OSD_TOP_RIGHT, "Fast Forward");
 270         osd_message_set_static(l_msgFF);
 271         osd_message_set_user_managed(l_msgFF);
 272     }
 273     else if (!enable && ff_state)
 274     {
 275         ff_state = 0; /* de-activate fast-forward */
 276         l_SpeedFactor = SavedSpeedFactor;
 277         audio.setSpeedFactor(l_SpeedFactor);
 278         StateChanged(M64CORE_SPEED_FACTOR, l_SpeedFactor);
 279         // remove message
 280         osd_delete_message(l_msgFF);
 281         l_msgFF = NULL;
 282     }
 283
 284 }
 285
 286 static void main_set_speedlimiter(int enable)
 287 {
 288     l_MainSpeedLimit = enable ? 1 : 0;
 289 }
 290
 291 static int main_is_paused(void)
 292 {
 293     return (g_EmulatorRunning && rompause);
 294 }
 295
 296 void main_toggle_pause(void)
 297 {
 298     if (!g_EmulatorRunning)
 299         return;
 300
 301     if (rompause)
 302     {
 303         DebugMessage(M64MSG_STATUS, "Emulation continued.");
 304         if(l_msgPause)
 305         {
 306             osd_delete_message(l_msgPause);
 307             l_msgPause = NULL;
 308         }
 309         StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
 310     }
 311     else
 312     {
 313         if(l_msgPause)
 314             osd_delete_message(l_msgPause);
 315
 316         DebugMessage(M64MSG_STATUS, "Emulation paused.");
 317         l_msgPause = osd_new_message(OSD_MIDDLE_CENTER, "Paused");
 318         osd_message_set_static(l_msgPause);
 319         osd_message_set_user_managed(l_msgPause);
 320         StateChanged(M64CORE_EMU_STATE, M64EMU_PAUSED);
 321     }
 322
 323     rompause = !rompause;
 324     l_FrameAdvance = 0;
 325 }
 326
 327 void main_advance_one(void)
 328 {
 329     l_FrameAdvance = 1;
 330     rompause = 0;
 331     StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
 332 }
 333
 334 static void main_draw_volume_osd(void)
 335 {
 336     char msgString[64];
 337     const char *volString;
 338
 339     // this calls into the audio plugin
 340     volString = audio.volumeGetString();
 341     if (volString == NULL)
 342     {
 343         strcpy(msgString, "Volume Not Supported.");
 344     }
 345     else
 346     {
 347         sprintf(msgString, "%s: %s", "Volume", volString);
 348     }
 349
 350     // create a new message or update an existing one
 351     if (l_msgVol != NULL)
 352         osd_update_message(l_msgVol, "%s", msgString);
 353     else {
 354         l_msgVol = osd_new_message(OSD_MIDDLE_CENTER, "%s", msgString);
 355         osd_message_set_user_managed(l_msgVol);
 356     }
 357 }
 358
 359 /* this function could be called as a result of a keypress, joystick/button movement,
 360    LIRC command, or 'testshots' command-line option timer */
 361 void main_take_next_screenshot(void)
 362 {
 363     l_TakeScreenshot = l_CurrentFrame + 1;
 364 }
 365
 366 void main_state_set_slot(int slot)
 367 {
 368     if (slot < 0 || slot > 9)
 369     {
 370         DebugMessage(M64MSG_WARNING, "Invalid savestate slot '%i' in main_state_set_slot().  Using 0", slot);
 371         slot = 0;
 372     }
 373
 374     savestates_select_slot(slot);
 375     StateChanged(M64CORE_SAVESTATE_SLOT, slot);
 376 }
 377
 378 void main_state_inc_slot(void)
 379 {
 380     savestates_inc_slot();
 381 }
 382
 383 static unsigned char StopRumble[64] = {0x23, 0x01, 0x03, 0xc0, 0x1b, 0x00, 0x00, 0x00,
 384                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 385                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 386                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 387                                        0, 0, 0, 0, 0, 0, 0, 0};
 388
 389 void main_state_load(const char *filename)
 390 {
 391     input.controllerCommand(0, StopRumble);
 392     input.controllerCommand(1, StopRumble);
 393     input.controllerCommand(2, StopRumble);
 394     input.controllerCommand(3, StopRumble);
 395
 396     if (filename == NULL) // Save to slot
 397         savestates_set_job(savestates_job_load, savestates_type_m64p, NULL);
 398     else
 399         savestates_set_job(savestates_job_load, savestates_type_unknown, filename);
 400 }
 401
 402 void main_state_save(int format, const char *filename)
 403 {
 404     if (filename == NULL) // Save to slot
 405         savestates_set_job(savestates_job_save, savestates_type_m64p, NULL);
 406     else // Save to file
 407         savestates_set_job(savestates_job_save, (savestates_type)format, filename);
 408 }
 409
 410 m64p_error main_core_state_query(m64p_core_param param, int *rval)
 411 {
 412     switch (param)
 413     {
 414         case M64CORE_EMU_STATE:
 415             if (!g_EmulatorRunning)
 416                 *rval = M64EMU_STOPPED;
 417             else if (rompause)
 418                 *rval = M64EMU_PAUSED;
 419             else
 420                 *rval = M64EMU_RUNNING;
 421             break;
 422         case M64CORE_VIDEO_MODE:
 423             if (!VidExt_VideoRunning())
 424                 *rval = M64VIDEO_NONE;
 425             else if (VidExt_InFullscreenMode())
 426                 *rval = M64VIDEO_FULLSCREEN;
 427             else
 428                 *rval = M64VIDEO_WINDOWED;
 429             break;
 430         case M64CORE_SAVESTATE_SLOT:
 431             *rval = savestates_get_slot();
 432             break;
 433         case M64CORE_SPEED_FACTOR:
 434             *rval = l_SpeedFactor;
 435             break;
 436         case M64CORE_SPEED_LIMITER:
 437             *rval = l_MainSpeedLimit;
 438             break;
 439         case M64CORE_VIDEO_SIZE:
 440         {
 441             int width, height;
 442             if (!g_EmulatorRunning)
 443                 return M64ERR_INVALID_STATE;
 444             main_get_screen_size(&width, &height);
 445             *rval = (width << 16) + height;
 446             break;
 447         }
 448         case M64CORE_AUDIO_VOLUME:
 449         {
 450             if (!g_EmulatorRunning)
 451                 return M64ERR_INVALID_STATE;
 452             return main_volume_get_level(rval);
 453         }
 454         case M64CORE_AUDIO_MUTE:
 455             *rval = main_volume_get_muted();
 456             break;
 457         case M64CORE_INPUT_GAMESHARK:
 458             *rval = event_gameshark_active();
 459             break;
 460         // these are only used for callbacks; they cannot be queried or set
 461         case M64CORE_STATE_LOADCOMPLETE:
 462         case M64CORE_STATE_SAVECOMPLETE:
 463             return M64ERR_INPUT_INVALID;
 464         default:
 465             return M64ERR_INPUT_INVALID;
 466     }
 467
 468     return M64ERR_SUCCESS;
 469 }
 470
 471 m64p_error main_core_state_set(m64p_core_param param, int val)
 472 {
 473     switch (param)
 474     {
 475         case M64CORE_EMU_STATE:
 476             if (!g_EmulatorRunning)
 477                 return M64ERR_INVALID_STATE;
 478             if (val == M64EMU_STOPPED)
 479             {
 480                 /* this stop function is asynchronous.  The emulator may not terminate until later */
 481                 main_stop();
 482                 return M64ERR_SUCCESS;
 483             }
 484             else if (val == M64EMU_RUNNING)
 485             {
 486                 if (main_is_paused())
 487                     main_toggle_pause();
 488                 return M64ERR_SUCCESS;
 489             }
 490             else if (val == M64EMU_PAUSED)
 491             {
 492                 if (!main_is_paused())
 493                     main_toggle_pause();
 494                 return M64ERR_SUCCESS;
 495             }
 496             return M64ERR_INPUT_INVALID;
 497         case M64CORE_VIDEO_MODE:
 498             if (!g_EmulatorRunning)
 499                 return M64ERR_INVALID_STATE;
 500             if (val == M64VIDEO_WINDOWED)
 501             {
 502                 if (VidExt_InFullscreenMode())
 503                     gfx.changeWindow();
 504                 return M64ERR_SUCCESS;
 505             }
 506             else if (val == M64VIDEO_FULLSCREEN)
 507             {
 508                 if (!VidExt_InFullscreenMode())
 509                     gfx.changeWindow();
 510                 return M64ERR_SUCCESS;
 511             }
 512             return M64ERR_INPUT_INVALID;
 513         case M64CORE_SAVESTATE_SLOT:
 514             if (val < 0 || val > 9)
 515                 return M64ERR_INPUT_INVALID;
 516             savestates_select_slot(val);
 517             return M64ERR_SUCCESS;
 518         case M64CORE_SPEED_FACTOR:
 519             if (!g_EmulatorRunning)
 520                 return M64ERR_INVALID_STATE;
 521             main_speedset(val);
 522             return M64ERR_SUCCESS;
 523         case M64CORE_SPEED_LIMITER:
 524             main_set_speedlimiter(val);
 525             return M64ERR_SUCCESS;
 526         case M64CORE_VIDEO_SIZE:
 527         {
 528             // the front-end app is telling us that the user has resized the video output frame, and so
 529             // we should try to update the video plugin accordingly.  First, check state
 530             int width, height;
 531             if (!g_EmulatorRunning)
 532                 return M64ERR_INVALID_STATE;
 533             width = (val >> 16) & 0xffff;
 534             height = val & 0xffff;
 535             // then call the video plugin.  if the video plugin supports resizing, it will resize its viewport and call
 536             // VidExt_ResizeWindow to update the window manager handling our opengl output window
 537             gfx.resizeVideoOutput(width, height);
 538             return M64ERR_SUCCESS;
 539         }
 540         case M64CORE_AUDIO_VOLUME:
 541             if (!g_EmulatorRunning)
 542                 return M64ERR_INVALID_STATE;
 543             if (val < 0 || val > 100)
 544                 return M64ERR_INPUT_INVALID;
 545             return main_volume_set_level(val);
 546         case M64CORE_AUDIO_MUTE:
 547             if ((main_volume_get_muted() && !val) || (!main_volume_get_muted() && val))
 548                 return main_volume_mute();
 549             return M64ERR_SUCCESS;
 550         case M64CORE_INPUT_GAMESHARK:
 551             if (!g_EmulatorRunning)
 552                 return M64ERR_INVALID_STATE;
 553             event_set_gameshark(val);
 554             return M64ERR_SUCCESS;
 555         // these are only used for callbacks; they cannot be queried or set
 556         case M64CORE_STATE_LOADCOMPLETE:
 557         case M64CORE_STATE_SAVECOMPLETE:
 558             return M64ERR_INPUT_INVALID;
 559         default:
 560             return M64ERR_INPUT_INVALID;
 561     }
 562 }
 563
 564 m64p_error main_get_screen_size(int *width, int *height)
 565 {
 566     gfx.readScreen(NULL, width, height, 0);
 567     return M64ERR_SUCCESS;
 568 }
 569
 570 m64p_error main_read_screen(void *pixels, int bFront)
 571 {
 572     int width_trash, height_trash;
 573     gfx.readScreen(pixels, &width_trash, &height_trash, bFront);
 574     return M64ERR_SUCCESS;
 575 }
 576
 577 m64p_error main_volume_up(void)
 578 {
 579     int level = 0;
 580     audio.volumeUp();
 581     main_draw_volume_osd();
 582     main_volume_get_level(&level);
 583     StateChanged(M64CORE_AUDIO_VOLUME, level);
 584     return M64ERR_SUCCESS;
 585 }
 586
 587 m64p_error main_volume_down(void)
 588 {
 589     int level = 0;
 590     audio.volumeDown();
 591     main_draw_volume_osd();
 592     main_volume_get_level(&level);
 593     StateChanged(M64CORE_AUDIO_VOLUME, level);
 594     return M64ERR_SUCCESS;
 595 }
 596
 597 m64p_error main_volume_get_level(int *level)
 598 {
 599     *level = audio.volumeGetLevel();
 600     return M64ERR_SUCCESS;
 601 }
 602
 603 m64p_error main_volume_set_level(int level)
 604 {
 605     audio.volumeSetLevel(level);
 606     main_draw_volume_osd();
 607     level = audio.volumeGetLevel();
 608     StateChanged(M64CORE_AUDIO_VOLUME, level);
 609     return M64ERR_SUCCESS;
 610 }
 611
 612 m64p_error main_volume_mute(void)
 613 {
 614     audio.volumeMute();
 615     main_draw_volume_osd();
 616     StateChanged(M64CORE_AUDIO_MUTE, main_volume_get_muted());
 617     return M64ERR_SUCCESS;
 618 }
 619
 620 int main_volume_get_muted(void)
 621 {
 622     return (audio.volumeGetLevel() == 0);
 623 }
 624
 625 m64p_error main_reset(int do_hard_reset)
 626 {
 627     if (do_hard_reset)
 628         reset_hard_job |= 1;
 629     else
 630         reset_soft();
 631     return M64ERR_SUCCESS;
 632 }
 633
 634 /*********************************************************************************************************
 635 * global functions, callbacks from the r4300 core or from other plugins
 636 */
 637
 638 static void video_plugin_render_callback(int bScreenRedrawn)
 639 {
 640     int bOSD = ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay");
 641
 642     // if the flag is set to take a screenshot, then grab it now
 643     if (l_TakeScreenshot != 0)
 644     {
 645         // if the OSD is enabled, and the screen has not been recently redrawn, then we cannot take a screenshot now because
 646         // it contains the OSD text.  Wait until the next redraw
 647         if (!bOSD || bScreenRedrawn)
 648         {
 649             TakeScreenshot(l_TakeScreenshot - 1);  // current frame number +1 is in l_TakeScreenshot
 650             l_TakeScreenshot = 0; // reset flag
 651         }
 652     }
 653
 654     // if the OSD is enabled, then draw it now
 655     if (bOSD)
 656     {
 657         osd_render();
 658     }
 659 }
 660
 661 void new_frame(void)
 662 {
 663     if (g_FrameCallback != NULL)
 664         (*g_FrameCallback)(l_CurrentFrame);
 665
 666     /* advance the current frame */
 667     l_CurrentFrame++;
 668
 669     if (l_FrameAdvance) {
 670         rompause = 1;
 671         l_FrameAdvance = 0;
 672         StateChanged(M64CORE_EMU_STATE, M64EMU_PAUSED);
 673     }
 674 }
 675
 676 void new_vi(void)
 677 {
 678     int Dif;
 679     unsigned int CurrentFPSTime;
 680     static unsigned int LastFPSTime = 0;
 681     static unsigned int CounterTime = 0;
 682     static unsigned int CalculatedTime ;
 683     static int VI_Counter = 0;
 684
 685     double VILimitMilliseconds = 1000.0 / ROM_PARAMS.vilimit;
 686     double AdjustedLimit = VILimitMilliseconds * 100.0 / l_SpeedFactor;  // adjust for selected emulator speed
 687     int time;
 688
 689     start_section(IDLE_SECTION);
 690     VI_Counter++;
 691
 692 #ifdef DBG
 693     if(g_DebuggerActive) DebuggerCallback(DEBUG_UI_VI, 0);
 694 #endif
 695
 696     if(LastFPSTime == 0)
 697     {
 698         LastFPSTime = CounterTime = SDL_GetTicks();
 699         return;
 700     }
 701     CurrentFPSTime = SDL_GetTicks();
 702
 703     Dif = CurrentFPSTime - LastFPSTime;
 704
 705     if (Dif < AdjustedLimit)
 706     {
 707         CalculatedTime = (unsigned int) (CounterTime + AdjustedLimit * VI_Counter);
 708         time = (int)(CalculatedTime - CurrentFPSTime);
 709         if (time > 0 && l_MainSpeedLimit)
 710         {
 711             DebugMessage(M64MSG_VERBOSE, "    new_vi(): Waiting %ims", time);
 712             SDL_Delay(time);
 713         }
 714         CurrentFPSTime = CurrentFPSTime + time;
 715     }
 716
 717     if (CurrentFPSTime - CounterTime >= 1000.0 )
 718     {
 719         CounterTime = SDL_GetTicks();
 720         VI_Counter = 0 ;
 721     }
 722
 723     LastFPSTime = CurrentFPSTime ;
 724     end_section(IDLE_SECTION);
 725 }
 726
 727 /*********************************************************************************************************
 728 * emulation thread - runs the core
 729 */
 730 m64p_error main_run(void)
 731 {
 732     /* take the r4300 emulator mode from the config file at this point and cache it in a global variable */
 733     r4300emu = ConfigGetParamInt(g_CoreConfig, "R4300Emulator");
 734
 735     /* set some other core parameters based on the config file values */
 736     savestates_set_autoinc_slot(ConfigGetParamBool(g_CoreConfig, "AutoStateSlotIncrement"));
 737     savestates_select_slot(ConfigGetParamInt(g_CoreConfig, "CurrentStateSlot"));
 738     no_compiled_jump = ConfigGetParamBool(g_CoreConfig, "NoCompiledJump");
 739         if (delay_si==-1) delay_si = ConfigGetParamBool(g_CoreConfig, "DelaySI");
 740     if (count_per_op==-1) count_per_op = ConfigGetParamInt(g_CoreConfig, "CountPerOp");
 741     if (count_per_op <= 0)
 742         count_per_op = 2;
 743
 744         // initialize memory, and do byte-swapping if it's not been done yet
 745     if (g_MemHasBeenBSwapped == 0)
 746     {
 747         init_memory(1);
 748         g_MemHasBeenBSwapped = 1;
 749     }
 750     else
 751     {
 752         init_memory(0);
 753     }
 754     // Attach rom to plugins
 755     if (!gfx.romOpen())
 756     {
 757         free_memory(); return M64ERR_PLUGIN_FAIL;
 758     }
 759     if (!audio.romOpen())
 760     {
 761         gfx.romClosed(); free_memory(); return M64ERR_PLUGIN_FAIL;
 762     }
 763     if (!input.romOpen())
 764     {
 765         audio.romClosed(); gfx.romClosed(); free_memory(); return M64ERR_PLUGIN_FAIL;
 766     }
 767
 768
 769     /* set up the SDL key repeat and event filter to catch keyboard/joystick commands for the core */
 770     event_initialize();
 771
 772     /* initialize the on-screen display */
 773     if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
 774     {
 775         // init on-screen display
 776         int width = 640, height = 480;
 777         gfx.readScreen(NULL, &width, &height, 0); // read screen to get width and height
 778         osd_init(width, height);
 779     }
 780
 781     // setup rendering callback from video plugin to the core, for screenshots and On-Screen-Display
 782     gfx.setRenderingCallback(video_plugin_render_callback);
 783
 784 #ifdef WITH_LIRC
 785     lircStart();
 786 #endif // WITH_LIRC
 787
 788 #ifdef DBG
 789     if (ConfigGetParamBool(g_CoreConfig, "EnableDebugger"))
 790         init_debugger();
 791 #endif
 792     /* Startup message on the OSD */
 793     osd_new_message(OSD_MIDDLE_CENTER, "Mupen64Plus Started...");
 794     g_EmulatorRunning = 1;
 795     StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
 796     /* call r4300 CPU core and run the game */
 797     r4300_reset_hard();
 798     r4300_reset_soft();
 799     r4300_execute();
 800
 801     /* now begin to shut down */
 802 #ifdef WITH_LIRC
 803     lircStop();
 804 #endif // WITH_LIRC
 805
 806 #ifdef DBG
 807     if (g_DebuggerActive)
 808         destroy_debugger();
 809 #endif
 810
 811     if (ConfigGetParamBool(g_CoreConfig, "OnScreenDisplay"))
 812     {
 813         osd_exit();
 814     }
 815
 816     rsp.romClosed();
 817     input.romClosed();
 818     audio.romClosed();
 819     gfx.romClosed();
 820     free_memory();
 821
 822     // clean up
 823     g_EmulatorRunning = 0;
 824     StateChanged(M64CORE_EMU_STATE, M64EMU_STOPPED);
 825
 826     return M64ERR_SUCCESS;
 827 }
 828
 829 void main_stop(void)
 830 {
 831     /* note: this operation is asynchronous.  It may be called from a thread other than the
 832        main emulator thread, and may return before the emulator is completely stopped */
 833     if (!g_EmulatorRunning)
 834         return;
 835
 836     DebugMessage(M64MSG_STATUS, "Stopping emulation.");
 837     if(l_msgPause)
 838     {
 839         osd_delete_message(l_msgPause);
 840         l_msgPause = NULL;
 841     }
 842     if(l_msgFF)
 843     {
 844         osd_delete_message(l_msgFF);
 845         l_msgFF = NULL;
 846     }
 847     if(l_msgVol)
 848     {
 849         osd_delete_message(l_msgVol);
 850         l_msgVol = NULL;
 851     }
 852     if (rompause)
 853     {
 854         rompause = 0;
 855         StateChanged(M64CORE_EMU_STATE, M64EMU_RUNNING);
 856     }
 857     stop = 1;
 858 #ifdef DBG
 859     if(g_DebuggerActive)
 860     {
 861         debugger_step();
 862     }
 863 #endif
 864 }