1
0
mirror of https://github.com/TomHarte/CLK.git synced 2024-06-09 17:29:36 +00:00
A latency-hating emulator of 8- and 16-bit platforms: the Acorn Electron, Amstrad CPC, Apple II/II+/IIe and early Macintosh, Atari 2600 and ST, ColecoVision, Enterprise 64/128, Commodore Vic-20 and Amiga, MSX 1, Oric 1/Atmos, Sega Master System, Sinclair
Go to file
Thomas Harte 79ed215254 Merge pull request #57 from TomHarte/Oric
Adds very provisional Oric emulation
2016-10-20 07:39:38 -04:00
Components Implemented non-linear volume. 2016-10-19 23:07:51 -04:00
Concurrency Implemented flush, added a call to it from the filter speaker's destructor, to ensure no race conditions on accessing the various bits of instance state there and below. 2016-10-19 21:15:04 -04:00
Machines Added 60Hz output support. 2016-10-20 07:34:23 -04:00
NumberTheory Calling it 'number theory' probably isn't accurate but extracted the CRC stuff and started using it for [M]FM encoding. 2016-09-18 18:33:26 -04:00
OSBindings/Mac Added an extra safety rail. 2016-10-20 07:36:53 -04:00
Outputs Implemented flush, added a call to it from the filter speaker's destructor, to ensure no race conditions on accessing the various bits of instance state there and below. 2016-10-19 21:15:04 -04:00
Processors/6502 Eventually reached an implementation of ADC that continues to satisfy all the formalised unit tests while also satisfying the manual BCDTest, that I need to find a way to formalise. I fixed the unit tests for Swift 3 while here, and attempted to do some unrelated NIB stuff with no real success. 2016-10-03 22:03:39 -04:00
ROMImages Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770? 2016-09-20 07:36:57 -04:00
SignalProcessing Formalised clock-rate multiplication within disk drives, discovered that the stepper didn't have ideal behaviour for my timed event loop and hence nailed down the semantics a ilttle more. 2016-07-31 13:32:30 -04:00
StaticAnalyser Added enough wiring to get Oric TAPs through to a completely unimplemented Oric emulation. 2016-10-11 22:20:13 -04:00
Storage Removed attempt at multiple-file logic, at least for the time being. Starting to wonder whether I actually need anything beyond a literal streaming of bytes? 2016-10-16 22:15:24 -04:00
.gitignore Reorganised system ROMs out of the Mac-specific folder, adjusted Mac code to expect to find them organised hierarchically (as how many os.roms am I going to have?) and added readme files to explain what's missing from the Git repository. 2016-06-05 08:33:01 -04:00
LICENSE Initial commit 2015-07-16 19:46:52 -04:00
README.md Added formal admission of Oricness. 2016-10-20 07:38:48 -04:00

CLK

CLK is an emulator for tourists that seeks best-in-class accuracy while minimising latency.

So its aims are:

  • single-click load of any piece of source media for any supported platform;
  • with a heavy signal processing tilt for accurate reproduction of original outputs;
  • that aims for the lowest possible latency; and
  • 100% accurate emulations, naturally.

In terms of platforms, it currently contains emulations of the:

  • Acorn Electron;
  • Atari 2600;
  • Oric 1/Atmos; and
  • Commodore Vic-20 (and Commodore 1540/1).

Single-click Loading

Through the combination of static analysis and runtime analysis, CLK seeks to be able automatically to select and configure the appropriate machine to run any provided disk, tape or ROM; to issue any commands necessary to run the software contained on the disk, tape or ROM; and to provide accelerated loading where feasible.

The full process of loading a title — even if you've never used the emulated machine before — is therefore:

  1. locate it in your OS;
  2. double click it.

Signal Processing

Consider an ordinary, unmodified Commodore Vic-20. Its only video output is composite. Therefore the emulated machine's only video output is composite. In order to display the video output, your GPU then decodes composite video. Therefore all composite video artefacts are present and exactly correct, not because of a posthoc filter combining all the subjective effects that this author associates with composite video but because the real signal is really being processed.

Similar effort is put into audio generation. If the real machine normally generates audio at 192Khz then the emulator generates a 192Khz source signal and filters it down to whatever the host machine can output.

If your machine has a 4k monitor and a 96Khz audio output? Then you'll get a 4k rendering of a composite display and, assuming the emulated machine produces source audio at or above 96Khz, 96,000 individual distinct audio samples a second. Interlaced video also works and looks much as it always did on those machines that produce it.

Low Latency

The display produced is an emulated CRT, with phosphor decay. Therefore if you have a 140Hz monitor it can produce 140 distinct frames per second. Latency is dictated by the output hardware, not the emulated machine.

The machine update mechanism is influenced separately by both screen refresh and audio stream processing; audio latency is therefore generally restrained to 510ms regardless of your screen's refresh rate.

A corollary of emulating the continuous nature CRT, not merely performing end-of-frame transcriptions, is that the most common motion aliasing effects of displaying 50Hz video on a 60Hz display are minimised; you don't have to own niche equipment to benefit.

Accurate Emulation

Cycle-accurate emulation for the supported target machines is fairly trite now; this emulator seeks to follow that well-trodden path. All emulation logic is written in C++ for explicit control over costs but, where a conflict arises, the presumption is towards clarity and simplicity of code. This emulator is willing to spend the processing resources available on modern hardware.

Which are polite ways of saying that it's generally slower than the standard bearers for each supported platform but that if it's comfortably within the processing ability of a semi-modern computer then that's not considered problematic.