static int SetConfigParameter(const char *ParamSpec)
{
char *ParsedString, *VarName, *VarValue=NULL;
m64p_handle ConfigSection;
m64p_type VarType;
m64p_error rval;
if (ParamSpec == NULL)
{
DebugMessage(M64MSG_ERROR, "ParamSpec is NULL in SetConfigParameter()");
return 1;
}
/* make a copy of the input string */
ParsedString = (char *) malloc(strlen(ParamSpec) + 1);
if (ParsedString == NULL)
{
DebugMessage(M64MSG_ERROR, "SetConfigParameter() couldn't allocate memory for temporary string.");
return 2;
}
strcpy(ParsedString, ParamSpec);
/* parse it for the simple section[name]=value format */
VarName = strchr(ParsedString, '[');
if (VarName != NULL)
{
*VarName++ = 0;
VarValue = strchr(VarName, ']');
if (VarValue != NULL)
{
*VarValue++ = 0;
}
}
if (VarName == NULL || VarValue == NULL || *VarValue != '=')
{
DebugMessage(M64MSG_ERROR, "invalid (param-spec) '%s'", ParamSpec);
free(ParsedString);
return 3;
}
VarValue++;
/* then set the value */
rval = (*ConfigOpenSection)(ParsedString, &ConfigSection);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "SetConfigParameter failed to open config section '%s'", ParsedString);
free(ParsedString);
return 4;
}
if ((*ConfigGetParameterType)(ConfigSection, VarName, &VarType) == M64ERR_SUCCESS)
{
switch(VarType)
{
int ValueInt;
float ValueFloat;
case M64TYPE_INT:
ValueInt = atoi(VarValue);
ConfigSetParameter(ConfigSection, VarName, M64TYPE_INT, &ValueInt);
break;
case M64TYPE_FLOAT:
ValueFloat = (float) atof(VarValue);
ConfigSetParameter(ConfigSection, VarName, M64TYPE_FLOAT, &ValueFloat);
break;
case M64TYPE_BOOL:
ValueInt = (int) (osal_insensitive_strcmp(VarValue, "true") == 0);
ConfigSetParameter(ConfigSection, VarName, M64TYPE_BOOL, &ValueInt);
break;
case M64TYPE_STRING:
ConfigSetParameter(ConfigSection, VarName, M64TYPE_STRING, VarValue);
break;
default:
DebugMessage(M64MSG_ERROR, "invalid VarType in SetConfigParameter()");
return 5;
}
}
else
{
ConfigSetParameter(ConfigSection, VarName, M64TYPE_STRING, VarValue);
}
free(ParsedString);
return 0;
}
void gen_interupt(void)
{
if (stop == 1)
{
g_gs_vi_counter = 0; // debug
dyna_stop();
}
if (!interupt_unsafe_state)
{
if (savestates_get_job() == savestates_job_load)
{
savestates_load();
return;
}
if (reset_hard_job)
{
reset_hard();
reset_hard_job = 0;
return;
}
}
if (skip_jump)
{
uint32_t dest = skip_jump;
skip_jump = 0;
next_interupt = (q.first->data.count > g_cp0_regs[CP0_COUNT_REG]
|| (g_cp0_regs[CP0_COUNT_REG] - q.first->data.count) < UINT32_C(0x80000000))
? q.first->data.count
: 0;
last_addr = dest;
generic_jump_to(dest);
return;
}
switch(q.first->data.type)
{
case SPECIAL_INT:
special_int_handler();
break;
case VI_INT:
remove_interupt_event();
vi_vertical_interrupt_event(&g_dev.vi);
break;
case COMPARE_INT:
compare_int_handler();
break;
case CHECK_INT:
remove_interupt_event();
wrapped_exception_general();
break;
case SI_INT:
remove_interupt_event();
si_end_of_dma_event(&g_dev.si);
break;
case PI_INT:
remove_interupt_event();
pi_end_of_dma_event(&g_dev.pi);
break;
case AI_INT:
remove_interupt_event();
ai_end_of_dma_event(&g_dev.ai);
break;
case SP_INT:
remove_interupt_event();
rsp_interrupt_event(&g_dev.sp);
break;
case DP_INT:
remove_interupt_event();
rdp_interrupt_event(&g_dev.dp);
break;
case HW2_INT:
hw2_int_handler();
break;
case NMI_INT:
nmi_int_handler();
break;
default:
DebugMessage(M64MSG_ERROR, "Unknown interrupt queue event type %.8X.", q.first->data.type);
remove_interupt_event();
wrapped_exception_general();
break;
}
if (!interupt_unsafe_state)
{
if (savestates_get_job() == savestates_job_save)
{
savestates_save();
return;
}
}
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
Lock();
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
// init sdl & gl
DebugMessage(M64MSG_VERBOSE, "Initializing video subsystem...");
if (CoreVideo_Init() != M64ERR_SUCCESS)
return false;
/* hard-coded attribute values */
const int iDOUBLEBUFFER = 1;
/* set opengl attributes */
CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, iDOUBLEBUFFER);
CoreVideo_GL_SetAttribute(M64P_GL_SWAP_CONTROL, bVerticalSync);
CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, colorBufferDepth);
CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, depthBufferDepth);
/* set multisampling */
if (options.multiSampling > 0)
{
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLEBUFFERS, 1);
if (options.multiSampling <= 2)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 2);
else if (options.multiSampling <= 4)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 4);
else if (options.multiSampling <= 8)
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 8);
else
CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 16);
}
/* Set the video mode */
m64p_video_mode ScreenMode = bWindowed ? M64VIDEO_WINDOWED : M64VIDEO_FULLSCREEN;
m64p_video_flags flags = M64VIDEOFLAG_SUPPORT_RESIZING;
if (CoreVideo_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, ScreenMode, flags) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Failed to set %i-bit video mode: %ix%i", colorBufferDepth, (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
CoreVideo_Quit();
return false;
}
/* check that our opengl attributes were properly set */
int iActual;
if (CoreVideo_GL_GetAttribute(M64P_GL_DOUBLEBUFFER, &iActual) == M64ERR_SUCCESS)
if (iActual != iDOUBLEBUFFER)
DebugMessage(M64MSG_WARNING, "Failed to set GL_DOUBLEBUFFER to %i. (it's %i)", iDOUBLEBUFFER, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_SWAP_CONTROL, &iActual) == M64ERR_SUCCESS)
if (iActual != bVerticalSync)
DebugMessage(M64MSG_WARNING, "Failed to set GL_SWAP_CONTROL to %i. (it's %i)", bVerticalSync, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_BUFFER_SIZE, &iActual) == M64ERR_SUCCESS)
if (iActual != colorBufferDepth)
DebugMessage(M64MSG_WARNING, "Failed to set GL_BUFFER_SIZE to %i. (it's %i)", colorBufferDepth, iActual);
if (CoreVideo_GL_GetAttribute(M64P_GL_DEPTH_SIZE, &iActual) == M64ERR_SUCCESS)
if (iActual != depthBufferDepth)
DebugMessage(M64MSG_WARNING, "Failed to set GL_DEPTH_SIZE to %i. (it's %i)", depthBufferDepth, iActual);
#ifndef USE_GLES
/* Get function pointers to OpenGL extensions (blame Microsoft Windows for this) */
OGLExtensions_Init();
#endif
char caption[500];
sprintf(caption, "%s v%i.%i.%i", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
CoreVideo_SetCaption(caption);
SetWindowMode();
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
return true;
}
static int ProcessIcmpUnreach(Packet *p)
{
/* Handle ICMP unreachable */
SessionKey skey;
Stream5LWSession *ssn = NULL;
uint16_t sport;
uint16_t dport;
#ifdef SUP_IP6
sfip_t *src;
sfip_t *dst;
#endif
/* No "orig" IP Header */
if (!p->orig_iph)
return 0;
/* Get TCP/UDP/ICMP session from original protocol/port info
* embedded in the ICMP Unreach message. This is already decoded
* in p->orig_foo. TCP/UDP ports are decoded as p->orig_sp/dp.
*/
skey.protocol = GET_ORIG_IPH_PROTO(p);
sport = p->orig_sp;
dport = p->orig_dp;
#ifdef SUP_IP6
src = GET_ORIG_SRC(p);
dst = GET_ORIG_DST(p);
if (sfip_fast_lt6(src, dst))
{
COPY4(skey.ip_l, src->ip32);
skey.port_l = sport;
COPY4(skey.ip_h, dst->ip32);
skey.port_h = dport;
}
else if (IP_EQUALITY(GET_ORIG_SRC(p), GET_ORIG_DST(p)))
{
COPY4(skey.ip_l, src->ip32);
COPY4(skey.ip_h, skey.ip_l);
if (sport < dport)
{
skey.port_l = sport;
skey.port_h = dport;
}
else
{
skey.port_l = dport;
skey.port_h = sport;
}
}
#else
if (p->orig_iph->ip_src.s_addr < p->orig_iph->ip_dst.s_addr)
{
skey.ip_l = p->orig_iph->ip_src.s_addr;
skey.port_l = sport;
skey.ip_h = p->orig_iph->ip_dst.s_addr;
skey.port_h = dport;
}
else if (p->orig_iph->ip_dst.s_addr == p->orig_iph->ip_src.s_addr)
{
skey.ip_l = p->orig_iph->ip_src.s_addr;
skey.ip_h = skey.ip_l;
if (sport < dport)
{
skey.port_l = sport;
skey.port_h = dport;
}
else
{
skey.port_l = dport;
skey.port_h = sport;
}
}
#endif
else
{
#ifdef SUP_IP6
COPY4(skey.ip_l, dst->ip32);
COPY4(skey.ip_h, src->ip32);
#else
skey.ip_l = p->orig_iph->ip_dst.s_addr;
skey.ip_h = p->orig_iph->ip_src.s_addr;
#endif
skey.port_l = dport;
skey.port_h = sport;
}
if (p->vh)
skey.vlan_tag = (uint16_t)VTH_VLAN(p->vh);
else
skey.vlan_tag = 0;
switch (skey.protocol)
{
case IPPROTO_TCP:
/* Lookup a TCP session */
ssn = GetLWTcpSession(&skey);
break;
case IPPROTO_UDP:
/* Lookup a UDP session */
ssn = GetLWUdpSession(&skey);
break;
case IPPROTO_ICMP:
/* Lookup a ICMP session */
ssn = GetLWSessionFromKey(icmp_lws_cache, &skey);
break;
}
if (ssn)
{
/* Mark this session as dead. */
DEBUG_WRAP(DebugMessage(DEBUG_STREAM_STATE,
"Marking session as dead, per ICMP Unreachable!\n"););
ssn->session_flags |= SSNFLAG_DROP_CLIENT;
ssn->session_flags |= SSNFLAG_DROP_SERVER;
ssn->session_state |= STREAM5_STATE_UNREACH;
}
static int try_fast_audio_dispatching(void)
{
/* identify audio ucode by using the content of ucode_data */
uint32_t ucode_data = *dmem_u32(TASK_UCODE_DATA);
uint32_t v;
if (*dram_u32(ucode_data) == 0x00000001) {
if (*dram_u32(ucode_data + 0x30) == 0xf0000f00) {
v = *dram_u32(ucode_data + 0x28);
switch(v)
{
case 0x1e24138c: /* audio ABI (most common) */
alist_process_audio(); return 1;
case 0x1dc8138c: /* GoldenEye */
alist_process_audio_ge(); return 1;
case 0x1e3c1390: /* BlastCorp, DiddyKongRacing */
alist_process_audio_bc(); return 1;
default:
DebugMessage(M64MSG_WARNING, "ABI1 identification regression: v=%08x", v);
}
} else {
v = *dram_u32(ucode_data + 0x10);
switch(v)
{
case 0x11181350: /* MarioKart, WaveRace (E) */
alist_process_mk(); return 1;
case 0x111812e0: /* StarFox (J) */
alist_process_sfj(); return 1;
case 0x110412ac: /* WaveRace (J RevB) */
alist_process_wrjb(); return 1;
case 0x110412cc: /* StarFox/LylatWars (except J) */
alist_process_sf(); return 1;
case 0x1cd01250: /* FZeroX */
alist_process_fz(); return 1;
case 0x1f08122c: /* YoshisStory */
alist_process_ys(); return 1;
case 0x1f38122c: /* 1080° Snowboarding */
alist_process_1080(); return 1;
case 0x1f681230: /* Zelda OoT / Zelda MM (J, J RevA) */
alist_process_oot(); return 1;
case 0x1f801250: /* Zelda MM (except J, J RevA, E Beta), PokemonStadium 2 */
alist_process_mm(); return 1;
case 0x109411f8: /* Zelda MM (E Beta) */
alist_process_mmb(); return 1;
case 0x1eac11b8: /* AnimalCrossing */
alist_process_ac(); return 1;
case 0x00010010: /* MusyX (IndianaJones, BattleForNaboo) */
musyx_task(); return 1;
default:
DebugMessage(M64MSG_WARNING, "ABI2 identification regression: v=%08x", v);
}
}
} else {
v = *dram_u32(ucode_data + 0x10);
switch(v)
{
case 0x00000001: /* MusyX:
RogueSquadron, ResidentEvil2, PolarisSnoCross,
TheWorldIsNotEnough, RugratsInParis, NBAShowTime,
HydroThunder, Tarzan, GauntletLegend, Rush2049 */
musyx_task(); return 1;
case 0x0000127c: /* naudio (many games) */
alist_process_naudio(); return 1;
case 0x00001280: /* BanjoKazooie */
alist_process_naudio_bk(); return 1;
case 0x1c58126c: /* DonkeyKong */
alist_process_naudio_dk(); return 1;
case 0x1ae8143c: /* BanjoTooie, JetForceGemini, MickeySpeedWayUSA, PerfectDark */
alist_process_naudio_mp3(); return 1;
case 0x1ab0140c: /* ConkerBadFurDay */
alist_process_naudio_cbfd(); return 1;
default:
DebugMessage(M64MSG_WARNING, "ABI3 identification regression: v=%08x", v);
}
}
return 0;
}
static void save_controller_config(int iCtrlIdx, const char *pccDeviceName)
{
m64p_handle pConfig;
char SectionName[32], Param[32], ParamString[128];
int j;
/* Delete the configuration section for this controller, so we can use SetDefaults and save the help comments also */
sprintf(SectionName, "Input-SDL-Control%i", iCtrlIdx + 1);
ConfigDeleteSection(SectionName);
/* Open the configuration section for this controller (create a new one) */
if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Couldn't open config section '%s'", SectionName);
return;
}
/* save the general controller parameters */
ConfigSetDefaultFloat(pConfig, "version", CONFIG_VERSION, "Mupen64Plus SDL Input Plugin config parameter version number. Please don't change");
ConfigSetDefaultBool(pConfig, "plugged", controller[iCtrlIdx].control->Present, "Specifies whether this controller is 'plugged in' to the simulated N64");
ConfigSetDefaultInt(pConfig, "plugin", controller[iCtrlIdx].control->Plugin, "Specifies which type of expansion pak is in the controller: 1=None, 2=Mem pak, 5=Rumble pak");
ConfigSetDefaultBool(pConfig, "mouse", controller[iCtrlIdx].mouse, "If True, then mouse buttons may be used with this controller");
ConfigSetDefaultInt(pConfig, "device", controller[iCtrlIdx].device, "Specifies which joystick is bound to this controller: -2=Keyboard/mouse, -1=Auto config, 0 or more= SDL Joystick number");
ConfigSetDefaultString(pConfig, "name", pccDeviceName, "SDL joystick name (name check disabled if this is empty string)");
sprintf(Param, "%.2f,%.2f", controller[iCtrlIdx].mouse_sens[0], controller[iCtrlIdx].mouse_sens[1]);
ConfigSetDefaultString(pConfig, "MouseSensitivity", Param, "Scaling factor for mouse movements. For X, Y axes.");
sprintf(Param, "%i,%i", controller[iCtrlIdx].axis_deadzone[0], controller[iCtrlIdx].axis_deadzone[1]);
ConfigSetDefaultString(pConfig, "AnalogDeadzone", Param, "The minimum absolute value of the SDL analog joystick axis to move the N64 controller axis value from 0. For X, Y axes.");
sprintf(Param, "%i,%i", controller[iCtrlIdx].axis_peak[0], controller[iCtrlIdx].axis_peak[1]);
ConfigSetDefaultString(pConfig, "AnalogPeak", Param, "An absolute value of the SDL joystick axis >= AnalogPeak will saturate the N64 controller axis value (at 80). For X, Y axes. For each axis, this must be greater than the corresponding AnalogDeadzone value");
/* save configuration for all the digital buttons */
for (j = 0; j < X_AXIS; j++ )
{
const char *Help;
int len = 0;
ParamString[0] = 0;
if (controller[iCtrlIdx].button[j].key > 0)
{
sprintf(Param, "key(%i) ", controller[iCtrlIdx].button[j].key);
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].button[j].button >= 0)
{
sprintf(Param, "button(%i) ", controller[iCtrlIdx].button[j].button);
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].button[j].axis >= 0)
{
if (controller[iCtrlIdx].button[j].axis_deadzone >= 0)
sprintf(Param, "axis(%i%c,%i) ", controller[iCtrlIdx].button[j].axis, (controller[iCtrlIdx].button[j].axis_dir == -1) ? '-' : '+',
controller[iCtrlIdx].button[j].axis_deadzone);
else
sprintf(Param, "axis(%i%c) ", controller[iCtrlIdx].button[j].axis, (controller[iCtrlIdx].button[j].axis_dir == -1) ? '-' : '+');
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].button[j].hat >= 0)
{
sprintf(Param, "hat(%i %s) ", controller[iCtrlIdx].button[j].hat, HAT_POS_NAME(controller[iCtrlIdx].button[j].hat_pos));
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].button[j].mouse >= 0)
{
sprintf(Param, "mouse(%i) ", controller[iCtrlIdx].button[j].mouse);
strcat(ParamString, Param);
}
if (j == 0)
Help = "Digital button configuration mappings";
else
Help = NULL;
/* if last character is a space, chop it off */
len = strlen(ParamString);
if (len > 0 && ParamString[len-1] == ' ')
ParamString[len-1] = 0;
ConfigSetDefaultString(pConfig, button_names[j], ParamString, Help);
}
/* save configuration for the 2 analog axes */
for (j = 0; j < 2; j++ )
{
const char *Help;
int len = 0;
ParamString[0] = 0;
if (controller[iCtrlIdx].axis[j].key_a > 0 && controller[iCtrlIdx].axis[j].key_b > 0)
{
sprintf(Param, "key(%i,%i) ", controller[iCtrlIdx].axis[j].key_a, controller[iCtrlIdx].axis[j].key_b);
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].axis[j].button_a >= 0 && controller[iCtrlIdx].axis[j].button_b >= 0)
{
sprintf(Param, "button(%i,%i) ", controller[iCtrlIdx].axis[j].button_a, controller[iCtrlIdx].axis[j].button_b);
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].axis[j].axis_a >= 0 && controller[iCtrlIdx].axis[j].axis_b >= 0)
{
sprintf(Param, "axis(%i%c,%i%c) ", controller[iCtrlIdx].axis[j].axis_a, (controller[iCtrlIdx].axis[j].axis_dir_a <= 0) ? '-' : '+',
controller[iCtrlIdx].axis[j].axis_b, (controller[iCtrlIdx].axis[j].axis_dir_b <= 0) ? '-' : '+' );
strcat(ParamString, Param);
}
if (controller[iCtrlIdx].axis[j].hat >= 0)
{
sprintf(Param, "hat(%i %s %s) ", controller[iCtrlIdx].axis[j].hat,
HAT_POS_NAME(controller[iCtrlIdx].axis[j].hat_pos_a),
HAT_POS_NAME(controller[iCtrlIdx].axis[j].hat_pos_b));
strcat(ParamString, Param);
}
if (j == 0)
Help = "Analog axis configuration mappings";
else
Help = NULL;
/* if last character is a space, chop it off */
len = strlen(ParamString);
if (len > 0 && ParamString[len-1] == ' ')
ParamString[len-1] = 0;
ConfigSetDefaultString(pConfig, button_names[X_AXIS + j], ParamString, Help);
}
}
void RSP_ProcessDList()
{
VI_UpdateSize();
OGL_UpdateScale();
TextureCache_ActivateNoise(2);
RSP.PC[0] = *(u32*)&DMEM[0x0FF0];
RSP.PCi = 0;
RSP.count = 0;
RSP.halt = FALSE;
RSP.busy = TRUE;
#ifdef __TRIBUFFER_OPT
__indexmap_clear();
#endif
gSP.matrix.stackSize = min( 32, *(u32*)&DMEM[0x0FE4] >> 6 );
gSP.matrix.modelViewi = 0;
gSP.changed |= CHANGED_MATRIX;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
gSP.matrix.modelView[0][i][j] = 0.0f;
gSP.matrix.modelView[0][0][0] = 1.0f;
gSP.matrix.modelView[0][1][1] = 1.0f;
gSP.matrix.modelView[0][2][2] = 1.0f;
gSP.matrix.modelView[0][3][3] = 1.0f;
u32 uc_start = *(u32*)&DMEM[0x0FD0];
u32 uc_dstart = *(u32*)&DMEM[0x0FD8];
u32 uc_dsize = *(u32*)&DMEM[0x0FDC];
if ((uc_start != RSP.uc_start) || (uc_dstart != RSP.uc_dstart))
gSPLoadUcodeEx( uc_start, uc_dstart, uc_dsize );
gDPSetAlphaCompare(G_AC_NONE);
gDPSetDepthSource(G_ZS_PIXEL);
gDPSetRenderMode(0, 0);
gDPSetAlphaDither(G_AD_DISABLE);
gDPSetColorDither(G_CD_DISABLE);
gDPSetCombineKey(G_CK_NONE);
gDPSetTextureConvert(G_TC_FILT);
gDPSetTextureFilter(G_TF_POINT);
gDPSetTextureLUT(G_TT_NONE);
gDPSetTextureLOD(G_TL_TILE);
gDPSetTextureDetail(G_TD_CLAMP);
gDPSetTexturePersp(G_TP_PERSP);
gDPSetCycleType(G_CYC_1CYCLE);
gDPPipelineMode(G_PM_NPRIMITIVE);
#ifdef PRINT_DISPLAYLIST
if ((RSP.DList%PRINT_DISPLAYLIST_NUM) == 0) DebugMessage(M64MSG_VERBOSE, "BEGIN DISPLAY LIST %i \n", RSP.DList);
#endif
while (!RSP.halt)
{
u32 pc = RSP.PC[RSP.PCi];
if ((pc + 8) > RDRAMSize)
{
#ifdef DEBUG
DebugMsg( DEBUG_LOW | DEBUG_ERROR, "ATTEMPTING TO EXECUTE RSP COMMAND AT INVALID RDRAM LOCATION\n" );
#endif
break;
}
u32 w0 = *(u32*)&RDRAM[pc];
u32 w1 = *(u32*)&RDRAM[pc+4];
RSP.nextCmd = _SHIFTR( *(u32*)&RDRAM[pc+8], 24, 8 );
RSP.cmd = _SHIFTR( w0, 24, 8 );
RSP.PC[RSP.PCi] += 8;
#ifdef PROFILE_GBI
GBI_ProfileBegin(RSP.cmd);
#endif
#ifdef PRINT_DISPLAYLIST
if ((RSP.DList%PRINT_DISPLAYLIST_NUM) == 0) DebugMessage(M64MSG_VERBOSE, "%s: w0=0x%x w1=0x%x\n", GBI_GetFuncName(GBI.current->type, RSP.cmd), w0, w1);
#endif
GBI.cmd[RSP.cmd]( w0, w1 );
#ifdef PROFILE_GBI
GBI_ProfileEnd(RSP.cmd);
#endif
}
#ifdef PRINT_DISPLAYLIST
if ((RSP.DList%PRINT_DISPLAYLIST_NUM) == 0) DebugMessage(M64MSG_VERBOSE, "END DISPLAY LIST %i \n", RSP.DList);
#endif
RSP.busy = FALSE;
RSP.DList++;
gSP.changed |= CHANGED_COLORBUFFER;
}
static m64p_error plugin_connect_gfx(m64p_dynlib_handle plugin_handle)
{
/* attach the Video plugin function pointers */
if (plugin_handle != NULL)
{
m64p_plugin_type PluginType;
int PluginVersion, APIVersion;
if (l_GfxAttached)
return M64ERR_INVALID_STATE;
/* set function pointers for required functions */
if (!GET_FUNC(ptr_PluginGetVersion, gfx.getVersion, "PluginGetVersion") ||
!GET_FUNC(ptr_ChangeWindow, gfx.changeWindow, "ChangeWindow") ||
!GET_FUNC(ptr_InitiateGFX, gfx.initiateGFX, "InitiateGFX") ||
!GET_FUNC(ptr_MoveScreen, gfx.moveScreen, "MoveScreen") ||
!GET_FUNC(ptr_ProcessDList, gfx.processDList, "ProcessDList") ||
!GET_FUNC(ptr_ProcessRDPList, gfx.processRDPList, "ProcessRDPList") ||
!GET_FUNC(ptr_RomClosed, gfx.romClosed, "RomClosed") ||
!GET_FUNC(ptr_RomOpen, gfx.romOpen, "RomOpen") ||
!GET_FUNC(ptr_ShowCFB, gfx.showCFB, "ShowCFB") ||
!GET_FUNC(ptr_UpdateScreen, gfx.updateScreen, "UpdateScreen") ||
!GET_FUNC(ptr_ViStatusChanged, gfx.viStatusChanged, "ViStatusChanged") ||
!GET_FUNC(ptr_ViWidthChanged, gfx.viWidthChanged, "ViWidthChanged") ||
!GET_FUNC(ptr_ReadScreen2, gfx.readScreen, "ReadScreen2") ||
!GET_FUNC(ptr_SetRenderingCallback, gfx.setRenderingCallback, "SetRenderingCallback") ||
!GET_FUNC(ptr_FBRead, gfx.fBRead, "FBRead") ||
!GET_FUNC(ptr_FBWrite, gfx.fBWrite, "FBWrite") ||
!GET_FUNC(ptr_FBGetFrameBufferInfo, gfx.fBGetFrameBufferInfo, "FBGetFrameBufferInfo"))
{
DebugMessage(M64MSG_ERROR, "broken Video plugin; function(s) not found.");
plugin_disconnect_gfx();
return M64ERR_INPUT_INVALID;
}
/* set function pointers for optional functions */
gfx.resizeVideoOutput = (ptr_ResizeVideoOutput) osal_dynlib_getproc(plugin_handle, "ResizeVideoOutput");
/* check the version info */
(*gfx.getVersion)(&PluginType, &PluginVersion, &APIVersion, NULL, NULL);
if (PluginType != M64PLUGIN_GFX || (APIVersion & 0xffff0000) != (GFX_API_VERSION & 0xffff0000))
{
DebugMessage(M64MSG_ERROR, "incompatible Video plugin");
plugin_disconnect_gfx();
return M64ERR_INCOMPATIBLE;
}
/* handle backwards-compatibility */
if (APIVersion < 0x020100)
{
DebugMessage(M64MSG_WARNING, "Fallback for Video plugin API (%02i.%02i.%02i) < 2.1.0. Screenshots may contain On Screen Display text", VERSION_PRINTF_SPLIT(APIVersion));
// tell the video plugin to make its rendering callback to me (it's old, and doesn't have the bScreenRedrawn flag)
gfx.setRenderingCallback(backcompat_videoRenderCallback);
l_old1SetRenderingCallback = gfx.setRenderingCallback; // save this just for future use
gfx.setRenderingCallback = (ptr_SetRenderingCallback) backcompat_setRenderCallbackIntercept;
}
if (APIVersion < 0x20200 || gfx.resizeVideoOutput == NULL)
{
DebugMessage(M64MSG_WARNING, "Fallback for Video plugin API (%02i.%02i.%02i) < 2.2.0. Resizable video will not work", VERSION_PRINTF_SPLIT(APIVersion));
gfx.resizeVideoOutput = dummyvideo_ResizeVideoOutput;
}
l_GfxAttached = 1;
}
else
plugin_disconnect_gfx();
return M64ERR_SUCCESS;
}
IOReturn AREngine::clipOutputSamples(const void* inMixBuffer, void* outTargetBuffer, UInt32 inFirstFrame, UInt32 inNumberFrames, const IOAudioStreamFormat* inFormat, IOAudioStream* /*inStream*/)
{
// figure out what sort of blit we need to do
if((inFormat->fSampleFormat == kIOAudioStreamSampleFormatLinearPCM) && inFormat->fIsMixable)
{
// it's mixable linear PCM, which means we will be calling a blitter, which works in samples not frames
Float32* theMixBuffer = (Float32*)inMixBuffer;
UInt32 theFirstSample = inFirstFrame * inFormat->fNumChannels;
UInt32 theNumberSamples = inNumberFrames * inFormat->fNumChannels;
if(inFormat->fNumericRepresentation == kIOAudioStreamNumericRepresentationSignedInt)
{
// it's some kind of signed integer, which we handle as some kind of even byte length
bool nativeEndianInts;
#if TARGET_RT_BIG_ENDIAN
nativeEndianInts = (inFormat->fByteOrder == kIOAudioStreamByteOrderBigEndian);
#else
nativeEndianInts = (inFormat->fByteOrder == kIOAudioStreamByteOrderLittleEndian);
#endif
switch(inFormat->fBitWidth)
{
case 8:
{
DebugMessage("AREngine::clipOutputSamples: can't handle signed integers with a bit width of 8 at the moment");
}
break;
case 16:
{
SInt16* theTargetBuffer = (SInt16*)outTargetBuffer;
if (nativeEndianInts)
Float32ToNativeInt16(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[theFirstSample]), theNumberSamples);
else
Float32ToSwapInt16(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[theFirstSample]), theNumberSamples);
}
break;
case 24:
{
UInt8* theTargetBuffer = (UInt8*)outTargetBuffer;
if (nativeEndianInts)
Float32ToNativeInt24(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[3*theFirstSample]), theNumberSamples);
else
Float32ToSwapInt24(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[3*theFirstSample]), theNumberSamples);
}
break;
case 32:
{
SInt32* theTargetBuffer = (SInt32*)outTargetBuffer;
if (nativeEndianInts)
Float32ToNativeInt32(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[theFirstSample]), theNumberSamples);
else
Float32ToSwapInt32(mHasVectorUnit, &(theMixBuffer[theFirstSample]), &(theTargetBuffer[theFirstSample]), theNumberSamples);
}
break;
default:
DebugMessageN1("AREngine::clipOutputSamples: can't handle signed integers with a bit width of %d", inFormat->fBitWidth);
break;
}
}
else if(inFormat->fNumericRepresentation == kIOAudioStreamNumericRepresentationIEEE754Float)
{
// it is some kind of floating point format
#if TARGET_RT_BIG_ENDIAN
if((inFormat->fBitWidth == 32) && (inFormat->fBitDepth == 32) && (inFormat->fByteOrder == kIOAudioStreamByteOrderBigEndian))
#else
if((inFormat->fBitWidth == 32) && (inFormat->fBitDepth == 32) && (inFormat->fByteOrder == kIOAudioStreamByteOrderLittleEndian))
#endif
{
// it's Float32, so we are just going to copy the data
Float32* theTargetBuffer = (Float32*)outTargetBuffer;
memcpy(&(theTargetBuffer[theFirstSample]), &(theMixBuffer[theFirstSample]), theNumberSamples * sizeof(Float32));
}
else
{
DebugMessageN2("AREngine::clipOutputSamples: can't handle floats with a bit width of %d, bit depth of %d, and/or the given byte order", inFormat->fBitWidth, inFormat->fBitDepth);
}
}
}
else
{
// it's not linear PCM or it's not mixable, so just copy the data into the target buffer
SInt8* theMixBuffer = (SInt8*)inMixBuffer;
SInt8* theTargetBuffer = (SInt8*)outTargetBuffer;
UInt32 theFirstByte = inFirstFrame * (inFormat->fBitWidth / 8) * inFormat->fNumChannels;
UInt32 theNumberBytes = inNumberFrames * (inFormat->fBitWidth / 8) * inFormat->fNumChannels;
memcpy(&(theTargetBuffer[theFirstByte]), &(theMixBuffer[theFirstByte]), theNumberBytes);
}
return kIOReturnSuccess;
}
/*
* Load file list signature file
*
* Arguments:
* filename: file name string
* FileSigInfo *: The file signature information.
* FileInspectConf *: The configuration to be update.
*
* Returns:
* None
*/
static void file_config_signature(char *filename, FileSigInfo *sig_info,
FileInspectConf *config)
{
FILE *fp = NULL;
char linebuf[MAX_SIG_LINE_LENGTH];
char full_path_filename[PATH_MAX+1];
int line_number = 0;
/* check table first, create one if not exist*/
if (config->sig_table == NULL)
{
config->sig_table = sha_table_new(SHA256_HASH_SIZE);
}
if (config->sig_table == NULL)
{
FILE_FATAL_ERROR("%s(%d) Could not create file signature hash.\n",
*(_dpd.config_file), *(_dpd.config_line));
}
/* parse the file line by line, each signature one entry*/
_dpd.logMsg("File inspect: processing file %s\n", filename);
UpdatePathToFile(full_path_filename, PATH_MAX, filename);
if((fp = fopen(full_path_filename, "r")) == NULL)
{
char errBuf[STD_BUF];
#ifdef WIN32
snprintf(errBuf, STD_BUF, "%s", strerror(errno));
#else
strerror_r(errno, errBuf, STD_BUF);
#endif
errBuf[STD_BUF-1] = '\0';
FILE_FATAL_ERROR("%s(%d) => Unable to open signature file %s, "
"Error: %s\n",
*(_dpd.config_file), *(_dpd.config_line), filename, errBuf);
return;
}
while( fgets(linebuf, MAX_SIG_LINE_LENGTH, fp) )
{
char *cmt = NULL;
char *sha256;
FileSigInfo *old_info;
DEBUG_WRAP(DebugMessage(DEBUG_FILE, "File signatures: %s\n",linebuf ););
line_number++;
/* Remove comments */
if( (cmt = strchr(linebuf, '#')) )
*cmt = '\0';
/* Remove newline as well, prevent double newline in logging.*/
if( (cmt = strchr(linebuf, '\n')) )
*cmt = '\0';
if (!strlen(linebuf))
continue;
sha256 = malloc(SHA256_HASH_SIZE);
if (!sha256)
{
FILE_FATAL_ERROR("%s(%d) => No memory for file: %s (%d), \n"
"signature: %s\n",
*(_dpd.config_file), *(_dpd.config_line),
filename, line_number, linebuf);
}
if (str_to_sha(linebuf, sha256, strlen(linebuf)) < 0)
{
FILE_FATAL_ERROR("%s(%d) => signature format at file: %s (%d), \n"
"signature: %s\n",
*(_dpd.config_file), *(_dpd.config_line),
filename, line_number, linebuf);
}
old_info = (FileSigInfo *)sha_table_find(config->sig_table, sha256);
if (old_info)
{
free(sha256);
_dpd.errMsg("%s(%d) => signature redefined at file: %s (%d), \n"
"signature: %s\n",
*(_dpd.config_file), *(_dpd.config_line),
filename, line_number, linebuf);
}
else
{
sha_table_add(config->sig_table, sha256, sig_info);
}
}
int main(int argc,char** argv)
{
DebugBlockTracer tracer("main");
if (argc < 3)
{
ErrorMessage("Need two args\n");
return 1;
}
DebugMessage("Creating JVM\n");
char** classPath = JVMBRIDGEFUNC(PlatformSplitClassPaths)(argv[1]);
JavaVM* vm = JVMBRIDGEFUNC(CreateJavaVM)(classPath);
JVMBRIDGEFUNC(DeletePathArray)(classPath);
DebugShowPointer(vm,"VM");
DebugMessage("Attaching Thread\n");
JNIEnv* env = JVMBRIDGEFUNC(AttachCurrentThread)(vm);
JVMBRIDGEFUNC(FindClass)(env,"java/lang/Object");
jobject stringClass = JVMBRIDGEFUNC(FindClass)(env,"java/lang/String");
if (stringClass == 0)
{
ErrorMessage("FindClass for java/lang/String failed.\n", argv[2]);
return 1;
}
if (JVMBRIDGEFUNC(FindClass)(env,"org/semantic/jvmbridge/ExecuteFunction") == 0)
{
ErrorMessage("FindClass for org/semantic/jvmbridge/ExecuteFunction failed.\n", argv[2]);
return 1;
}
jobject appClass = JVMBRIDGEFUNC(FindClass)(env,argv[2]);
if (appClass == 0)
{
ErrorMessage("FindClass for %s failed.\n", argv[2]);
return 1;
}
{
jmethodID mainMethod = JVMBRIDGEFUNC(GetStaticMethodID) (env,appClass,"main","([Ljava/lang/String;)V");
jobject stringArray = JVMBRIDGEFUNC(NewObjectArray)(env,0,stringClass,0);
jvaluelist vlist = JVMBRIDGEFUNC(CreateValueList)();
JVMBRIDGEFUNC(AddObjectToValueList)(vlist,stringArray);
JVMBRIDGEFUNC(CallStaticVoidMethodVL)(env,appClass,mainMethod,vlist);
}
JVMBRIDGEFUNC(StartExecuteFunction)(env,&NullFree);
{
jmethodID fooMethod = JVMBRIDGEFUNC(GetStaticMethodID) (env,appClass,"foo","(" SigOpaqueAddress "S)V");
jvaluelist vlist = JVMBRIDGEFUNC(CreateValueList)();
#if ARCH_64BIT
JVMBRIDGEFUNC(AddLongToValueList)
#else
JVMBRIDGEFUNC(AddIntToValueList)
#endif
(vlist,reinterpret_cast<COpaqueAddress>(&CallbackFunction));
JVMBRIDGEFUNC(AddShortToValueList)(vlist,37);
JVMBRIDGEFUNC(CallStaticVoidMethodVL)(env,appClass,fooMethod,vlist);
}
JVMBRIDGEFUNC(DetachCurrentThread)(vm);
return 0;
}
int main(int argc, char *argv[])
{
int i;
printf(" __ __ __ _ _ ____ _ \n");
printf("| \\/ |_ _ _ __ ___ _ __ / /_ | || | | _ \\| |_ _ ___ \n");
printf("| |\\/| | | | | '_ \\ / _ \\ '_ \\| '_ \\| || |_| |_) | | | | / __| \n");
printf("| | | | |_| | |_) | __/ | | | (_) |__ _| __/| | |_| \\__ \\ \n");
printf("|_| |_|\\__,_| .__/ \\___|_| |_|\\___/ |_| |_| |_|\\__,_|___/ \n");
printf(" |_| https://mupen64plus.org/ \n");
printf("%s Version %i.%i.%i\n\n", CONSOLE_UI_NAME, VERSION_PRINTF_SPLIT(CONSOLE_UI_VERSION));
/* bootstrap some special parameters from the command line */
if (ParseCommandLineInitial(argc, (const char **) argv) != 0)
return 1;
/* load the Mupen64Plus core library */
if (AttachCoreLib(l_CoreLibPath) != M64ERR_SUCCESS)
return 2;
/* start the Mupen64Plus core library, load the configuration file */
m64p_error rval = (*CoreStartup)(CORE_API_VERSION, l_ConfigDirPath, l_DataDirPath, "Core", DebugCallback, NULL, CALLBACK_FUNC);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "couldn't start Mupen64Plus core library.");
DetachCoreLib();
return 3;
}
#ifdef VIDEXT_HEADER
rval = CoreOverrideVidExt(&vidExtFunctions);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "couldn't start VidExt library.");
DetachCoreLib();
return 14;
}
#endif
/* Open configuration sections */
rval = OpenConfigurationHandles();
if (rval != M64ERR_SUCCESS)
{
(*CoreShutdown)();
DetachCoreLib();
return 4;
}
/* parse command-line options */
rval = ParseCommandLineFinal(argc, (const char **) argv);
if (rval != M64ERR_SUCCESS)
{
(*CoreShutdown)();
DetachCoreLib();
return 5;
}
/* Ensure that the core supports comparison feature if necessary */
if (l_CoreCompareMode != 0 && !(g_CoreCapabilities & M64CAPS_CORE_COMPARE))
{
DebugMessage(M64MSG_ERROR, "can't use --core-compare feature with this Mupen64Plus core library.");
DetachCoreLib();
return 6;
}
compare_core_init(l_CoreCompareMode);
/* Ensure that the core supports the debugger if necessary */
if (l_LaunchDebugger && !(g_CoreCapabilities & M64CAPS_DEBUGGER))
{
DebugMessage(M64MSG_ERROR, "can't use --debug feature with this Mupen64Plus core library.");
DetachCoreLib();
return 6;
}
/* save the given command-line options in configuration file if requested */
if (l_SaveOptions)
SaveConfigurationOptions();
/* load ROM image */
FILE *fPtr = fopen(l_ROMFilepath, "rb");
if (fPtr == NULL)
{
DebugMessage(M64MSG_ERROR, "couldn't open ROM file '%s' for reading.", l_ROMFilepath);
(*CoreShutdown)();
DetachCoreLib();
return 7;
}
/* get the length of the ROM, allocate memory buffer, load it from disk */
long romlength = 0;
fseek(fPtr, 0L, SEEK_END);
romlength = ftell(fPtr);
fseek(fPtr, 0L, SEEK_SET);
unsigned char *ROM_buffer = (unsigned char *) malloc(romlength);
if (ROM_buffer == NULL)
{
DebugMessage(M64MSG_ERROR, "couldn't allocate %li-byte buffer for ROM image file '%s'.", romlength, l_ROMFilepath);
fclose(fPtr);
(*CoreShutdown)();
DetachCoreLib();
return 8;
}
else if (fread(ROM_buffer, 1, romlength, fPtr) != romlength)
{
DebugMessage(M64MSG_ERROR, "couldn't read %li bytes from ROM image file '%s'.", romlength, l_ROMFilepath);
free(ROM_buffer);
fclose(fPtr);
(*CoreShutdown)();
DetachCoreLib();
return 9;
}
fclose(fPtr);
/* Try to load the ROM image into the core */
if ((*CoreDoCommand)(M64CMD_ROM_OPEN, (int) romlength, ROM_buffer) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "core failed to open ROM image file '%s'.", l_ROMFilepath);
free(ROM_buffer);
(*CoreShutdown)();
DetachCoreLib();
return 10;
}
free(ROM_buffer); /* the core copies the ROM image, so we can release this buffer immediately */
/* handle the cheat codes */
CheatStart(l_CheatMode, l_CheatNumList);
if (l_CheatMode == CHEAT_SHOW_LIST)
{
(*CoreDoCommand)(M64CMD_ROM_CLOSE, 0, NULL);
(*CoreShutdown)();
DetachCoreLib();
return 11;
}
/* search for and load plugins */
rval = PluginSearchLoad(l_ConfigUI);
if (rval != M64ERR_SUCCESS)
{
(*CoreDoCommand)(M64CMD_ROM_CLOSE, 0, NULL);
(*CoreShutdown)();
DetachCoreLib();
return 12;
}
/* attach plugins to core */
for (i = 0; i < 4; i++)
{
if ((*CoreAttachPlugin)(g_PluginMap[i].type, g_PluginMap[i].handle) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "core error while attaching %s plugin.", g_PluginMap[i].name);
(*CoreDoCommand)(M64CMD_ROM_CLOSE, 0, NULL);
(*CoreShutdown)();
DetachCoreLib();
return 13;
}
}
/* set up Frame Callback if --testshots is enabled */
if (l_TestShotList != NULL)
{
if ((*CoreDoCommand)(M64CMD_SET_FRAME_CALLBACK, 0, FrameCallback) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "couldn't set frame callback, --testshots will not work.");
}
}
/* set gb cart loader */
if ((*CoreDoCommand)(M64CMD_SET_MEDIA_LOADER, sizeof(l_media_loader), &l_media_loader) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "Couldn't set media loader, transferpak and GB carts will not work.");
}
/* load savestate at startup */
if (l_SaveStatePath != NULL)
{
if ((*CoreDoCommand)(M64CMD_STATE_LOAD, 0, (void *) l_SaveStatePath) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "couldn't load state, rom will run normally.");
}
}
/* Setup debugger */
if (l_LaunchDebugger)
{
if (debugger_setup_callbacks())
{
DebugMessage(M64MSG_ERROR, "couldn't setup debugger callbacks.");
(*CoreDoCommand)(M64CMD_ROM_CLOSE, 0, NULL);
(*CoreShutdown)();
DetachCoreLib();
return 14;
}
/* Set Core config parameter to enable debugger */
int bEnableDebugger = 1;
(*ConfigSetParameter)(l_ConfigCore, "EnableDebugger", M64TYPE_BOOL, &bEnableDebugger);
/* Fork the debugger input thread. */
#if SDL_VERSION_ATLEAST(2,0,0)
SDL_CreateThread(debugger_loop, "DebugLoop", NULL);
#else
SDL_CreateThread(debugger_loop, NULL);
#endif
}
/* run the game */
(*CoreDoCommand)(M64CMD_EXECUTE, 0, NULL);
/* detach plugins from core and unload them */
for (i = 0; i < 4; i++)
(*CoreDetachPlugin)(g_PluginMap[i].type);
PluginUnload();
/* close the ROM image */
(*CoreDoCommand)(M64CMD_ROM_CLOSE, 0, NULL);
/* save the configuration file again if --nosaveoptions was not specified, to keep any updated parameters from the core/plugins */
if (l_SaveOptions)
SaveConfigurationOptions();
/* Shut down and release the Core library */
(*CoreShutdown)();
DetachCoreLib();
/* free allocated memory */
if (l_TestShotList != NULL)
free(l_TestShotList);
return 0;
}
static m64p_error ParseCommandLineFinal(int argc, const char **argv)
{
int i;
/* parse commandline options */
for (i = 1; i < argc; i++)
{
int ArgsLeft = argc - i - 1;
if (strcmp(argv[i], "--noosd") == 0)
{
int Osd = 0;
(*ConfigSetParameter)(l_ConfigCore, "OnScreenDisplay", M64TYPE_BOOL, &Osd);
}
else if (strcmp(argv[i], "--osd") == 0)
{
int Osd = 1;
(*ConfigSetParameter)(l_ConfigCore, "OnScreenDisplay", M64TYPE_BOOL, &Osd);
}
else if (strcmp(argv[i], "--fullscreen") == 0)
{
int Fullscreen = 1;
(*ConfigSetParameter)(l_ConfigVideo, "Fullscreen", M64TYPE_BOOL, &Fullscreen);
}
else if (strcmp(argv[i], "--windowed") == 0)
{
int Fullscreen = 0;
(*ConfigSetParameter)(l_ConfigVideo, "Fullscreen", M64TYPE_BOOL, &Fullscreen);
}
else if (strcmp(argv[i], "--nospeedlimit") == 0)
{
int EnableSpeedLimit = 0;
if (g_CoreAPIVersion < 0x020001)
DebugMessage(M64MSG_WARNING, "core library doesn't support --nospeedlimit");
else
{
if ((*CoreDoCommand)(M64CMD_CORE_STATE_SET, M64CORE_SPEED_LIMITER, &EnableSpeedLimit) != M64ERR_SUCCESS)
DebugMessage(M64MSG_ERROR, "core gave error while setting --nospeedlimit option");
}
}
else if ((strcmp(argv[i], "--corelib") == 0 || strcmp(argv[i], "--configdir") == 0 ||
strcmp(argv[i], "--datadir") == 0) && ArgsLeft >= 1)
{ /* these are handled in ParseCommandLineInitial */
i++;
}
else if (strcmp(argv[i], "--resolution") == 0 && ArgsLeft >= 1)
{
const char *res = argv[i+1];
int xres, yres;
i++;
if (sscanf(res, "%ix%i", &xres, &yres) != 2)
DebugMessage(M64MSG_WARNING, "couldn't parse resolution '%s'", res);
else
{
(*ConfigSetParameter)(l_ConfigVideo, "ScreenWidth", M64TYPE_INT, &xres);
(*ConfigSetParameter)(l_ConfigVideo, "ScreenHeight", M64TYPE_INT, &yres);
}
}
else if (strcmp(argv[i], "--cheats") == 0 && ArgsLeft >= 1)
{
if (strcmp(argv[i+1], "all") == 0)
l_CheatMode = CHEAT_ALL;
else if (strcmp(argv[i+1], "list") == 0)
l_CheatMode = CHEAT_SHOW_LIST;
else
{
l_CheatMode = CHEAT_LIST;
l_CheatNumList = (char*) argv[i+1];
}
i++;
}
else if (strcmp(argv[i], "--plugindir") == 0 && ArgsLeft >= 1)
{
g_PluginDir = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--sshotdir") == 0 && ArgsLeft >= 1)
{
(*ConfigSetParameter)(l_ConfigCore, "ScreenshotPath", M64TYPE_STRING, argv[i+1]);
i++;
}
else if (strcmp(argv[i], "--gfx") == 0 && ArgsLeft >= 1)
{
g_GfxPlugin = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--audio") == 0 && ArgsLeft >= 1)
{
g_AudioPlugin = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--input") == 0 && ArgsLeft >= 1)
{
g_InputPlugin = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--rsp") == 0 && ArgsLeft >= 1)
{
g_RspPlugin = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--emumode") == 0 && ArgsLeft >= 1)
{
int emumode = atoi(argv[i+1]);
i++;
if (emumode < 0 || emumode > 2)
{
DebugMessage(M64MSG_WARNING, "invalid --emumode value '%i'", emumode);
continue;
}
if (emumode == 2 && !(g_CoreCapabilities & M64CAPS_DYNAREC))
{
DebugMessage(M64MSG_WARNING, "Emulator core doesn't support Dynamic Recompiler.");
emumode = 1;
}
(*ConfigSetParameter)(l_ConfigCore, "R4300Emulator", M64TYPE_INT, &emumode);
}
else if (strcmp(argv[i], "--savestate") == 0 && ArgsLeft >= 1)
{
l_SaveStatePath = argv[i+1];
i++;
}
else if (strcmp(argv[i], "--testshots") == 0 && ArgsLeft >= 1)
{
l_TestShotList = ParseNumberList(argv[i+1], NULL);
i++;
}
else if (strcmp(argv[i], "--set") == 0 && ArgsLeft >= 1)
{
if (SetConfigParameter(argv[i+1]) != 0)
return M64ERR_INPUT_INVALID;
i++;
}
else if (strcmp(argv[i], "--debug") == 0)
{
l_LaunchDebugger = 1;
}
else if (strcmp(argv[i], "--core-compare-send") == 0)
{
l_CoreCompareMode = 1;
}
else if (strcmp(argv[i], "--core-compare-recv") == 0)
{
l_CoreCompareMode = 2;
}
else if (strcmp(argv[i], "--nosaveoptions") == 0)
{
l_SaveOptions = 0;
}
#define PARSE_GB_CART_PARAM(param, key) \
else if (strcmp(argv[i], param) == 0) \
{ \
ConfigSetParameter(l_ConfigTransferPak, key, M64TYPE_STRING, argv[i+1]); \
i++; \
}
PARSE_GB_CART_PARAM("--gb-rom-1", "GB-rom-1")
PARSE_GB_CART_PARAM("--gb-ram-1", "GB-ram-1")
PARSE_GB_CART_PARAM("--gb-rom-2", "GB-rom-2")
PARSE_GB_CART_PARAM("--gb-ram-2", "GB-ram-2")
PARSE_GB_CART_PARAM("--gb-rom-3", "GB-rom-3")
PARSE_GB_CART_PARAM("--gb-ram-3", "GB-ram-3")
PARSE_GB_CART_PARAM("--gb-rom-4", "GB-rom-4")
PARSE_GB_CART_PARAM("--gb-ram-4", "GB-ram-4")
#undef PARSE_GB_CART_PARAM
else if (strcmp(argv[i], "--dd-ipl-rom") == 0)
{
ConfigSetParameter(l_Config64DD, "IPL-ROM", M64TYPE_STRING, argv[i+1]);
i++;
}
else if (strcmp(argv[i], "--dd-disk") == 0)
{
ConfigSetParameter(l_Config64DD, "Disk", M64TYPE_STRING, argv[i+1]);
i++;
}
else if (ArgsLeft == 0)
{
/* this is the last arg, it should be a ROM filename */
l_ROMFilepath = argv[i];
return M64ERR_SUCCESS;
}
else if (strcmp(argv[i], "--verbose") == 0)
{
g_Verbose = 1;
}
else
{
DebugMessage(M64MSG_WARNING, "unrecognized command-line parameter '%s'", argv[i]);
}
/* continue argv loop */
}
/* missing ROM filepath */
DebugMessage(M64MSG_ERROR, "no ROM filepath given");
return M64ERR_INPUT_INVALID;
}
void passe2(precomp_instr *dest, int start, int end, precomp_block *block)
{
unsigned int i;
build_wrappers(dest, start, end, block);
/* First, fix up all the jumps. This involves a table lookup to find the offset into the block of x86_64 code for
* for start of a recompiled r4300i instruction corresponding to the given jump destination address in the N64
* address space. Next, the relative offset between this destination and the location of the jump instruction is
* computed and stored in memory, so that the jump will branch to the right place in the recompiled code.
*/
for (i = 0; i < jumps_number; i++)
{
precomp_instr *jump_instr = dest + ((jumps_table[i].mi_addr - dest[0].addr) / 4);
unsigned int jmp_offset_loc = jumps_table[i].pc_addr;
unsigned char *addr_dest = NULL;
/* calculate the destination address to jump to */
if (jump_instr->reg_cache_infos.need_map)
{
addr_dest = jump_instr->reg_cache_infos.jump_wrapper;
}
else
{
addr_dest = block->code + jump_instr->local_addr;
}
/* write either a 32-bit IP-relative offset or a 64-bit absolute address */
if (jumps_table[i].absolute64)
{
*((unsigned long long *) (block->code + jmp_offset_loc)) = (unsigned long long) addr_dest;
}
else
{
long jump_rel_offset = (long) (addr_dest - (block->code + jmp_offset_loc + 4));
*((int *) (block->code + jmp_offset_loc)) = (int) jump_rel_offset;
if (jump_rel_offset >= 0x7fffffffLL || jump_rel_offset < -0x80000000LL)
{
DebugMessage(M64MSG_ERROR, "assembler pass2 error: offset too big for relative jump from %p to %p",
(block->code + jmp_offset_loc + 4), addr_dest);
asm(" int $3; ");
}
}
}
/* Next, fix up all of the RIP-relative memory accesses. This is unique to the x86_64 architecture, because
* the 32-bit absolute displacement addressing mode is not available (and there's no 64-bit absolute displacement
* mode either).
*/
for (i = 0; i < riprel_number; i++)
{
unsigned char *rel_offset_ptr = block->code + riprel_table[i].pc_addr;
long rip_rel_offset = (long) (riprel_table[i].global_dst - (rel_offset_ptr + 4 + riprel_table[i].extra_bytes));
if (rip_rel_offset >= 0x7fffffffLL || rip_rel_offset < -0x80000000LL)
{
DebugMessage(M64MSG_ERROR, "assembler pass2 error: offset too big between mem target: %p and code position: %p",
riprel_table[i].global_dst, rel_offset_ptr);
asm(" int $3; ");
}
*((int *) rel_offset_ptr) = (int) rip_rel_offset;
}
}
bool COGLGraphicsContext::Initialize(uint32 dwWidth, uint32 dwHeight, BOOL bWindowed )
{
DebugMessage(M64MSG_INFO, "Initializing OpenGL Device Context.");
Lock();
CGraphicsContext::Get()->m_supportTextureMirror = false;
CGraphicsContext::Initialize(dwWidth, dwHeight, bWindowed );
if( bWindowed )
{
windowSetting.statusBarHeightToUse = windowSetting.statusBarHeight;
windowSetting.toolbarHeightToUse = windowSetting.toolbarHeight;
}
else
{
windowSetting.statusBarHeightToUse = 0;
windowSetting.toolbarHeightToUse = 0;
}
int depthBufferDepth = options.OpenglDepthBufferSetting;
int colorBufferDepth = 32;
int bVerticalSync = windowSetting.bVerticalSync;
if( options.colorQuality == TEXTURE_FMT_A4R4G4B4 ) colorBufferDepth = 16;
/* // init sdl & gl
DebugMessage(M64MSG_VERBOSE, "Initializing video subsystem...");
if (CoreVideo_Init() != M64ERR_SUCCESS)
return false;
*/
/* hard-coded attribute values */
const int iDOUBLEBUFFER = 1;
/* set opengl attributes */
// CoreVideo_GL_SetAttribute(M64P_GL_DOUBLEBUFFER, iDOUBLEBUFFER);
// CoreVideo_GL_SetAttribute(M64P_GL_SWAP_CONTROL, bVerticalSync);
// CoreVideo_GL_SetAttribute(M64P_GL_BUFFER_SIZE, colorBufferDepth);
// CoreVideo_GL_SetAttribute(M64P_GL_DEPTH_SIZE, depthBufferDepth);
//
// /* set multisampling */
// if (options.multiSampling > 0)
// {
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLEBUFFERS, 1);
// if (options.multiSampling <= 2)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 2);
// else if (options.multiSampling <= 4)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 4);
// else if (options.multiSampling <= 8)
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 8);
// else
// CoreVideo_GL_SetAttribute(M64P_GL_MULTISAMPLESAMPLES, 16);
// }
//
// /* Set the video mode */
// m64p_video_mode ScreenMode = bWindowed ? M64VIDEO_WINDOWED : M64VIDEO_FULLSCREEN;
// if (CoreVideo_SetVideoMode(windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, colorBufferDepth, ScreenMode) != M64ERR_SUCCESS)
// {
// DebugMessage(M64MSG_ERROR, "Failed to set %i-bit video mode: %ix%i", colorBufferDepth, (int)windowSetting.uDisplayWidth, (int)windowSetting.uDisplayHeight);
// CoreVideo_Quit();
// return false;
// }
//
//#ifdef WIN32
// GLenum err = glewInit();
// if (GLEW_OK != err)
// {
// /* Problem: glewInit failed, something is seriously wrong. */
// fprintf(stderr, "Error: %s\n", glewGetErrorString(err));
// }
//#endif
//
// char caption[500];
// sprintf(caption, "%s v%i.%i.%i", PLUGIN_NAME, VERSION_PRINTF_SPLIT(PLUGIN_VERSION));
// CoreVideo_SetCaption(caption);
// SetWindowMode();
/*
SDL_Surface* screen;
SDL_Init(SDL_INIT_VIDEO);
if (!(screen = SDL_SetVideoMode(1024, 768, 16, SDL_SWSURFACE )))
{
SDL_QuitSubSystem( SDL_INIT_VIDEO );
return FALSE;
}
EGLNativeWindowType EGL_handle;
EGLContext EGL_context;
HDC EGL_device;
EGLint EGL_version_major,EGL_version_minor;
EGLint nConfigs;
EGLConfig EGL_config;
GLint success;
const EGLint ConfigAttribs[] =
{
EGL_LEVEL, 0,
EGL_DEPTH_SIZE, 16,
EGL_STENCIL_SIZE, 0,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NATIVE_RENDERABLE, EGL_FALSE,
EGL_NONE
};
const EGLint ContextAttribs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
SDL_SysWMinfo info;
SDL_VERSION(&info.version);
SDL_GetWMInfo(&info);
EGL_handle = (EGLNativeWindowType) info.window;
EGL_device = GetDC(EGL_handle);
printf("EGL Context Creation\n");
EGL_display = eglGetDisplay((EGLNativeDisplayType) EGL_device);
if (EGL_display == EGL_NO_DISPLAY){
printf( "EGL Display Get failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglInitialize(EGL_display, &EGL_version_major, &EGL_version_minor)){
printf( "EGL Display Initialize failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglChooseConfig(EGL_display, ConfigAttribs, &EGL_config, 1, &nConfigs)){
printf( "EGL Configuration failed: %s \n", EGLErrorString());
return FALSE;
} else if (nConfigs != 1){
printf( "EGL Configuration failed: nconfig %i, %s \n", nConfigs, EGLErrorString());
return FALSE;
}
EGL_surface = eglCreateWindowSurface(EGL_display, EGL_config, EGL_handle, NULL);
if (EGL_surface == EGL_NO_SURFACE){
printf("EGL Surface Creation failed: %s will attempt without window... \n", EGLErrorString());
EGL_surface = eglCreateWindowSurface(EGL_display, EGL_config, NULL, NULL);
if (EGL_surface == EGL_NO_SURFACE){
printf( "EGL Surface Creation failed: %s \n", EGLErrorString());
return FALSE;
}
}
eglBindAPI(EGL_OPENGL_ES_API);
EGL_context = eglCreateContext(EGL_display, EGL_config, EGL_NO_CONTEXT, ContextAttribs);
if (EGL_context == EGL_NO_CONTEXT){
printf( "EGL Context Creation failed: %s \n", EGLErrorString());
return FALSE;
}
if (!eglMakeCurrent(EGL_display, EGL_surface, EGL_surface, EGL_context)){
printf( "EGL Make Current failed: %s \n", EGLErrorString());
return FALSE;
};
eglSwapInterval(EGL_display, 1);
*/
#ifdef USE_SDL
//// paulscode, added for switching between RGBA8888 and RGB565
// (part of the color banding fix)
int bitsPP;
if( Android_JNI_UseRGBA8888() )
bitsPP = 32;
else
bitsPP = 16;
/* Set the video mode */
SDL_Surface* hScreen;
printf( "Setting video mode %dx%d...\n", windowSetting.uDisplayWidth, windowSetting.uDisplayHeight );
// TODO: I should actually check what the pixelformat is, rather than assuming 16 bpp (RGB_565) or 32 bpp (RGBA_8888):
// if (!(hScreen = SDL_SetVideoMode( windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, 16, SDL_HWSURFACE )))
if (!(hScreen = SDL_SetVideoMode( windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, bitsPP, SDL_HWSURFACE )))
{
printf( "Problem setting videomode %dx%d: %s\n", windowSetting.uDisplayWidth, windowSetting.uDisplayHeight, SDL_GetError() );
SDL_QuitSubSystem( SDL_INIT_VIDEO );
return false;
}
#endif
InitState();
InitOGLExtension();
sprintf(m_strDeviceStats, "%.60s - %.128s : %.60s", m_pVendorStr, m_pRenderStr, m_pVersionStr);
TRACE0(m_strDeviceStats);
DebugMessage(M64MSG_INFO, "Using OpenGL: %s", m_strDeviceStats);
GLint precision,range;
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_LOW_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader lowp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_MEDIUM_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader mediump precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_VERTEX_SHADER,GL_HIGH_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Vertex Shader highp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER ,GL_LOW_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader lowp precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_MEDIUM_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader mediump precision:%i range:%i",precision,range);
glGetShaderPrecisionFormat(GL_FRAGMENT_SHADER,GL_HIGH_FLOAT,&precision,&range);
DebugMessage(M64MSG_INFO,"GLSL Fragment Shader highp precision:%i range:%i",precision,range);
Unlock();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER); // Clear buffers
UpdateFrame();
Clear(CLEAR_COLOR_AND_DEPTH_BUFFER);
UpdateFrame();
m_bReady = true;
status.isVertexShaderEnabled = false;
return true;
}
void ParseReference(Barnyard2Config *bc, char *args, SigNode *sn)
{
char **toks, *system, *id;
int num_toks;
DEBUG_WRAP(DebugMessage(DEBUG_MAPS_DEEP, "map: parsing reference %s\n", args););
EXPORT unsigned int CALL DoRspCycles(unsigned int Cycles)
{
OSTask_t *task = (OSTask_t*)(rsp.DMEM + 0xFC0);
unsigned int i, sum=0;
if( task->type == 1 && task->data_ptr != 0 && GraphicsHle) {
if (rsp.ProcessDlistList != NULL) {
rsp.ProcessDlistList();
}
*rsp.SP_STATUS_REG |= 0x0203;
if ((*rsp.SP_STATUS_REG & 0x40) != 0 ) {
*rsp.MI_INTR_REG |= 0x1;
rsp.CheckInterrupts();
}
*rsp.DPC_STATUS_REG &= ~0x0002;
return Cycles;
} else if (task->type == 2 && AudioHle) {
if (rsp.ProcessAlistList != NULL) {
rsp.ProcessAlistList();
}
*rsp.SP_STATUS_REG |= 0x0203;
if ((*rsp.SP_STATUS_REG & 0x40) != 0 ) {
*rsp.MI_INTR_REG |= 0x1;
rsp.CheckInterrupts();
}
return Cycles;
} else if (task->type == 7) {
rsp.ShowCFB();
}
*rsp.SP_STATUS_REG |= 0x203;
if ((*rsp.SP_STATUS_REG & 0x40) != 0 )
{
*rsp.MI_INTR_REG |= 0x1;
rsp.CheckInterrupts();
}
if (task->ucode_size <= 0x1000)
for (i=0; i<(task->ucode_size/2); i++)
sum += *(rsp.RDRAM + task->ucode + i);
else
for (i=0; i<(0x1000/2); i++)
sum += *(rsp.IMEM + i);
if (task->ucode_size > 0x1000)
{
switch(sum)
{
case 0x9E2: // banjo tooie (U) boot code
{
int i,j;
memcpy(rsp.IMEM + 0x120, rsp.RDRAM + 0x1e8, 0x1e8);
for (j=0; j<0xfc; j++)
for (i=0; i<8; i++)
*(rsp.RDRAM+((0x2fb1f0+j*0xff0+i)^S8))=*(rsp.IMEM+((0x120+j*8+i)^S8));
}
return Cycles;
break;
case 0x9F2: // banjo tooie (E) + zelda oot (E) boot code
{
int i,j;
memcpy(rsp.IMEM + 0x120, rsp.RDRAM + 0x1e8, 0x1e8);
for (j=0; j<0xfc; j++)
for (i=0; i<8; i++)
*(rsp.RDRAM+((0x2fb1f0+j*0xff0+i)^S8))=*(rsp.IMEM+((0x120+j*8+i)^S8));
}
return Cycles;
break;
}
}
else
{
switch(task->type)
{
case 2: // audio
if (audio_ucode(task) == 0)
return Cycles;
break;
case 4: // jpeg
switch(sum)
{
case 0x278: // used by zelda during boot
*rsp.SP_STATUS_REG |= 0x200;
return Cycles;
break;
case 0x2e4fc: // uncompress
jpg_uncompress(task);
return Cycles;
break;
default:
{
DebugMessage(M64MSG_WARNING, "unknown jpeg task: sum:%x", sum);
}
}
break;
}
}
#if 0
{
FILE *f;
DebugMessage(M64MSG_WARNING, "unknown task: type:%d sum:%x PC:%lx", (int)task->type, sum, (unsigned long) rsp.SP_PC_REG);
if (task->ucode_size <= 0x1000)
{
f = fopen("imem.dat", "wb");
if (f == NULL || fwrite(rsp.RDRAM + task->ucode, 1, task->ucode_size, f) != task->ucode_size)
DebugMessage(M64MSG_WARNING, "couldn't write to RSP debugging file imem.dat");
fclose(f);
f = fopen("dmem.dat", "wb");
if (f == NULL || fwrite(rsp.RDRAM + task->ucode_data, 1, task->ucode_data_size, f) != task->ucode_data_size)
DebugMessage(M64MSG_WARNING, "couldn't write to RSP debugging file dmem.dat");
fclose(f);
}
else
{
f = fopen("imem.dat", "wb");
if (f == NULL || fwrite(rsp.IMEM, 1, 0x1000, f) != 0x1000)
DebugMessage(M64MSG_WARNING, "couldn't write to RSP debugging file imem.dat");
fclose(f);
f = fopen("dmem.dat", "wb");
if (f == NULL || fwrite(rsp.DMEM, 1, 0x1000, f) != 0x1000)
DebugMessage(M64MSG_WARNING, "couldn't write to RSP debugging file dmem.dat");
fclose(f);
}
}
#endif
return Cycles;
}
void dvb_debug(char *str_temp)
{
if(dvb_bug == 0)
return;
DebugMessage("=== PXWANG dvb_debug CallBy Function:%s", str_temp);
}
static int ProcessIcmpUnreach(Packet *p)
{
/* Handle ICMP unreachable */
SessionKey skey;
SessionControlBlock *ssn = NULL;
uint16_t sport;
uint16_t dport;
sfaddr_t *src;
sfaddr_t *dst;
/* No "orig" IP Header */
if (!p->orig_iph)
return 0;
/* Get TCP/UDP/ICMP session from original protocol/port info
* embedded in the ICMP Unreach message. This is already decoded
* in p->orig_foo. TCP/UDP ports are decoded as p->orig_sp/dp.
*/
skey.protocol = GET_ORIG_IPH_PROTO(p);
sport = p->orig_sp;
dport = p->orig_dp;
src = GET_ORIG_SRC(p);
dst = GET_ORIG_DST(p);
if (sfip_fast_lt6(src, dst))
{
COPY4(skey.ip_l, sfaddr_get_ip6_ptr(src));
skey.port_l = sport;
COPY4(skey.ip_h, sfaddr_get_ip6_ptr(dst));
skey.port_h = dport;
}
else if (IP_EQUALITY(src, dst))
{
COPY4(skey.ip_l, sfaddr_get_ip6_ptr(src));
COPY4(skey.ip_h, skey.ip_l);
if (sport < dport)
{
skey.port_l = sport;
skey.port_h = dport;
}
else
{
skey.port_l = dport;
skey.port_h = sport;
}
}
else
{
COPY4(skey.ip_l, sfaddr_get_ip6_ptr(dst));
COPY4(skey.ip_h, sfaddr_get_ip6_ptr(src));
skey.port_l = dport;
skey.port_h = sport;
}
if (p->vh)
skey.vlan_tag = (uint16_t)VTH_VLAN(p->vh);
else
skey.vlan_tag = 0;
switch (skey.protocol)
{
case IPPROTO_TCP:
/* Lookup a TCP session */
ssn = GetLWTcpSession(&skey);
break;
case IPPROTO_UDP:
/* Lookup a UDP session */
ssn = GetLWUdpSession(&skey);
break;
case IPPROTO_ICMP:
/* Lookup a ICMP session */
ssn = session_api->get_session_by_key(icmp_lws_cache, &skey);
break;
}
if (ssn)
{
/* Mark this session as dead. */
DEBUG_WRAP(DebugMessage(DEBUG_STREAM_STATE,
"Marking session as dead, per ICMP Unreachable!\n"););
ssn->ha_state.session_flags |= SSNFLAG_DROP_CLIENT;
ssn->ha_state.session_flags |= SSNFLAG_DROP_SERVER;
ssn->session_state |= STREAM_STATE_UNREACH;
}
static int load_controller_config(const char *SectionName, int i, int bIsAutoconfig)
{
m64p_handle pConfig;
char input_str[256], value1_str[16], value2_str[16];
const char *config_ptr;
int j;
/* Open the configuration section for this controller */
if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "Couldn't open config section '%s'", SectionName);
return 0;
}
/* Check version number, and if it doesn't match: delete the config section and return with error */
if (!bIsAutoconfig)
{
float fVersion = 0.0f;
if (ConfigGetParameter(pConfig, "version", M64TYPE_FLOAT, &fVersion, sizeof(float)) != M64ERR_SUCCESS)
{
ConfigDeleteSection(SectionName);
return -1;
}
if (((int) fVersion) != ((int) CONFIG_VERSION))
{
DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in config section '%s': current is %.2f. Clearing.", fVersion, SectionName, (float) CONFIG_VERSION);
ConfigDeleteSection(SectionName);
return -1;
}
}
/* check for the required parameters */
if (ConfigGetParameter(pConfig, "plugged", M64TYPE_BOOL, &controller[i].control->Present, sizeof(int)) != M64ERR_SUCCESS)
return -1;
if (ConfigGetParameter(pConfig, "plugin", M64TYPE_INT, &controller[i].control->Plugin, sizeof(int)) != M64ERR_SUCCESS)
return -1;
if (ConfigGetParameter(pConfig, "device", M64TYPE_INT, &controller[i].device, sizeof(int)) != M64ERR_SUCCESS)
return -1;
/* Name validation only applies to stored configurations (not auto-configs) */
if (!bIsAutoconfig)
{
char device_name[256];
if (ConfigGetParameter(pConfig, "name", M64TYPE_STRING, device_name, 256) != M64ERR_SUCCESS)
device_name[0] = 0;
if (controller[i].device == DEVICE_NOT_JOYSTICK)
{
/* do not load automatically generated keyboard config that was stored to disk (prefer any joysticks attached) */
if (strcmp(device_name, "AutoKeyboard") == 0)
return -2;
}
else if (controller[i].device >= 0 && device_name[0] != 0)
{
/* check that the SDL device name matches the name stored in the config section */
const char *sdl_name = get_sdl_joystick_name(controller[i].device);
if (sdl_name == NULL || strncmp(device_name, sdl_name, 255) != 0)
{
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: SDL joystick name '%s' doesn't match stored configuration name '%s'", i + 1, sdl_name, device_name);
return -3;
}
}
}
/* then do the optional parameters */
ConfigGetParameter(pConfig, "mouse", M64TYPE_BOOL, &controller[i].mouse, sizeof(int));
if (ConfigGetParameter(pConfig, "MouseSensitivity", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS)
{
if (sscanf(input_str, "%f,%f", &controller[i].mouse_sens[0], &controller[i].mouse_sens[1]) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in MouseSensitivity parameter for controller %i", i + 1);
}
if (ConfigGetParameter(pConfig, "AnalogDeadzone", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS)
{
if (sscanf(input_str, "%i,%i", &controller[i].axis_deadzone[0], &controller[i].axis_deadzone[1]) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in AnalogDeadzone parameter for controller %i", i + 1);
}
if (ConfigGetParameter(pConfig, "AnalogPeak", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS)
{
if (sscanf(input_str, "%i,%i", &controller[i].axis_peak[0], &controller[i].axis_peak[1]) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in AnalogPeak parameter for controller %i", i + 1);
}
/* load configuration for all the digital buttons */
for (j = 0; j < X_AXIS; j++)
{
if (ConfigGetParameter(pConfig, button_names[j], M64TYPE_STRING, input_str, 256) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "missing config key '%s' for controller %i button %i", button_names[j], i+1, j);
continue;
}
if ((config_ptr = strstr(input_str, "key")) != NULL)
if (sscanf(config_ptr, "key(%i)", (int *) &controller[i].button[j].key) != 1)
DebugMessage(M64MSG_WARNING, "parsing error in key() parameter of button '%s' for controller %i", button_names[j], i + 1);
if ((config_ptr = strstr(input_str, "button")) != NULL)
if (sscanf(config_ptr, "button(%i)", &controller[i].button[j].button) != 1)
DebugMessage(M64MSG_WARNING, "parsing error in button() parameter of button '%s' for controller %i", button_names[j], i + 1);
if ((config_ptr = strstr(input_str, "axis")) != NULL)
{
char chAxisDir;
if (sscanf(config_ptr, "axis(%d%c,%d", &controller[i].button[j].axis, &chAxisDir, &controller[i].button[j].axis_deadzone) != 3 &&
sscanf(config_ptr, "axis(%i%c", &controller[i].button[j].axis, &chAxisDir) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in axis() parameter of button '%s' for controller %i", button_names[j], i + 1);
controller[i].button[j].axis_dir = (chAxisDir == '+' ? 1 : (chAxisDir == '-' ? -1 : 0));
}
if ((config_ptr = strstr(input_str, "hat")) != NULL)
{
char *lastchar = NULL;
if (sscanf(config_ptr, "hat(%i %15s", &controller[i].button[j].hat, value1_str) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in hat() parameter of button '%s' for controller %i", button_names[j], i + 1);
value1_str[15] = 0;
/* chop off the last character of value1_str if it is the closing parenthesis */
lastchar = &value1_str[strlen(value1_str) - 1];
if (lastchar > value1_str && *lastchar == ')') *lastchar = 0;
controller[i].button[j].hat_pos = get_hat_pos_by_name(value1_str);
}
if ((config_ptr = strstr(input_str, "mouse")) != NULL)
if (sscanf(config_ptr, "mouse(%i)", &controller[i].button[j].mouse) != 1)
DebugMessage(M64MSG_WARNING, "parsing error in mouse() parameter of button '%s' for controller %i", button_names[j], i + 1);
}
/* load configuration for the 2 analog joystick axes */
for (j = X_AXIS; j <= Y_AXIS; j++)
{
int axis_idx = j - X_AXIS;
if (ConfigGetParameter(pConfig, button_names[j], M64TYPE_STRING, input_str, 256) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "missing config key '%s' for controller %i axis %i", button_names[j], i+1, axis_idx);
continue;
}
if ((config_ptr = strstr(input_str, "key")) != NULL)
if (sscanf(config_ptr, "key(%i,%i)", (int *) &controller[i].axis[axis_idx].key_a, (int *) &controller[i].axis[axis_idx].key_b) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in key() parameter of axis '%s' for controller %i", button_names[j], i + 1);
if ((config_ptr = strstr(input_str, "button")) != NULL)
if (sscanf(config_ptr, "button(%i,%i)", &controller[i].axis[axis_idx].button_a, &controller[i].axis[axis_idx].button_b) != 2)
DebugMessage(M64MSG_WARNING, "parsing error in button() parameter of axis '%s' for controller %i", button_names[j], i + 1);
if ((config_ptr = strstr(input_str, "axis")) != NULL)
{
char chAxisDir1, chAxisDir2;
if (sscanf(config_ptr, "axis(%i%c,%i%c)", &controller[i].axis[axis_idx].axis_a, &chAxisDir1,
&controller[i].axis[axis_idx].axis_b, &chAxisDir2) != 4)
DebugMessage(M64MSG_WARNING, "parsing error in axis() parameter of axis '%s' for controller %i", button_names[j], i + 1);
controller[i].axis[axis_idx].axis_dir_a = (chAxisDir1 == '+' ? 1 : (chAxisDir1 == '-' ? -1 : 0));
controller[i].axis[axis_idx].axis_dir_b = (chAxisDir2 == '+' ? 1 : (chAxisDir2 == '-' ? -1 : 0));
}
if ((config_ptr = strstr(input_str, "hat")) != NULL)
{
char *lastchar = NULL;
if (sscanf(config_ptr, "hat(%i %15s %15s", &controller[i].axis[axis_idx].hat, value1_str, value2_str) != 3)
DebugMessage(M64MSG_WARNING, "parsing error in hat() parameter of axis '%s' for controller %i", button_names[j], i + 1);
value1_str[15] = value2_str[15] = 0;
/* chop off the last character of value2_str if it is the closing parenthesis */
lastchar = &value2_str[strlen(value2_str) - 1];
if (lastchar > value2_str && *lastchar == ')') *lastchar = 0;
controller[i].axis[axis_idx].hat_pos_a = get_hat_pos_by_name(value1_str);
controller[i].axis[axis_idx].hat_pos_b = get_hat_pos_by_name(value2_str);
}
}
return 1;
}
void lircCheckInput(void)
{
struct pollfd lircpoll;
lircpoll.fd = g_lircfd;
lircpoll.events = POLLIN;
if(poll(&lircpoll, 1, 0) > 0)
{
char *code;
char *c;
int ret;
if(lirc_nextcode(&code) == 0 && code != NULL)
{
while((ret = lirc_code2char(g_config, code, &c)) == 0 && c!=NULL)
{
char *c_ind = c;
while(*c_ind != '\0')
{
*c_ind = toupper(*c_ind);
c_ind++;
}
DebugMessage(M64MSG_VERBOSE, "LIRC Execing command \"%s\"", c);
if(strcmp(c, "SAVE") == 0)
savestates_job |= SAVESTATE;
else if(strcmp(c, "LOAD") == 0)
savestates_job |= LOADSTATE;
else if(strcmp(c, "QUIT") == 0)
main_stop();
else if(strcmp(c, "FULLSCREEN") == 0)
changeWindow();
else if(strcmp(c, "MUTE") == 0)
{
volumeMute();
main_draw_volume_osd();
}
else if(strcmp(c, "VOL+") == 0)
{
volumeUp();
main_draw_volume_osd();
}
else if(strcmp(c, "VOL-") == 0)
{
volumeDown();
main_draw_volume_osd();
}
else if(strcmp(c, "SCREENSHOT") == 0)
main_take_next_screenshot();
else if(strcmp(c, "SPEED+") == 0)
main_speedup(5);
else if(strcmp(c, "SPEED-") == 0)
main_speeddown(5);
else if(strcmp(c, "ADVANCE") == 0)
main_advance_one();
else if(strcmp(c, "PAUSE") == 0)
main_toggle_pause();
else
{
int val = ((int)c[0])-((int) '0');
if (val >= 0 && val <= 9)
savestates_select_slot( val );
}
}
free(code);
}
}
}
void load_configuration(int bPrintSummary)
{
char SectionName[32];
const char *JoyName;
int joy_found = 0, joy_plugged = 0;
int readOK;
int n64CtrlIdx, sdlCtrlIdx, j;
/* loop through all 4 simulated N64 controllers */
for (n64CtrlIdx=0,sdlCtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
/* reset the controller configuration */
clear_controller(n64CtrlIdx);
/* try to load the config from the core's configuration api */
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
readOK = load_controller_config(SectionName, n64CtrlIdx, 0);
if (readOK <= 0 || controller[n64CtrlIdx].device == DEVICE_AUTO)
{
int ControllersFound = 0;
/* make sure that SDL device number hasn't already been used for a different N64 controller */
for (j = 0; j < n64CtrlIdx; j++)
{
if (controller[j].device == sdlCtrlIdx)
{
sdlCtrlIdx++;
j = -1;
}
}
/* if auto / bad config, get joystick name based on SDL order */
JoyName = get_sdl_joystick_name(sdlCtrlIdx);
/* reset the controller configuration again and try to auto-configure */
ControllersFound = auto_set_defaults(sdlCtrlIdx, JoyName);
sdlCtrlIdx++;
if (ControllersFound == 0)
{
controller[n64CtrlIdx].device = DEVICE_AUTO;
controller[n64CtrlIdx].control->Present = 0;
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: Disabled, SDL joystick %i is not available", n64CtrlIdx+1, sdlCtrlIdx-1);
}
else
{
for (j = 0; j < ControllersFound; j++) /* a USB device may have > 1 controller */
{
sprintf(SectionName, "AutoConfig%i", j);
if (n64CtrlIdx + j > 3)
{
ConfigDeleteSection(SectionName);
continue;
}
clear_controller(n64CtrlIdx + j);
if (load_controller_config(SectionName, n64CtrlIdx + j, 1) > 0)
{
/* use ConfigSetDefault*() to save this auto-config if config section was empty */
save_controller_config(n64CtrlIdx + j, JoyName);
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using auto-config for SDL joystick %i ('%s')", n64CtrlIdx+1, controller[n64CtrlIdx].device, JoyName);
}
else
{
DebugMessage(M64MSG_ERROR, "Autoconfig data invalid for controller #%i in device '%s'", j + 1, JoyName);
}
ConfigDeleteSection(SectionName);
}
n64CtrlIdx += ControllersFound - 1;
continue;
}
}
else if (controller[n64CtrlIdx].device >= 0)
{
/* if joystick found in cfg, take its SDL number from there */
JoyName = get_sdl_joystick_name(controller[n64CtrlIdx].device);
/* valid joystick configuration was read; check if the specified joystick is available in SDL */
if (JoyName == NULL)
{
controller[n64CtrlIdx].device = DEVICE_AUTO;
controller[n64CtrlIdx].control->Present = 0;
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: Disabled, SDL joystick %i is not available", n64CtrlIdx+1, controller[n64CtrlIdx].device);
}
else
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using stored config for SDL joystick %i ('%s')", n64CtrlIdx+1, controller[n64CtrlIdx].device, JoyName);
}
else /* controller is configured for keyboard/mouse */
{
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using keyboard/mouse", n64CtrlIdx+1);
}
}
/* see how many joysticks were found */
joy_found = 0, joy_plugged = 0;
for (j = 0; j < 4; j++)
{
if (controller[j].device >= 0 || controller[j].device == DEVICE_NOT_JOYSTICK)
{
joy_found++;
if (controller[j].control->Present)
joy_plugged++;
}
}
/* fallback to keyboard if no joysticks are available and 'plugged in' */
if (joy_found == 0 || joy_plugged == 0)
{
force_controller_keyboard(0);
}
if (bPrintSummary)
{
if (joy_found > 0 && joy_plugged > 0)
{
DebugMessage(M64MSG_INFO, "%i controller(s) found, %i plugged in and usable in the emulator", joy_found, joy_plugged);
}
else
{
if (joy_found == 0)
DebugMessage(M64MSG_WARNING, "No joysticks/controllers found");
else if (joy_plugged == 0)
DebugMessage(M64MSG_WARNING, "%i controllers found, but none were 'plugged in'", joy_found);
}
}
}
void gen_interupt(void)
{
if (stop == 1)
{
vi_counter = 0; // debug
dyna_stop();
}
if (!interupt_unsafe_state)
{
if (savestates_get_job() == savestates_job_load)
{
savestates_load();
return;
}
if (reset_hard_job)
{
reset_hard();
reset_hard_job = 0;
return;
}
}
if (skip_jump)
{
unsigned int dest = skip_jump;
skip_jump = 0;
if (q->count > Count || (Count - q->count) < 0x80000000)
next_interupt = q->count;
else
next_interupt = 0;
last_addr = dest;
generic_jump_to(dest);
return;
}
switch(q->type)
{
case SPECIAL_INT:
if (Count > 0x10000000) return;
remove_interupt_event();
add_interupt_event_count(SPECIAL_INT, 0);
return;
break;
case VI_INT:
if(vi_counter < 60)
{
if (vi_counter == 0)
cheat_apply_cheats(ENTRY_BOOT);
vi_counter++;
}
else
{
cheat_apply_cheats(ENTRY_VI);
}
gfx.updateScreen();
#ifdef WITH_LIRC
lircCheckInput();
#endif
SDL_PumpEvents();
refresh_stat();
// if paused, poll for input events
//if(rompause)
//{
osd_render(); // draw Paused message in case gfx.updateScreen didn't do it
//VidExt_GL_SwapBuffers();
// while(rompause)
// {
//SDL_Delay(10);
SDL_PumpEvents();
#ifdef WITH_LIRC
lircCheckInput();
#endif //WITH_LIRC
// }
//}
new_vi();
WaitForSingleObject(rompausesem, INFINITE);
if (vi_register.vi_v_sync == 0) vi_register.vi_delay = 500000;
else vi_register.vi_delay = ((vi_register.vi_v_sync + 1)*1500);
next_vi += vi_register.vi_delay;
if (vi_register.vi_status&0x40) vi_field=1-vi_field;
else vi_field=0;
remove_interupt_event();
add_interupt_event_count(VI_INT, next_vi);
MI_register.mi_intr_reg |= 0x08;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case COMPARE_INT:
remove_interupt_event();
Count+=2;
add_interupt_event_count(COMPARE_INT, Compare);
Count-=2;
Cause = (Cause | 0x8000) & 0xFFFFFF83;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case CHECK_INT:
remove_interupt_event();
break;
case SI_INT:
#ifdef WITH_LIRC
lircCheckInput();
#endif //WITH_LIRC
SDL_PumpEvents();
PIF_RAMb[0x3F] = 0x0;
remove_interupt_event();
MI_register.mi_intr_reg |= 0x02;
si_register.si_stat |= 0x1000;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case PI_INT:
remove_interupt_event();
MI_register.mi_intr_reg |= 0x10;
pi_register.read_pi_status_reg &= ~3;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case AI_INT:
if (ai_register.ai_status & 0x80000000) // full
{
unsigned int ai_event = get_event(AI_INT);
remove_interupt_event();
ai_register.ai_status &= ~0x80000000;
ai_register.current_delay = ai_register.next_delay;
ai_register.current_len = ai_register.next_len;
add_interupt_event_count(AI_INT, ai_event+ai_register.next_delay);
MI_register.mi_intr_reg |= 0x04;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
}
else
{
remove_interupt_event();
ai_register.ai_status &= ~0x40000000;
//-------
MI_register.mi_intr_reg |= 0x04;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
}
break;
case SP_INT:
remove_interupt_event();
sp_register.sp_status_reg |= 0x203;
// sp_register.sp_status_reg |= 0x303;
if (!(sp_register.sp_status_reg & 0x40)) return; // !intr_on_break
MI_register.mi_intr_reg |= 0x01;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case DP_INT:
remove_interupt_event();
dpc_register.dpc_status &= ~2;
dpc_register.dpc_status |= 0x81;
MI_register.mi_intr_reg |= 0x20;
if (MI_register.mi_intr_reg & MI_register.mi_intr_mask_reg)
Cause = (Cause | 0x400) & 0xFFFFFF83;
else
return;
if ((Status & 7) != 1) return;
if (!(Status & Cause & 0xFF00)) return;
break;
case HW2_INT:
// Hardware Interrupt 2 -- remove interrupt event from queue
remove_interupt_event();
// setup r4300 Status flags: reset TS, and SR, set IM2
Status = (Status & ~0x00380000) | 0x1000;
Cause = (Cause | 0x1000) & 0xFFFFFF83;
/* the exception_general() call below will jump to the interrupt vector (0x80000180) and setup the
* interpreter or dynarec
*/
break;
case NMI_INT:
// Non Maskable Interrupt -- remove interrupt event from queue
remove_interupt_event();
// setup r4300 Status flags: reset TS and SR, set BEV, ERL, and SR
Status = (Status & ~0x00380000) | 0x00500004;
Cause = 0x00000000;
// simulate the soft reset code which would run from the PIF ROM
r4300_reset_soft();
// clear all interrupts, reset interrupt counters back to 0
Count = 0;
vi_counter = 0;
init_interupt();
// clear the audio status register so that subsequent write_ai() calls will work properly
ai_register.ai_status = 0;
// set ErrorEPC with the last instruction address
ErrorEPC = PC->addr;
// reset the r4300 internal state
if (r4300emu != CORE_PURE_INTERPRETER)
{
// clear all the compiled instruction blocks and re-initialize
free_blocks();
init_blocks();
}
// adjust ErrorEPC if we were in a delay slot, and clear the delay_slot and dyna_interp flags
if(delay_slot==1 || delay_slot==3)
{
ErrorEPC-=4;
}
delay_slot = 0;
dyna_interp = 0;
// set next instruction address to reset vector
last_addr = 0xa4000040;
generic_jump_to(0xa4000040);
return;
default:
DebugMessage(M64MSG_ERROR, "Unknown interrupt queue event type %.8X.", q->type);
remove_interupt_event();
break;
}
#ifdef NEW_DYNAREC
if (r4300emu == CORE_DYNAREC) {
EPC = pcaddr;
pcaddr = 0x80000180;
Status |= 2;
Cause &= 0x7FFFFFFF;
pending_exception=1;
} else {
exception_general();
}
#else
exception_general();
#endif
if (!interupt_unsafe_state)
{
if (savestates_get_job() == savestates_job_save)
{
savestates_save();
return;
}
}
}
/****************************************************************************
*
* Function: RegisterPlugin(char *, void (*func)())
*
* Purpose: Associates a rule option keyword with an option setup/linking
* function.
*
* Arguments: keyword => The option keyword to associate with the option
* handler
* *func => function pointer to the handler
*
* Returns: void function
*
***************************************************************************/
void RegisterPlugin(char *keyword, void (*func) (char *, OptTreeNode *, int))
{
KeywordXlateList *idx;
DEBUG_WRAP(DebugMessage(DEBUG_PLUGIN, "Registering keyword:func => %s:%p\n",
keyword, func););
void add_interupt_event_count(int type, unsigned int count)
{
struct node* event;
struct node* e;
int special;
special = (type == SPECIAL_INT);
if(g_cp0_regs[CP0_COUNT_REG] > UINT32_C(0x80000000)) SPECIAL_done = 0;
if (get_event(type)) {
DebugMessage(M64MSG_WARNING, "two events of type 0x%x in interrupt queue", type);
/* FIXME: hack-fix for freezing in Perfect Dark
* http://code.google.com/p/mupen64plus/issues/detail?id=553
* https://github.com/mupen64plus-ae/mupen64plus-ae/commit/802d8f81d46705d64694d7a34010dc5f35787c7d
*/
return;
}
event = alloc_node(&q.pool);
if (event == NULL)
{
DebugMessage(M64MSG_ERROR, "Failed to allocate node for new interrupt event");
return;
}
event->data.count = count;
event->data.type = type;
if (q.first == NULL)
{
q.first = event;
event->next = NULL;
next_interupt = q.first->data.count;
}
else if (before_event(count, q.first->data.count, q.first->data.type) && !special)
{
event->next = q.first;
q.first = event;
next_interupt = q.first->data.count;
}
else
{
for(e = q.first;
e->next != NULL &&
(!before_event(count, e->next->data.count, e->next->data.type) || special);
e = e->next);
if (e->next == NULL)
{
e->next = event;
event->next = NULL;
}
else
{
if (!special)
for(; e->next != NULL && e->next->data.count == count; e = e->next);
event->next = e->next;
e->next = event;
}
}
}
void JudgeTask::doRun()
{
ILogger *logger = LoggerFactory::getLogger(LoggerId::AppInitLoggerId);
OJString infoBuffer;
FormatString(infoBuffer, OJStr("[JudgeTask] task %d"), Input.SolutionID);
logger->logInfo(infoBuffer);
//编译
if(!compile())
{
return;
}
//搜索测试数据
OJString path;
FormatString(path, OJStr("%s/%d"), AppConfig::Path::TestDataPath.c_str(), Input.ProblemID);
DebugMessage(OJStr("[JudgeTask] %d search path: %s"), Input.SolutionID, path.c_str());
//TODO: 根据是否specialJudge，决定搜索.out还是.in文件。
FileTool::FileNameList fileList;
FileTool::GetSpecificExtFiles(fileList, path, OJStr(".out"), true);
OJUInt32_t testCount = fileList.size();
if(testCount <= 0)//没有测试数据
{
output_.Result = AppConfig::JudgeCode::SystemError;
FormatString(infoBuffer, OJStr("[JudgeTask] not found test data for solution %d problem %d."),
Input.SolutionID, Input.ProblemID);
logger->logError(infoBuffer);
return;
}
//测试多组数据
OJUInt32_t accepted = 0;
for(OJUInt32_t i=0; i<testCount; ++i)
{
answerOutputFile_ = fileList[i];
answerInputFile_ = FileTool::RemoveFileExt(answerOutputFile_);
answerInputFile_ += OJStr(".in");
DebugMessage(OJStr("[JudgeTask] %d input file: %s"),
Input.SolutionID, answerInputFile_.c_str());
DebugMessage(OJStr("[JudgeTask] %d output file: %s"),
Input.SolutionID, answerOutputFile_.c_str());
if(!safeRemoveFile(userOutputFile_))
{
output_.Result = AppConfig::JudgeCode::SystemError;
break;
}
if(!excute())
{
break;
}
if(!match())
{
break;
}
++accepted;
}
output_.PassRate = float(accepted)/testCount;
}
static m64p_error OpenConfigurationHandles(void)
{
float fConfigParamsVersion;
int bSaveConfig = 0;
m64p_error rval;
unsigned int i;
/* Open Configuration sections for core library and console User Interface */
rval = (*ConfigOpenSection)("Core", &l_ConfigCore);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "failed to open 'Core' configuration section");
return rval;
}
rval = (*ConfigOpenSection)("Video-General", &l_ConfigVideo);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "failed to open 'Video-General' configuration section");
return rval;
}
rval = (*ConfigOpenSection)("Transferpak", &l_ConfigTransferPak);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "failed to open 'Transferpak' configuration section");
return rval;
}
rval = (*ConfigOpenSection)("64DD", &l_Config64DD);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "failed to open '64DD' configuration section");
return rval;
}
rval = (*ConfigOpenSection)("UI-Console", &l_ConfigUI);
if (rval != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_ERROR, "failed to open 'UI-Console' configuration section");
return rval;
}
if ((*ConfigGetParameter)(l_ConfigUI, "Version", M64TYPE_FLOAT, &fConfigParamsVersion, sizeof(float)) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "No version number in 'UI-Console' config section. Setting defaults.");
(*ConfigDeleteSection)("UI-Console");
(*ConfigOpenSection)("UI-Console", &l_ConfigUI);
bSaveConfig = 1;
}
else if (((int) fConfigParamsVersion) != ((int) CONFIG_PARAM_VERSION))
{
DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in 'UI-Console' config section: current is %.2f. Setting defaults.", fConfigParamsVersion, (float) CONFIG_PARAM_VERSION);
(*ConfigDeleteSection)("UI-Console");
(*ConfigOpenSection)("UI-Console", &l_ConfigUI);
bSaveConfig = 1;
}
else if ((CONFIG_PARAM_VERSION - fConfigParamsVersion) >= 0.0001f)
{
/* handle upgrades */
float fVersion = CONFIG_PARAM_VERSION;
ConfigSetParameter(l_ConfigUI, "Version", M64TYPE_FLOAT, &fVersion);
DebugMessage(M64MSG_INFO, "Updating parameter set version in 'UI-Console' config section to %.2f", fVersion);
bSaveConfig = 1;
}
/* Set default values for my Config parameters */
(*ConfigSetDefaultFloat)(l_ConfigUI, "Version", CONFIG_PARAM_VERSION, "Mupen64Plus UI-Console config parameter set version number. Please don't change this version number.");
(*ConfigSetDefaultString)(l_ConfigUI, "PluginDir", OSAL_CURRENT_DIR, "Directory in which to search for plugins");
(*ConfigSetDefaultString)(l_ConfigUI, "VideoPlugin", "mupen64plus-video-rice" OSAL_DLL_EXTENSION, "Filename of video plugin");
(*ConfigSetDefaultString)(l_ConfigUI, "AudioPlugin", "mupen64plus-audio-sdl" OSAL_DLL_EXTENSION, "Filename of audio plugin");
(*ConfigSetDefaultString)(l_ConfigUI, "InputPlugin", "mupen64plus-input-sdl" OSAL_DLL_EXTENSION, "Filename of input plugin");
(*ConfigSetDefaultString)(l_ConfigUI, "RspPlugin", "mupen64plus-rsp-hle" OSAL_DLL_EXTENSION, "Filename of RSP plugin");
for(i = 1; i < 5; ++i) {
char key[64];
char desc[2048];
#define SET_DEFAULT_STRING(key_fmt, default_value, desc_fmt) \
do { \
snprintf(key, sizeof(key), key_fmt, i); \
snprintf(desc, sizeof(desc), desc_fmt, i); \
(*ConfigSetDefaultString)(l_ConfigTransferPak, key, default_value, desc); \
} while(0)
SET_DEFAULT_STRING("GB-rom-%u", "", "Filename of the GB ROM to load into transferpak %u");
SET_DEFAULT_STRING("GB-ram-%u", "", "Filename of the GB RAM to load into transferpak %u");
#undef SET_DEFAULT_STRING
}
(*ConfigSetDefaultString)(l_Config64DD, "IPL-ROM", "", "Filename of the 64DD IPL ROM");
(*ConfigSetDefaultString)(l_Config64DD, "Disk", "", "Filename of the disk to load into Disk Drive");
if (bSaveConfig && ConfigSaveSection != NULL) { /* ConfigSaveSection was added in Config API v2.1.0 */
(*ConfigSaveSection)("UI-Console");
(*ConfigSaveSection)("Transferpak");
}
return M64ERR_SUCCESS;
}