void _mainthread(PVOID pvoid)
{
HMENU hmenu;
main_init(argc, argv);
//Carlo Concari: show correct disc protected status at startup
hmenu=GetMenu(ghwnd);
CheckMenuItem(hmenu, IDM_DISC_WPROT_0, (writeprot[0]) ? MF_CHECKED : MF_UNCHECKED);
CheckMenuItem(hmenu, IDM_DISC_WPROT_1, (writeprot[1]) ? MF_CHECKED : MF_UNCHECKED);
while (1)
{
main_run();
if (doautoboot)
{
main_reset();
disc_close(0);
disc_load(0, discfns[0]);
if (defaultwriteprot) writeprot[0] = 1;
hmenu = GetMenu(ghwnd);
CheckMenuItem(hmenu, IDM_DISC_WPROT_0, (writeprot[0]) ? MF_CHECKED : MF_UNCHECKED);
autoboot = 150;
doautoboot = 0;
}
}
}
gint main(gint argc,gchar* argv[])
{
int res;
/*---GTK��ʼ��----*/
gtk_init(&argc, &argv);
g_thread_init(NULL);
gdk_threads_init();
struct wcam_win *c = calloc(1, sizeof(struct wcam_win));
c->entry_win = login_create();
res = login_run(c->entry_win);
if (res == -1) {
goto err_win;
}
login_hide(c->entry_win);
main_create(c);
main_run();
err_win:
free(c->entry_win);
free(c);
return 0;
}
int
main (int argc, char **argv)
{
char **opts = main_init (argc, argv);
fd_epoll = epoll_create (1024);
ASSERT (fd_epoll >= 0);
main_init_srv (opts);
main_run (&main_loop);
close (fd_epoll);
return 0;
}
const char * usf_render(void * state, int16_t * buffer, size_t count, int32_t * sample_rate)
{
USF_STATE->last_error = 0;
USF_STATE->error_message[0] = '\0';
if ( !USF_STATE->MemoryState )
{
if ( usf_startup( USF_STATE ) < 0 )
return USF_STATE->last_error;
}
if ( USF_STATE->samples_in_buffer )
{
size_t do_max = USF_STATE->samples_in_buffer;
if ( do_max > count )
do_max = count;
if ( buffer )
memcpy( buffer, USF_STATE->samplebuf, sizeof(int16_t) * 2 * do_max );
USF_STATE->samples_in_buffer -= do_max;
if ( sample_rate )
*sample_rate = USF_STATE->SampleRate;
if ( USF_STATE->samples_in_buffer )
{
memmove( USF_STATE->samplebuf, USF_STATE->samplebuf + do_max * 2, sizeof(int16_t) * 2 * USF_STATE->samples_in_buffer );
return 0;
}
if ( buffer )
buffer += 2 * do_max;
count -= do_max;
}
USF_STATE->sample_buffer = buffer;
USF_STATE->sample_buffer_count = count;
USF_STATE->stop = 0;
main_run(USF_STATE);
if ( sample_rate )
*sample_rate = USF_STATE->SampleRate;
return USF_STATE->last_error;
}
int STDCALL
WinMain(HINSTANCE instance, HINSTANCE previnst, LPSTR cline, int cmd_show) {
int ret;
FOUNDATION_UNUSED(instance);
FOUNDATION_UNUSED(previnst);
FOUNDATION_UNUSED(cline);
FOUNDATION_UNUSED(cmd_show);
if (main_initialize() < 0)
return -1;
SetConsoleCtrlHandler(_main_console_handler, TRUE);
thread_set_main();
foundation_startup();
system_post_event(FOUNDATIONEVENT_START);
#if BUILD_DEBUG
ret = main_run(0);
#else
{
string_t name;
const application_t* app = environment_application();
string_const_t aname = app->short_name;
string_const_t vstr = string_from_version_static(app->version);
name = string_allocate_concat_varg(
aname.length ? aname.str : "unknown", aname.length ? aname.length : 7,
STRING_CONST("-"),
STRING_CONST(vstr));
if (app->dump_callback)
crash_guard_set(app->dump_callback, STRING_ARGS(name));
ret = crash_guard(main_run, 0, app->dump_callback, STRING_ARGS(name));
string_deallocate(name.str);
}
#endif
main_finalize();
return ret;
}
/*! Normal entry point for all platforms, including Windows console applications */
int
main(int argc, char** argv)
#endif
{
int ret;
#if !FOUNDATION_PLATFORM_ANDROID && !FOUNDATION_PLATFORM_PNACL
_environment_main_args(argc, (const char* const*)argv);
#elif FOUNDATION_PLATFORM_PNACL
FOUNDATION_UNUSED(instance);
#endif
ret = main_initialize();
if (ret < 0)
return ret;
#if FOUNDATION_PLATFORM_POSIX
//Set signal handlers
{
struct sigaction action;
memset(&action, 0, sizeof(action));
#if FOUNDATION_COMPILER_CLANG
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdisabled-macro-expansion"
#endif
//Signals we process globally
action.sa_handler = sighandler;
sigaction(SIGKILL, &action, 0);
sigaction(SIGTERM, &action, 0);
sigaction(SIGQUIT, &action, 0);
sigaction(SIGINT, &action, 0);
sigaction(SIGABRT, &action, 0);
//Ignore sigpipe
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, 0);
#if FOUNDATION_COMPILER_CLANG
# pragma clang diagnostic pop
#endif
}
#endif
#if FOUNDATION_PLATFORM_ANDROID
if ((ret = android_initialize()) < 0)
return ret;
#endif
#if FOUNDATION_PLATFORM_TIZEN
if ((ret = tizen_initialize()) < 0)
return ret;
#endif
#if FOUNDATION_PLATFORM_WINDOWS
SetConsoleCtrlHandler(_main_console_handler, TRUE);
#endif
thread_set_main();
foundation_startup();
#if FOUNDATION_PLATFORM_WINDOWS || FOUNDATION_PLATFORM_LINUX || FOUNDATION_PLATFORM_PNACL
system_post_event(FOUNDATIONEVENT_START);
#endif
#if FOUNDATION_PLATFORM_APPLE
# if FOUNDATION_PLATFORM_MACOSX
if (!(environment_application()->flags & APPLICATION_UTILITY)) {
delegate_start_main_ns_thread();
extern int NSApplicationMain(int argc, char* argv[]);
ret = NSApplicationMain(argc, argv);
# elif FOUNDATION_PLATFORM_IOS
{
delegate_start_main_ns_thread();
extern int UIApplicationMain(int argc, char* argv[], void* principalClassName,
void* delegateClassName);
ret = UIApplicationMain(argc, (char**)argv, 0, 0);
# endif
//NSApplicationMain and UIApplicationMain never returns though
return ret;
}
#endif
#if !FOUNDATION_PLATFORM_IOS
# if FOUNDATION_PLATFORM_TIZEN
tizen_start_main_thread();
ret = tizen_app_main(argc, argv);
# else
{
string_t name;
const application_t* app = environment_application();
{
string_const_t vstr = string_from_version_static(app->version);
string_const_t aname = app->short_name;
if (!aname.length)
aname = string_const(STRING_CONST("unknown"));
name = string_allocate_format(STRING_CONST("%.*s-%.*s"), (int)aname.length, aname.str,
(int)vstr.length, vstr.str);
}
if (app->dump_callback)
crash_guard_set(app->dump_callback, name.str, name.length);
if (system_debugger_attached())
ret = main_run(0);
else
ret = crash_guard(main_run, 0, app->dump_callback, name.str, name.length);
string_deallocate(name.str);
}
# endif
main_finalize();
#if FOUNDATION_PLATFORM_ANDROID
android_finalize();
#endif
#if FOUNDATION_PLATFORM_TIZEN
tizen_finalize();
#endif
return ret;
#endif
}
#if FOUNDATION_PLATFORM_ANDROID
/*! Android native glue entry point */
void
android_main(struct android_app * app) {
if (!app)
return;
android_entry(app);
real_main();
}
#endif
#if FOUNDATION_PLATFORM_PNACL
/*! PNaCl glue entry points */
PP_EXPORT int32_t
PPP_InitializeModule(PP_Module module_id, PPB_GetInterface get_browser) {
return pnacl_module_initialize(module_id, get_browser);
}
PP_EXPORT const void*
PPP_GetInterface(const char* interface_name) {
return pnacl_module_interface(interface_name, string_length(interface_name));
}
PP_EXPORT void
PPP_ShutdownModule() {
pnacl_module_finalize();
}
EXPORT m64p_error CALL CoreDoCommand(m64p_command Command, int ParamInt, void *ParamPtr)
{
m64p_error rval;
int keysym, keymod;
if (!l_CoreInit)
return M64ERR_NOT_INIT;
switch(Command)
{
case M64CMD_NOP:
return M64ERR_SUCCESS;
case M64CMD_ROM_OPEN:
if (g_EmulatorRunning || l_ROMOpen)
return M64ERR_INVALID_STATE;
if (ParamPtr == NULL || ParamInt < 4096)
return M64ERR_INPUT_ASSERT;
rval = open_rom((const unsigned char *) ParamPtr, ParamInt);
if (rval == M64ERR_SUCCESS)
{
l_ROMOpen = 1;
}
return rval;
case M64CMD_ROM_CLOSE:
if (g_EmulatorRunning || !l_ROMOpen)
return M64ERR_INVALID_STATE;
l_ROMOpen = 0;
return close_rom();
case M64CMD_ROM_GET_HEADER:
if (!l_ROMOpen)
return M64ERR_INVALID_STATE;
if (ParamPtr == NULL)
return M64ERR_INPUT_ASSERT;
if (sizeof(m64p_rom_header) < ParamInt)
ParamInt = sizeof(m64p_rom_header);
memcpy(ParamPtr, &ROM_HEADER, ParamInt);
// Mupen64Plus used to keep a m64p_rom_header with a clean ROM name
// Keep returning a clean ROM name for backwards compatibility
if (ParamInt >= 0x20)
{
int size = (ParamInt >= 0x20 + 20) ? 20 : (ParamInt - 0x20);
memcpy((char *)ParamPtr + 0x20, ROM_PARAMS.headername, size);
}
return M64ERR_SUCCESS;
case M64CMD_ROM_GET_SETTINGS:
if (!l_ROMOpen)
return M64ERR_INVALID_STATE;
if (ParamPtr == NULL)
return M64ERR_INPUT_ASSERT;
if (sizeof(m64p_rom_settings) < ParamInt)
ParamInt = sizeof(m64p_rom_settings);
memcpy(ParamPtr, &ROM_SETTINGS, ParamInt);
return M64ERR_SUCCESS;
case M64CMD_EXECUTE:
if (g_EmulatorRunning || !l_ROMOpen)
return M64ERR_INVALID_STATE;
/* the main_run() function will not return until the player has quit the game */
rval = main_run();
return rval;
case M64CMD_STOP:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
/* this stop function is asynchronous. The emulator may not terminate until later */
return main_core_state_set(M64CORE_EMU_STATE, M64EMU_STOPPED);
case M64CMD_PAUSE:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
return main_core_state_set(M64CORE_EMU_STATE, M64EMU_PAUSED);
case M64CMD_RESUME:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
return main_core_state_set(M64CORE_EMU_STATE, M64EMU_RUNNING);
case M64CMD_CORE_STATE_QUERY:
if (ParamPtr == NULL)
return M64ERR_INPUT_ASSERT;
return main_core_state_query((m64p_core_param) ParamInt, (int *) ParamPtr);
case M64CMD_CORE_STATE_SET:
if (ParamPtr == NULL)
return M64ERR_INPUT_ASSERT;
return main_core_state_set((m64p_core_param) ParamInt, *((int *)ParamPtr));
case M64CMD_SET_FRAME_CALLBACK:
g_FrameCallback = (m64p_frame_callback) ParamPtr;
return M64ERR_SUCCESS;
case M64CMD_READ_SCREEN:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
if (ParamPtr == NULL)
return M64ERR_INPUT_ASSERT;
if (ParamInt < 0 || ParamInt > 1)
return M64ERR_INPUT_INVALID;
return main_read_screen(ParamPtr, ParamInt);
case M64CMD_RESET:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
if (ParamInt < 0 || ParamInt > 1)
return M64ERR_INPUT_INVALID;
return main_reset(ParamInt);
case M64CMD_ADVANCE_FRAME:
if (!g_EmulatorRunning)
return M64ERR_INVALID_STATE;
main_advance_one();
return M64ERR_SUCCESS;
default:
return M64ERR_INPUT_INVALID;
}
return M64ERR_INTERNAL;
}
