NTSC GameCubes have no Language setting, so the language byte in SRAM is always 0. Some NTSC games do react oddly and display unfinished translations and similar when the byte is set to a nonzero value that corresponds to a non-English language on a PAL GameCube. See issue 7731: https://code.google.com/p/dolphin-emu/issues/detail?id=7731.
NaNs always propagate, so we can get away with only checking for NaN
inputs in the rare case that the result is NaN (as already done in
Jit64::HandleNaNs()).
Fixes block dots in THP videos.
Nintendo's THP video uses paired U8 stores to write their THP videos after decoding with floating point operations.
Paired stores clamp the range to the minimum and maximum values(0 - 255 in this case).
In some instances the resulting float will be larger than what a U8 can fit(Typically white) and results in black dots due to how AArch64 handles
quantizing.
The new implementation has 3 options:
SyncGpuMaxDistance
SyncGpuMinDistance
SyncGpuOverclock
The MaxDistance controlls how many CPU cycles the CPU is allowed to be in front
of the GPU. Too low values will slow down extremly, too high values are as
unsynchronized and half of the games will crash.
The -MinDistance (negative) set how many cycles the GPU is allowed to be in
front of the CPU. As we are used to emulate an infinitiv fast GPU, this may be
set to any high (negative) number.
The last parameter is to hack a faster (>1.0) or slower(<1.0) GPU. As we don't
emulate GPU timing very well (eg skip the timings of the pixel stage completely),
an overclock factor of ~0.5 is often much more accurate than 1.0
Should fix Issue 8209: Emulated Wiimote tilt is incorrect since 4.0-4543.
Original changes can be looked at the link below and discussion about the issue can be followed within Issue 8209 at googlecode.
http://pastebin.com/yKA2nuGp
Thanks to hk.konpie for the fix.
When AccurateNaNs is enabled, NaNs are handled accurately by checking
for NaN results and choosing the correct input NaN or replacing x86's
generated -QNaN with +QNaN.
This fixes a minor bug where the IPL thinks the SRAM has been corrupted and forces you to re-set date/time and settings when you change language in Config -> GameCube while not skipping the IPL on boot.
Note - I removed a SleepCurrentThread(1) the patch added which seemed to
be unrelated to the actual job at hand. If there was a real need for it
(which sounds like it would be an enet-related bug - enet_host_service
is supposed to *sleep*), that needs to be dealt with...
ISOFile and GameFile were using IsWiiDisc() and IsWadFile() to set
an enum value. The volume might as well return an enum directly.
I increased the Qt CACHE_REVISION because m_platform now is saved as u32
instead of int, but increasing the wx CACHE_REVISION is not necessary.
I tried to change messages that contained instructions for users,
while avoiding messages that are so technical that most users
wouldn't understand them even if they were in the right language.
Fixes a bug in lfs where I was doing a rev64.16b when I needed to do a rev32.8b.
Change a ld1r.4s to a ld1r.2s.
Fix an issue where a fcvtl2 needed to be a fcvtl.
Re-enabled psq_l, issue with flickering can't be reproduced anymore, so whatever.
This cleans up some of the code between core and UI for disassembling and dumping code blocks.
Should help the QT UI in bringing up its debug UI since it won't have to deal with this garbage now.
We already use ALT + ENTER for toggling fullscreen.
But as ENTER is both home and start, this buttons will always
also be triggered on toggling fullscreen. Now we check for
those buttons if ALT is not pressed.
So now we're able to toggle fullscreen without pressing home or start.
- Change the Wiimote emulation SYSCONF R/W to use the temporary NAND if in use.
- Fix up SysConf API so this actually works.
Kind of a hack. Like I said, this can be cleaned up when configuration
is synced...
Eventually, netplay will be able to use the host's NAND, but this could
still be useful in some cases; for TAS it definitely makes sense to have
a way to avoid using any preexisting NAND.
In terms of implementation: remove D_WIIUSER_IDX, which was just WIIROOT
+ "/", as well as some other indices which are pointless to have as
separate variables rather than just using the actual path (fixed, since
they're actual Wii NAND paths) at the call site. Then split off
D_SESSION_WIIROOT_IDX, which can point to the dummy NAND directory, from
D_WIIROOT_IDX, which always points to the "real" one the user
configured.
Specifically, things like GETHOSTBYNAME, GETHOSTID, etc. could be done
without creating a socket, which is what the old check blocked. Now we
check at the ioctl and ioctlv handlers. Might be possible to get a bit
more realistic behavior in future by filtering individual ioctls, but it
probably doesn't matter.
This includes net, which is nonsensical to "sync" in netplay/replays
(could have the host do the Wii networking in future though...), and USB
keyboard, which just needs some love to do the same.
- FileSearch is now just one function, and it converts the original glob
into a regex on all platforms rather than relying on native Windows
pattern matching on there and a complete hack elsewhere. It now
supports recursion out of the box rather than manually expanding
into a full list of directories in multiple call sites.
- This adds a GCC >= 4.9 dependency due to older versions having
outright broken <regex>. MSVC is fine with it.
- ScanDirectoryTree returns the parent entry rather than filling parts
of it in via reference. The count is now stored in the entry like it
was for subdirectories.
- .glsl file search is now done with DoFileSearch.
- IOCTLV_READ_DIR now uses ScanDirectoryTree directly and sorts the
results after replacements for better determinism.
We had to lock audiocommon with the old asynchron HLE audio emulation,
now our Mixer is just a plain FIFO which may underrun.
Of course, this will stutter, but underruning the audio backend is likely worse.
Until loadstores are fully investigated, let's artificially extend the life of it by disabling all of them.
These instructions break in a very terrible way and eventually all loadstores end up attempting to access memory region (u32)-1.
Disable until someone has enough time to investigate further.
This was a struct with exactly one element, and
an overloaded constructor which matches the construtor
of this element. So there is no need for this stacked
structur.
This is time based block profiling unlike the ARMv7 core.
I would like to add cycle counter based block profiling like the ARMv7 core, but it first requires writing a kernel module to enable the counters to userland applications
This is intended to better separate it from GetNames and to clarify
that this name originally wasn't meant to be shown to users.
The ISOProperties GUI is also updated, mainly because labeling
the long banner name "short name" was confusing.
This affects enabling and disabling block profiling on the fly.
The block profiling pauses the CPU cores and then flushes the JIT's block cache and enables block profile.
The issue with this is that when we pause the CPU core, we don't have a way to tell if the JIT recompiler has actually left.
So if the secondary thread that is clearing the JIT block cache is too quick, it will clear the cache as a recompiler is still running that block that
has been cleared.
Replaces them with forward declarations of used types, or removes them entirely if they aren't used at all. This also replaces certain Common headers with less inclusive ones (in terms of definitions they pull in).
This is available with the `GDBSocket` option in
`~/.dolphin-emu/Config/Dolphin.ini`.
GDB can connect to it with:
$ powerpc-eabi-gdb
(gdb) target remote |socat STDIO UNIX:foo.sock
Because I don't like so much binding the GDB stub socket to 0.0.0.0.
On Linux, with a suitable umask, we can make sure that another local
user cannot connect to the socket.
I'm not sure if Maker is the best name (Developer? Publisher?
Company? Copyright?) but I went with it because it's
what the game properties window uses. For the sake of
backwards compatibility, the INI option wasn't renamed.
This scanning thread either polls libusb or checks every 500ms for a
change depending on host capabilities. The GC Adapter can now be plugged
and unplugged at any time when dolphin is open, it will be used if the
direct connect option is set.
- CEXIETHERNET::SendComplete is always called from the main thread, so
drop the _Threadsafe.
- Mark the FIFO player thread as the "CPU thread" so it can call
ScheduleEvent without complaints. I haven't actually tested this,
since I don't know how to use the FIFO player; it might break
something.
PowerPC does exceptions and hardware and stuff, Memory doesn't.
I did not realize until a few minutes ago that there were two versions of these functions. This is why namespaces suck. Anyway, these were added by Mullin earlier this year.
They weren't sufficient and are made redundant by previous commits; they
also (on master) caused breakage due to Jit64::psq_stXX assuming writes
would be fastmem and not clobber a register under certain conditions.
That really needs to be refactored, but for now, this works.
Change TMemCheck::Action to return whether to break rather than calling
PPCDebugInterface::BreakNow, as this simplified the implementation; then
remove said method, as that was its only caller. One "interface" method
down, many to go...
Without fastmem, the JIT code still does an inline check for RAM
addresses. With watchpoints we have to disable that too. (Hardware
watchpoints would avoid all the slow, but be complicated to implement
and limited in number - I doubt most people debugging games care much if
they run slower.)
With this change and watchpoints enabled, Melee runs at no more than 40%
speed, despite running at full speed without them. Oh well. Better
works slowly than doesn't bloody work.
Incidentally, I'm getting an unrelated crash in
PowerPC::HostIsRAMAddress when shutting down a game. This code sucks.
- Move JitState::memcheck to JitOptions because it's an option.
- Add JitOptions::fastmem; switch JIT code to checking that rather than
bFastmem directly.
- Add JitBase::UpdateMemoryOptions(), which sets both two JIT options
(replacing the duplicate lines in Jit64 and JitIL that set memcheck
from bMMU).
- (!) The ARM JITs both had some lines that checked js.memcheck
despite it being uninitialized in their cases. I've added
UpdateMemoryOptions to both. There is a chance this could make
something slower compared to the old behavior if the uninitialized
value happened to be nonzero... hdkr should check this.
- UpdateMemoryOptions forces jo.fastmem and jo.memcheck off and on,
respectively, if there are any watchpoints set.
- Also call that function from ClearCache.
- Have MemChecks call ClearCache when the {first,last} watchpoint is
{added,removed}.
Enabling jo.memcheck (bah, confusing names) is currently pointless
because hitting a watchpoint does not interrupt the basic block. That
will change in the next commit.
All the multiplying and dividing by 100 in controller configs is
messy... An attempted solution to the problem was to not multiply
default_value by 100 in ControllerEmu::ControlGroup::LoadConfig,
but that broke other things instead, so I went with this.
This makes the code cleaner and also leads to some user-visible changes:
The wx game properties will no longer let the user
select WAD languages that don't have any names.
The Qt game list will now display names using the languages
set in the configuration instead of always using
English for PAL GC games and Japanese for WADs.
If a WAD doesn't have a name in the user's preferred language,
English is now selected as a fallback before Japanese.
Boot_BS2Emu was trying to read from the inserted disc even when
nothing was inserted, and this happened to not crash (but not
work either) before VolumeHandler was removed. This commit adds
a check that restores the old behavior, so there is no longer a
crash, but the game ID still doesn't get set for WADs. I don't
know if/how it should be set, so this felt like the safest option.
Core::Shutdown was only called on app exit, yet the emu thread exits
whenever emulation stops; if you launched a new game it would just join
via the destructor when s_emu_thread was set to a new thread.
(Incidentally, the destructor also makes explicitly joining on app exit
rather pointless.)
Because the GUI thread wasn't waiting for the CPU thread to fully shut
down, Core::IsRunning would remain true briefly after CFrame::DoStop
which, given Dolphin's penchant for accessing variables belonging to
other threads, can only mean trouble... In my case, because the previous
commit caused UpdateGUI, which is called at the end of DoStop, to call
PauseAndLock, which checks IsRunning, pressing stop at the right time
would cause strange behavior.
Since its lifetime is managed on the CPU thread, this (or a refactoring)
is absolutely required. One of the functions with a PauseAndLock call
added is CFrame::UpdateGUI; this is fine now, since it's called only
after important events happen, so just make sure not to call it every
frame or something :)
The regBuildMemAddress function already clears the address register.
Not only is clearing it again pointless, regBuildMemAddress uses the
bits in IInfo slightly diffrently and the second clear can clear
the wrong registers causing bugs if something else actually needs to
use those registers.
VolumeHandler is basically just a wrapper around a single IVolume object.
This change moves that object to DVDInterface, moves the Read32
function to IVolume, and gets rid of the rest of VolumeHandler.
The instant speed broke some games. SUDTR will now emulate
the transfer from the disc drive buffer to the main memory,
but not the speed of the disc drive itself.
With some specific, STUN-hostile routers, the netplay client can get
stuck forever while trying to connect to the stun server. This adds a
5 seconds (much more than should be necessary if it works) timer until
a failure is registered and the attempt stops.
* Changed the SI buffer processing so that transfers do not have to be completed instantly
* Added a second socket at port 49420 (0xc10c) which sends clock information to the GBA slaves
* Handled disconnections from the GBA and GC
* Made the transfers asynchronous
* Blocks the socket before the connection times out
Requires VBA-M SVN 1235 or later.
Otherwise, it would work but any async sending would be delayed by 4ms or
wait until the next packet was received.
Also increase the client timeout to 250ms, since enet_host_service is now
really interrupted.
Add std::unique_ptr<sf::Packet> objects to a queue instead of functions,
makes things easier to read, and avoids headaches while checking the
lifetime of the concerned objects.
Using BindToRegister from the register caches causes the register bound to be marked dirty.
Using the regular R() function from the register caches loads the registers without being dirty.
When implementing new instructions make sure to BindToRegister registers that become dirty.
With my previous changes Dolphin would fail to create the user directory if it didn't exist, and would dump all the configuration options in to the cwdir.
This was a bit more complicated to fix in a clean fashion, so I took to moving around code concerning user directories.
Instead of having GetUserPath serve a dual purpose of both getting and setting our user directories, break out to a new SetUserPath function.
GetUserPath will know only get the configured user path.
SetUserPath will set our user paths and setup the internal user path state.
This ending up being a lot cleaner overall, which is nice. Also less mind bending when attempting to read the code.
So now we won't dump all of our configuration in to the cwdir if ~/.dolphin-emu isn't found.
Fixes issue 8371.
It turns out that the offsets of the data in the return buffer matter: the
offset 0x340 is hardcoded into the code that uses the result.
With that fixed, get rid of the completely wrong 0x80000000 hack.
psq_st performs one store, and psq_ld one load, from the perspective of the
MMU; getting this wrong leads to potentially incorrect behavior (incorrect page
faults, weirdness with the gather pipe, etc.). Fix this, and stop masking
the address when checking for gather pipe writes.
Also a bunch of cleanup.
This came up from the discussion we were having prior about dumping half of a kilobyte of VFP registers to the stack is insanity.
This was due to me basically copying exactly what I did on ARMv7's paired loadstores, where the impact is less since we only use the bottom 64bits of
the VFP registers.
So I decided to think about how to improve upon this since I got called out on my terrible code.
The solution I have come up with is instead of jumping to the common ASM routine and having that check if it needs to take the fastmem or slowmem
routes, just inline the check in to the JIT block and jump to either a fastmem or slowmem handler.
Fairly simple, and this allows us to only flush the registers that are required when doing so. Should give a reasonable increase in performance for
games that use the slowmem path quite a lot.
Cleared the default mapping of hotkeys as they were conflicting with the key shortcuts.
Removed the Open, Change Disc, Refresh List and Exit hotkeys as they work only when driven from the menu.
- Simplified the locking mechanism when controllers were updated
- Reloaded the config of the controls instead of re-initialising the control plugins
- Fixed controls being unresponsive after the Refresh button was pressed
- Disables the hotkeys while the controller config is open
* Halving the number of hotkeys checked for (there were extra for future use)
* Gets the controller status once before parsing hotkeys
* Checks for the GUI lock once before parsing hotkeys
* Removed some redundant memsets
This is unused, and since it had the same value as FL_OUT_D, it was unnecessarily setting the rS register as an output, even on instructions that only have FL_OUT_D set.
When the core is busy shutting down only uninstall the exception handler if fastmem is actually enabled.
We only install when fastmem is enabled, so only uninstall when it is as well.
Fixes a crash I was getting on ARMv7.
When the fastmem loadstore would fail, we would disassemble a few instructions to determine if lhbrx or lhz*
This was failing since I was checking the REV16 instruction that appears after the LDRH. Fixed it to make sure it was checking the correct instruction
which is SXTH.
Fixes an issue where homebrew wouldn't load with fastmem enabled.
Comparing floating point numbers with == can trigger warnings (and have static analysis tools complain). So we make it the else case.
This also more closely resembles the Gekko manual.
It seems that games actually read this to determine how to act, which
isn't particularly strange. I was imagining it was more for the
Wiimote's internal normalization, but I was wrong.
When enabled, the silent option will avoid popping up dialog boxes for
overwrite confirmation or codec selection. The codec selection defaults to
uncompressed RGB.
This is required for FifoCI on Windows which needs to drive Dolphin from the
command line exclusively.
We do a whole bunch of non-threadsafe stuff, especially in the UI, and I'm
probably not going to get around to implementing a threadsafe framework
for interaction between the UI and the CPU thread anytime soon. See issue
8220.
The PowerPC CPU has bits in MSR (DR and IR) which control whether
addresses are translated. We should respect these instead of mixing
physical addresses and translated addresses into the same address space.
This is mostly mass-renaming calls to memory accesses APIs from places
which expect address translation to use a different version from those
which do not expect address translation.
This does very little on its own, but it's the first step to a correct BAT
implementation.
Admiral H. Curtiss