Welcome to the PSPSOne home page. On this page you will find the latest project status for the PSPSOne emulator.

Many have been inquiring of me as to the current status of the PSPSOne project, and I hope to be able to answer everyone's questions.

PSPSOne is more than an emulator to me. It's a legacy, It's a playable history of video games perfectly preserved from the 90's.

PSPSOne is a promise, it's a promise of being able to play thousands of awesome Playstation games on a whole new portable platform.

Shortly after the PSP was released, a method was discovered how to run homebrew applications on the American 1.5 firmware version.

My first real contribution to the PSP homebrew scene was PSPQuake it took about a week to convert the significant bits of code to make it PSP-compatible.

I had ported Quake for 2 main reasons:

1. I needed a challenge to jump into PSP development.

2. I didn't want to shell out 30-40$ (US) per game.

Now that PSPQuake is out in the wild of the Internet, I've set my sights on true Playstation emulation for the PSP.

You can download the alpha release of PSPSOne here. Don't expect to run Final Fantasy on it quite yet. The alpha release was put out as a proof of concept.

It runs most Playstation iso's (bin files) at about .5 FPS (½ frame per second). Instead of starting completely over and coding up an emulator from scratch,

I based my work off of PCSX. The emulator is running fine in Interpreter mode.

----------------------------------------------------------------------------------------------------------------

A little about emulation:

One question that I often get asked is how things are emulated. Entire books can be written about different emulation methods. The alpha release of PSPSOne is

currently running in Interpreted mode, This is where each instruction is interepreted by the emulator, and an internal representation of the emulated hardware is updated.

For game systems that are significantly slower than the system they are being run on, this is fine. However, to emulate a powerfull system such as the Playstation 1,

an entirely different approach to emulation is needed. Currently, I'm coding a Dynamic Recomplier. This dynamic recomplier takes the original game and re-compiles the

code to the native r4000 instruction set used in the PSP.

----------------------------------------------------------------------------------

Current Status:

The following is the current status on various bits that make up the PSPSOne emulator

Graphics:

Currently, the graphics are all software driven, no attempt has yet been made to use the gu functions of the PSP to increase speed. I have ported over the PeopSoft gpu plugin.

The accuracy of the video emulation is close to 100%, but more can be done to speed things up using hardware rendering functions supported by the PSP.

Sound:

No sound support yet. I have stubbed in some functions that do nothing. I'll get back to this once the video is running faster.

Input:

Basic button support has been added for the input plugin. The controls map over nicely except for the 2^nd stick, and L2 and R2 buttons.

CD-rom Support:

I've put in support for reading .psx files, as well as reading .bin files. I've also added support for reading gzipped bin files int the form of filexx.bin.gz .

Storage space is at a prremium for PSP, so, the more roms you can fit on a memory stick, the better.

Interpreter:

This is the unchanged interpreter that PCSX uses, it works close to 100%, but it's very slow.

Dynamic recompiler:

This is the real heart of the emulator, I have been working to code up a dynamic recompiler to increase the speed of emualtion for some time now, and I've gotten

off to a few false starts.

At first, I believed that because the PS1 and the PSP used simular processors, I could simply filter out the adressing scheme and pass the code from the game

rom to the PSP cpu relatively unchanged. This form of recompiling is known as a “binary address translation”. Unfortunately, this approach did not work as well as I hoped it would,

because of the complexity of the code needed, and because the PSP needed to use those same hardware registers for it's own purposes.

My next attempt was to code a dynamic recompiler that preserved the PS1 usage of registers on the PSP. Unfortunately, this approach suffered from the same outcome as my first attempt,

because the PSP needed those same registers as the PS1, and I had to write a whole bunch of code to swap in/out register values from the stack while remapping

only certain registers. This approach works OK, with about a 7-10X speed increase over the just the interpreted code. This attempt needs a bunch of special code that looks for and

remaps register usage on a pre-code basis, and it is a real pain to work with because of all the special cases.

Now, I'm working on a dynamic recompiler that is much simpler of a design, it makes no attempt to preserve the original register usage, instead, it keeps a set of the PS1's

registers virtually in a block of memory, and when it needs to read/write/operate on a PS1 register, it swaps memory in and out of the PSP registers. I have high hopes for this

version of the dynamic recompiler, and I'm about 65% done with it at this point.

Screenshots:

Here's a screen shot of the title screen for Spider-Man,

Many title screens use a 640x480 graphic, My emu

needs some code to auto-detect 320x240 or 640x480

graphic modes.

Here's a screen shot from Driver, title screen.

Please Donate! shernandez1337@comcast.net
Coding great applications like this port for PSP takes a lot of time and energy, So please, donate so I can continue coding and improving this: shernandez1337@comcast.net