6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-11-04 15:05:36 +00:00
Code Issues Projects Releases Wiki Activity
d221c712b0
CLK/Machines/Electron/Electron.cpp

1039 lines
30 KiB
C++
Raw Normal View History

Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
//
// Electron.cpp
// Clock Signal
//
// Created by Thomas Harte on 03/01/2016.
// Copyright © 2016 Thomas Harte. All rights reserved.
//
#include "Electron.hpp"
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
#include "TapeUEF.hpp"
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
#include <algorithm>
Simplified the run builder rather; put a double check of Electron timing in place.
2016-02-26 03:01:42 +00:00
#include <cassert>
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
using namespace Electron;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
namespace {
static const unsigned int cycles_per_line = 128;
static const unsigned int lines_per_frame = 625;
static const unsigned int cycles_per_frame = lines_per_frame * cycles_per_line;
static const unsigned int crt_cycles_multiplier = 8;
static const unsigned int crt_cycles_per_line = crt_cycles_multiplier * cycles_per_line;
static const unsigned int field_divider_line = 312; // i.e. the line, simultaneous with which, the first field's sync ends. So if
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +00:00
// the first line with pixels in field 1 is the 20th in the frame, the first line
// with pixels in field 2 will be 20+field_divider_line
static const unsigned int first_graphics_line = 31;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
static const unsigned int first_graphics_cycle = 33;
Moved interrupt back down to where it's probably meant to be.
2016-03-13 04:18:46 +00:00
static const unsigned int display_end_interrupt_line = 256;
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +00:00
static const unsigned int real_time_clock_interrupt_1 = 16704;
static const unsigned int real_time_clock_interrupt_2 = 56704;
Introduced a compile-time configurable audio divider, set it arbitrarily to '8' for now. Discovered why my graphics aren't centred and added a TODO.
2016-04-14 02:31:59 +00:00
Wired in options, at least getting as far as the Objective-C bridge. Then fast loading makes it to the emulated machine, display output type doesn't.
2016-04-18 12:21:00 +00:00
static const unsigned int clock_rate_audio_divider = 8;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
#define graphics_line(v) ((((v) >> 7) - first_graphics_line + field_divider_line) % field_divider_line)
Access timing now appears to be exactly on the nail. Disabled automatic interrupt expiration again as I'm not persuaded it's correct for at least the RTC.
2016-03-11 04:12:28 +00:00
#define graphics_column(v) ((((v) & 127) - first_graphics_cycle + 128) & 127)
Disabled my various bits of rate interchange debugging; improved test for when to call update_display due to a RAM write.
2016-01-22 03:16:52 +00:00
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
Machine::Machine() :
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_control(0),
_interrupt_status(Interrupt::PowerOnReset),
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_frameCycles(0),
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
_displayOutputPosition(0),
_audioOutputPosition(0),
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_current_pixel_line(-1),
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
_use_fast_tape_hack(false),
Colour phase is now updated and varies per line.
2016-04-22 01:07:29 +00:00
_crt(nullptr),
_phase(0)
Switched to two-phase setup to deal with OpenGL scheduling.
2016-03-20 17:50:13 +00:00
{
memset(_key_states, 0, sizeof(_key_states));
memset(_palette, 0xf, sizeof(_palette));
for(int c = 0; c < 16; c++)
memset(_roms[c], 0xff, 16384);
_tape.set_delegate(this);
}
Ensured machines can nominate their own aspect ratio windows. Switched to 11/10 for the Electron.
2016-04-12 03:12:56 +00:00
void Machine::setup_output(float aspect_ratio)
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
{
Fixes: drop any processing backlog, try not to allow an Electron document to close mid-draw, perform a frame grab even if the emulated machine is over-processing, really really don't create a CRT until it's safe.
2016-03-20 22:42:37 +00:00
_crt = std::unique_ptr<Outputs::CRT::CRT>(new Outputs::CRT::CRT(crt_cycles_per_line, 8, Outputs::CRT::DisplayType::PAL50, 1));
Made an attempt to switch to the flywheels for both vertical and horizontal sync, and to act more appropriately for out-of-bounds sync requests. Lots of tweaking to do, I fear.
2016-02-12 04:43:08 +00:00
_crt->set_rgb_sampling_function(
Made an attempt slightly to simplify the fragment processor, at both ends.
2016-04-13 02:35:11 +00:00
"vec3 rgb_sample(usampler2D sampler, vec2 coordinate, vec2 icoordinate)"
There is now a semi-reasonable amount of screen output again.
2016-02-06 02:35:39 +00:00
"{"
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
"uint texValue = texture(sampler, coordinate).r;"
Minor simplification.
2016-04-13 23:19:04 +00:00
"texValue >>= 4 - (int(icoordinate.x * 8) & 4);"
Made an attempt slightly to simplify the fragment processor, at both ends.
2016-04-13 02:35:11 +00:00
"return vec3( uvec3(texValue) & uvec3(4u, 2u, 1u));"
Onward with carrying this through to the bitter end, this at least results in all the appropriate knowledge and call-ins occuring at the CRT.
2016-02-05 03:28:50 +00:00
"}");
Introduced a compile-time configurable audio divider, set it arbitrarily to '8' for now. Discovered why my graphics aren't centred and added a TODO.
2016-04-14 02:31:59 +00:00
// TODO: as implied below, I've introduced a clock's latency into the graphics pipeline somehow. Investigate.
_crt->set_visible_area(_crt->get_rect_for_area(first_graphics_line - 3, 256, (first_graphics_cycle+1) * crt_cycles_multiplier, 80 * crt_cycles_multiplier, 4.0f / 3.0f));
Onward with carrying this through to the bitter end, this at least results in all the appropriate knowledge and call-ins occuring at the CRT.
2016-02-05 03:28:50 +00:00
Simplified sound generation.
2016-04-05 02:22:19 +00:00
// The maximum output frequency is 62500Hz and all other permitted output frequencies are integral divisions of that;
Turned audio quality up to the maximum, at least for now.
2016-04-07 01:12:22 +00:00
// however setting the speaker on or off can happen on any 2Mhz cycle, and probably (?) takes effect immediately. So
// run the speaker at a 2000000Hz input rate, at least for the time being.
Introduced a compile-time configurable audio divider, set it arbitrarily to '8' for now. Discovered why my graphics aren't centred and added a TODO.
2016-04-14 02:31:59 +00:00
_speaker.set_input_rate(2000000 / clock_rate_audio_divider);
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
}
Ensured GL context is active when destructing CRTOpenGL.
2016-04-25 00:34:25 +00:00
void Machine::close_output()
{
_crt = nullptr;
}
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
unsigned int Machine::perform_bus_operation(CPU6502::BusOperation operation, uint16_t address, uint8_t *value)
{
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
unsigned int cycles = 1;
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
if(address < 0x8000)
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
{
if(isReadOperation(operation))
{
This at least now connects up a CRT, though it never talks to it.
2016-01-08 03:26:49 +00:00
*value = _ram[address];
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
else
{
Attemted further to diminish jumpiness.
2016-03-23 02:07:30 +00:00
if(
(
((_frameCycles >= first_graphics_line * cycles_per_line) && (_frameCycles < (first_graphics_line + 256) * cycles_per_line)) ||
((_frameCycles >= (first_graphics_line + field_divider_line) * cycles_per_line) && (_frameCycles < (first_graphics_line + 256 + field_divider_line) * cycles_per_line))
)
)
Disabled my various bits of rate interchange debugging; improved test for when to call update_display due to a RAM write.
2016-01-22 03:16:52 +00:00
update_display();
Switched display update and RAM write order.
2016-01-12 03:29:16 +00:00
_ram[address] = *value;
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
This at least now connects up a CRT, though it never talks to it.
2016-01-08 03:26:49 +00:00
Disabled my various bits of rate interchange debugging; improved test for when to call update_display due to a RAM write.
2016-01-22 03:16:52 +00:00
// for the entire frame, RAM is accessible only on odd cycles; in modes below 4
// it's also accessible only outside of the pixel regions
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
cycles += 1 + (_frameCycles&1);
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(_screen_mode < 4)
Made an attempt at correct timing, adding support for additional paged ROMs, added file association for .rom.
2016-01-13 03:34:26 +00:00
{
Switched to probably more accurate contended memory, resolved issue of not leaving the tape data received interrupt set when returning a byte from the fast tape, fixing Joe Blade, and tested slightly further to determine that interrupts probably signal upon entry into horizontal sync.
2016-03-14 23:29:28 +00:00
const int current_line = graphics_line(_frameCycles + (_frameCycles&1));
const int current_column = graphics_column(_frameCycles + (_frameCycles&1));
Access timing now appears to be exactly on the nail. Disabled automatic interrupt expiration again as I'm not persuaded it's correct for at least the RTC.
2016-03-11 04:12:28 +00:00
if(current_line < 256 && current_column < 80 && !_isBlankLine)
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
cycles += (unsigned int)(80 - current_column);
Made an attempt at correct timing, adding support for additional paged ROMs, added file association for .rom.
2016-01-13 03:34:26 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
else
{
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
if(address >= 0xc000)
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
{
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
if((address & 0xff00) == 0xfe00)
{
switch(address&0xf)
{
case 0x0:
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(isReadOperation(operation))
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
*value = _interrupt_status;
Some minor optimisations and timing tweaks. Nothing of substance.
2016-03-11 00:58:50 +00:00
_interrupt_status &= ~PowerOnReset;
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
else
{
Fixed: setting an interrupt control value with the lowest bit set could result in interrupts that can't be disabled.
2016-03-13 03:55:33 +00:00
_interrupt_control = (*value) & ~1;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
evaluate_interrupts();
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x1:
break;
case 0x2:
Fixed: attempting to read the screen start address no longer alters it.
2016-03-13 22:50:23 +00:00
if(!isReadOperation(operation))
{
_startScreenAddress = (_startScreenAddress & 0xfe00) | (uint16_t)(((*value) & 0xe0) << 1);
if(!_startScreenAddress) _startScreenAddress |= 0x8000;
}
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
break;
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
case 0x3:
Fixed: attempting to read the screen start address no longer alters it.
2016-03-13 22:50:23 +00:00
if(!isReadOperation(operation))
{
_startScreenAddress = (_startScreenAddress & 0x01ff) | (uint16_t)(((*value) & 0x3f) << 9);
if(!_startScreenAddress) _startScreenAddress |= 0x8000;
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x4:
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
if(isReadOperation(operation))
{
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
*value = _tape.get_data_register();
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
Shushed.
2016-01-20 04:33:15 +00:00
else
{
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_data_register(*value);
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_tape.clear_interrupts(Interrupt::TransmitDataEmpty);
Shushed.
2016-01-20 04:33:15 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x5:
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(!isReadOperation(operation))
{
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
const uint8_t interruptDisable = (*value)&0xf0;
if( interruptDisable )
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if( interruptDisable&0x10 ) _interrupt_status &= ~Interrupt::DisplayEnd;
if( interruptDisable&0x20 ) _interrupt_status &= ~Interrupt::RealTimeClock;
if( interruptDisable&0x40 ) _interrupt_status &= ~Interrupt::HighToneDetect;
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
evaluate_interrupts();
Removed some logging.
2016-02-07 19:42:40 +00:00
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
// TODO: NMI (?)
}
// else
{
uint8_t nextROM = (*value)&0xf;
// if(nextROM&0x08)
// {
// _activeRom = (Electron::ROMSlot)(nextROM&0x0e);
// printf("%d -> Paged %d\n", nextROM, _activeRom);
// }
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(((_active_rom&12) != 8) || (nextROM&8))
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_active_rom = (Electron::ROMSlot)nextROM;
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
}
// else
// {
// printf("Ignored!");
// }
// printf("%d -> Paged %d\n", nextROM, _activeRom);
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x6:
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
if(!isReadOperation(operation))
{
Resolved some errors.
2016-01-14 03:11:33 +00:00
update_audio();
_speaker.set_divider(*value);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_counter(*value);
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x7:
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
if(!isReadOperation(operation))
{
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
// update screen mode
uint8_t new_screen_mode = ((*value) >> 3)&7;
if(new_screen_mode == 7) new_screen_mode = 4;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(new_screen_mode != _screen_mode)
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// printf("To mode %d, at %d cycles into field (%d)\n", new_screen_mode, _fieldCycles, _fieldCycles >> 7);
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
update_display();
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_screen_mode = new_screen_mode;
switch(_screen_mode)
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
{
case 0: case 1: case 2: _screenModeBaseAddress = 0x3000; break;
case 3: _screenModeBaseAddress = 0x4000; break;
case 4: case 5: _screenModeBaseAddress = 0x5800; break;
case 6: _screenModeBaseAddress = 0x6000; break;
}
}
// update speaker mode
bool new_speaker_is_enabled = (*value & 6) == 2;
Resolved some errors.
2016-01-14 03:11:33 +00:00
if(new_speaker_is_enabled != _speaker.get_is_enabled())
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
update_audio();
Resolved some errors.
2016-01-14 03:11:33 +00:00
_speaker.set_is_enabled(new_speaker_is_enabled);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_is_enabled(!new_speaker_is_enabled);
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
_tape.set_is_running(((*value)&0x40) ? true : false);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_is_in_input_mode(((*value)&0x04) ? false : true);
// TODO: caps lock LED
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
default:
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
if(!isReadOperation(operation))
{
update_display();
static const int registers[4][4] = {
{10, 8, 2, 0},
{14, 12, 6, 4},
{15, 13, 7, 5},
{11, 9, 3, 1},
};
const int index = (address >> 1)&3;
const uint8_t colour = ~(*value);
if(address&1)
{
_palette[registers[index][0]] = (_palette[registers[index][0]]&3) | ((colour >> 1)&4);
_palette[registers[index][1]] = (_palette[registers[index][1]]&3) | ((colour >> 0)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&3) | ((colour << 1)&4);
_palette[registers[index][3]] = (_palette[registers[index][3]]&3) | ((colour << 2)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&5) | ((colour >> 4)&2);
_palette[registers[index][3]] = (_palette[registers[index][3]]&5) | ((colour >> 3)&2);
}
else
{
_palette[registers[index][0]] = (_palette[registers[index][0]]&6) | ((colour >> 7)&1);
_palette[registers[index][1]] = (_palette[registers[index][1]]&6) | ((colour >> 6)&1);
_palette[registers[index][2]] = (_palette[registers[index][2]]&6) | ((colour >> 5)&1);
_palette[registers[index][3]] = (_palette[registers[index][3]]&6) | ((colour >> 4)&1);
_palette[registers[index][0]] = (_palette[registers[index][0]]&5) | ((colour >> 2)&2);
_palette[registers[index][1]] = (_palette[registers[index][1]]&5) | ((colour >> 1)&2);
}
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
// regenerate all palette tables for now
#define pack(a, b) (uint8_t)((a << 4) | (b))
for(int byte = 0; byte < 256; byte++)
{
uint8_t *target = (uint8_t *)&_paletteTables.forty1bpp[byte];
target[0] = pack(_palette[(byte&0x80) >> 4], _palette[(byte&0x40) >> 3]);
target[1] = pack(_palette[(byte&0x20) >> 2], _palette[(byte&0x10) >> 1]);
target = (uint8_t *)&_paletteTables.eighty2bpp[byte];
target[0] = pack(_palette[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], _palette[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]);
target[1] = pack(_palette[((byte&0x20) >> 2) | ((byte&0x02) >> 0)], _palette[((byte&0x10) >> 1) | ((byte&0x01) << 1)]);
target = (uint8_t *)&_paletteTables.eighty1bpp[byte];
target[0] = pack(_palette[(byte&0x80) >> 4], _palette[(byte&0x40) >> 3]);
target[1] = pack(_palette[(byte&0x20) >> 2], _palette[(byte&0x10) >> 1]);
target[2] = pack(_palette[(byte&0x08) >> 0], _palette[(byte&0x04) << 1]);
target[3] = pack(_palette[(byte&0x02) << 2], _palette[(byte&0x01) << 3]);
_paletteTables.forty2bpp[byte] = pack(_palette[((byte&0x80) >> 4) | ((byte&0x08) >> 2)], _palette[((byte&0x40) >> 3) | ((byte&0x04) >> 1)]);
_paletteTables.eighty4bpp[byte] = pack( _palette[((byte&0x80) >> 4) | ((byte&0x20) >> 3) | ((byte&0x08) >> 2) | ((byte&0x02) >> 1)],
_palette[((byte&0x40) >> 3) | ((byte&0x10) >> 2) | ((byte&0x04) >> 1) | ((byte&0x01) >> 0)]);
}
#undef pack
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
}
}
else
{
if(isReadOperation(operation))
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
if(
_use_fast_tape_hack &&
Resolved potential crash if tape requests are made without one inserted. Softened glFinish to glFlush, though I'm still not sure I should strictly need even that.
2016-04-20 01:00:48 +00:00
_tape.has_tape() &&
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
(operation == CPU6502::BusOperation::ReadOpcode) &&
(
(address == 0xf4e5) || (address == 0xf4e6) || // double NOPs at 0xf4e5, 0xf6de, 0xf6fa and 0xfa51
(address == 0xf6de) || (address == 0xf6df) || // act to disable the normal branch into tape-handling
(address == 0xf6fa) || (address == 0xf6fb) || // code, forcing the OS along the serially-accessed ROM
(address == 0xfa51) || (address == 0xfa52) || // pathway.
(address == 0xf0a8) // 0xf0a8 is from where a service call would normally be
// dispatched; we can check whether it would be call 14
// (i.e. read byte) and, if so, whether the OS was about to
// issue a read byte call to a ROM despite being the tape
// FS being selected. If so then this is a get byte that
// we should service synthetically. Put the byte into Y
// and set A to zero to report that action was taken, then
// allow the PC read to return an RTS.
)
)
{
uint8_t service_call = (uint8_t)get_value_of_register(CPU6502::Register::X);
if(address == 0xf0a8)
{
if(!_ram[0x247] && service_call == 14)
{
_tape.set_delegate(nullptr);
// TODO: handle tape wrap around.
int cycles_left_while_plausibly_in_data = 50;
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
while(1)
{
Made a further guess at the state interrupts would probably be left; slightly simplified interface.
2016-03-15 02:42:52 +00:00
_tape.run_for_input_pulse();
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
cycles_left_while_plausibly_in_data--;
if(!cycles_left_while_plausibly_in_data) _fast_load_is_in_data = false;
Made a further guess at the state interrupts would probably be left; slightly simplified interface.
2016-03-15 02:42:52 +00:00
if( (_tape.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
(_fast_load_is_in_data || _tape.get_data_register() == 0x2a)
) break;
}
_tape.set_delegate(this);
Made a further guess at the state interrupts would probably be left; slightly simplified interface.
2016-03-15 02:42:52 +00:00
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
Switched to probably more accurate contended memory, resolved issue of not leaving the tape data received interrupt set when returning a byte from the fast tape, fixing Joe Blade, and tested slightly further to determine that interrupts probably signal upon entry into horizontal sync.
2016-03-14 23:29:28 +00:00
_interrupt_status |= _tape.get_interrupt_status();
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
_fast_load_is_in_data = true;
set_value_of_register(CPU6502::Register::A, 0);
set_value_of_register(CPU6502::Register::Y, _tape.get_data_register());
*value = 0x60; // 0x60 is RTS
}
else
*value = _os[address & 16383];
}
else
*value = 0xea;
}
else
{
*value = _os[address & 16383];
}
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
else
{
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(isReadOperation(operation))
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
switch(_active_rom)
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
{
case ROMSlotKeyboard:
case ROMSlotKeyboard+1:
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
*value = 0xf0;
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
for(int address_line = 0; address_line < 14; address_line++)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(!(address&(1 << address_line))) *value |= _key_states[address_line];
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
}
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
break;
default:
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
*value = _roms[_active_rom][address & 16383];
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
break;
}
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
}
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
// if(operation == CPU6502::BusOperation::ReadOpcode)
// {
Made an attempt to put interrupts in the correct places regardless of even/odd field.
2016-02-17 01:36:19 +00:00
// printf("%04x: %02x (%d)\n", address, *value, _fieldCycles);
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
// }
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +00:00
// const int end_of_field =
// if (_frameCycles < (256 + first_graphics_line) << 7))
Switched to probably more accurate contended memory, resolved issue of not leaving the tape data received interrupt set when returning a byte from the fast tape, fixing Joe Blade, and tested slightly further to determine that interrupts probably signal upon entry into horizontal sync.
2016-03-14 23:29:28 +00:00
const unsigned int pixel_line_clock = _frameCycles;// + 128 - first_graphics_cycle + 80;
Fixed: timing issue versus supplied test ROM was failure to include the Plus 1 ROM in the mix.
2016-03-12 16:51:20 +00:00
const unsigned int line_before_cycle = graphics_line(pixel_line_clock);
const unsigned int line_after_cycle = graphics_line(pixel_line_clock + cycles);
Fixed RAM timings: it's at least two and possibly three cycles to access RAM, and an access that overlaps with video fetch in Modes 0–3 will cost the length of the video fetch rather than somehow finishing in time.
2016-03-11 00:04:43 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// implicit assumption here: the number of 2Mhz cycles this bus operation will take
// is never longer than a line. On the Electron, it's a safe one.
Access timing now appears to be exactly on the nail. Disabled automatic interrupt expiration again as I'm not persuaded it's correct for at least the RTC.
2016-03-11 04:12:28 +00:00
if(line_before_cycle != line_after_cycle)
Made an attempt to put interrupts in the correct places regardless of even/odd field.
2016-02-17 01:36:19 +00:00
{
Access timing now appears to be exactly on the nail. Disabled automatic interrupt expiration again as I'm not persuaded it's correct for at least the RTC.
2016-03-11 04:12:28 +00:00
switch(line_before_cycle)
{
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +00:00
// case real_time_clock_interrupt_line: signal_interrupt(Interrupt::RealTimeClock); break;
Access timing now appears to be exactly on the nail. Disabled automatic interrupt expiration again as I'm not persuaded it's correct for at least the RTC.
2016-03-11 04:12:28 +00:00
// case real_time_clock_interrupt_line+1: clear_interrupt(Interrupt::RealTimeClock); break;
case display_end_interrupt_line: signal_interrupt(Interrupt::DisplayEnd); break;
// case display_end_interrupt_line+1: clear_interrupt(Interrupt::DisplayEnd); break;
}
These interrupts apparently last only 64µs at most.
2016-03-11 00:10:53 +00:00
}
Fixed RAM timings: it's at least two and possibly three cycles to access RAM, and an access that overlaps with video fetch in Modes 0–3 will cost the length of the video fetch rather than somehow finishing in time.
2016-03-11 00:04:43 +00:00
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +00:00
if(
(pixel_line_clock < real_time_clock_interrupt_1 && pixel_line_clock + cycles >= real_time_clock_interrupt_1) ||
(pixel_line_clock < real_time_clock_interrupt_2 && pixel_line_clock + cycles >= real_time_clock_interrupt_2))
{
signal_interrupt(Interrupt::RealTimeClock);
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_frameCycles += cycles;
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
Colour phase is now updated and varies per line.
2016-04-22 01:07:29 +00:00
if(!(_frameCycles&127)) _phase += 64;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// deal with frame wraparound by updating the two dependent subsystems
// as though the exact end of frame had been hit, then reset those
// and allow the frame cycle counter to assume its real value
if(_frameCycles >= cycles_per_frame)
Fixed RAM timings: it's at least two and possibly three cycles to access RAM, and an access that overlaps with video fetch in Modes 0–3 will cost the length of the video fetch rather than somehow finishing in time.
2016-03-11 00:04:43 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
unsigned int nextFrameCycles = _frameCycles - cycles_per_frame;
_frameCycles = cycles_per_frame;
Fixed RAM timings: it's at least two and possibly three cycles to access RAM, and an access that overlaps with video fetch in Modes 0–3 will cost the length of the video fetch rather than somehow finishing in time.
2016-03-11 00:04:43 +00:00
update_display();
update_audio();
_displayOutputPosition = 0;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_audioOutputPosition = 0;
_frameCycles = nextFrameCycles;
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
Turned audio quality up to the maximum, at least for now.
2016-04-07 01:12:22 +00:00
if(!(_frameCycles&16383))
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
update_audio();
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
_tape.run_for_cycles(cycles);
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
return cycles;
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
Fixes: now setting correct frame time estimate, properly enabling the timestamp attribute, and ensuring that the Electron flushes screen work at least once per host frame update.
2016-02-15 00:28:02 +00:00
void Machine::update_output()
{
update_display();
update_audio();
}
Moved set_tape so that the inline definition of get_next_tape_pulse is visible to it. Also eliminated some dead typedefs.
2016-01-20 13:27:25 +00:00
void Machine::set_tape(std::shared_ptr<Storage::Tape> tape)
{
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
_tape.set_tape(tape);
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
void Machine::set_rom(ROMSlot slot, size_t length, const uint8_t *data)
{
uint8_t *target = nullptr;
switch(slot)
{
Made an attempt at correct timing, adding support for additional paged ROMs, added file association for .rom.
2016-01-13 03:34:26 +00:00
case ROMSlotOS: target = _os; break;
default: target = _roms[slot]; break;
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
memcpy(target, data, std::min((size_t)16384, length));
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
inline void Machine::signal_interrupt(Electron::Interrupt interrupt)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status |= interrupt;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
evaluate_interrupts();
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
inline void Machine::clear_interrupt(Electron::Interrupt interrupt)
{
_interrupt_status &= ~interrupt;
evaluate_interrupts();
}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
void Machine::tape_did_change_interrupt_status(Tape *tape)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status = (_interrupt_status & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | _tape.get_interrupt_status();
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
evaluate_interrupts();
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
inline void Machine::evaluate_interrupts()
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(_interrupt_status & _interrupt_control)
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status |= 1;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
else
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status &= ~1;
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
}
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
set_irq_line(_interrupt_status & 1);
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
inline void Machine::update_audio()
{
Introduced a compile-time configurable audio divider, set it arbitrarily to '8' for now. Discovered why my graphics aren't centred and added a TODO.
2016-04-14 02:31:59 +00:00
unsigned int difference = _frameCycles - _audioOutputPosition;
_audioOutputPosition = _frameCycles;
_speaker.run_for_cycles(difference / clock_rate_audio_divider);
_audioOutputPositionError = difference % clock_rate_audio_divider;
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
inline void Machine::start_pixel_line()
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_current_pixel_line = (_current_pixel_line+1)&255;
if(!_current_pixel_line)
{
_startLineAddress = _startScreenAddress;
Blank lines are back.
2016-03-11 03:19:54 +00:00
_current_character_row = 0;
_isBlankLine = false;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
else
{
Blank lines are back.
2016-03-11 03:19:54 +00:00
bool mode_has_blank_lines = (_screen_mode == 6) || (_screen_mode == 3);
_isBlankLine = (mode_has_blank_lines && ((_current_character_row > 7 && _current_character_row < 10) || (_current_pixel_line > 249)));
if(!_isBlankLine)
{
_startLineAddress++;
if(_current_character_row > 7)
{
_startLineAddress += ((_screen_mode < 4) ? 80 : 40) * 8 - 8;
_current_character_row = 0;
}
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
_currentScreenAddress = _startLineAddress;
_current_pixel_column = 0;
Made an attempt to reduce the amount of data heading to the GPU.
2016-03-23 01:16:32 +00:00
_current_output_target = nullptr;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
inline void Machine::end_pixel_line()
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Made an attempt to reduce the amount of data heading to the GPU.
2016-03-23 01:16:32 +00:00
if(_current_output_target) _crt->output_data((unsigned int)((_current_output_target - _initial_output_target) * _current_output_divider), _current_output_divider);
Blank lines are back.
2016-03-11 03:19:54 +00:00
_current_character_row++;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
inline void Machine::output_pixels(unsigned int number_of_cycles)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
if(!number_of_cycles) return;
Blank lines are back.
2016-03-11 03:19:54 +00:00
if(_isBlankLine)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Blank lines are back.
2016-03-11 03:19:54 +00:00
_crt->output_blank(number_of_cycles * crt_cycles_multiplier);
}
else
{
Made an attempt to reduce the amount of data heading to the GPU.
2016-03-23 01:16:32 +00:00
unsigned int divider = 0;
switch(_screen_mode)
{
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
case 0: case 3: divider = 2; break;
case 1: case 4: case 6: divider = 4; break;
case 2: case 5: divider = 8; break;
Made an attempt to reduce the amount of data heading to the GPU.
2016-03-23 01:16:32 +00:00
}
if(!_current_output_target || divider != _current_output_divider)
{
if(_current_output_target) _crt->output_data((unsigned int)((_current_output_target - _initial_output_target) * _current_output_divider), _current_output_divider);
_current_output_divider = divider;
_initial_output_target = _current_output_target = _crt->allocate_write_area(640 / _current_output_divider);
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
#define get_pixel() \
if(_currentScreenAddress&32768)\
{\
_currentScreenAddress = (_screenModeBaseAddress + _currentScreenAddress)&32767;\
}\
_last_pixel_byte = _ram[_currentScreenAddress];\
_currentScreenAddress = _currentScreenAddress+8
Blank lines are missing (if the double negative can be forgiven) but the framebuffer is otherwise seemingly working well again.
2016-02-20 05:11:23 +00:00
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
switch(_screen_mode)
{
case 0: case 3:
while(number_of_cycles--)
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
{
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
get_pixel();
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
*(uint32_t *)_current_output_target = _paletteTables.eighty1bpp[_last_pixel_byte];
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
_current_output_target += 4;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
_current_pixel_column++;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
break;
Blank lines are back.
2016-03-11 03:19:54 +00:00
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
case 1:
while(number_of_cycles--)
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
{
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
get_pixel();
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
*(uint16_t *)_current_output_target = _paletteTables.eighty2bpp[_last_pixel_byte];
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
_current_output_target += 2;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
_current_pixel_column++;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
break;
Made an attempt to reintroduce interlacing and screen modes with gaps. Something's wrong with synchronisation though, so most likely I'm outputting a bad signal.
2016-02-20 22:32:51 +00:00
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
case 2:
while(number_of_cycles--)
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
{
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
get_pixel();
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
*_current_output_target = _paletteTables.eighty4bpp[_last_pixel_byte];
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
_current_output_target += 1;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
_current_pixel_column++;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
break;
Blank lines are back.
2016-03-11 03:19:54 +00:00
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
case 4: case 6:
if(_current_pixel_column&1)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Shifted responsibility for byte shifts, probably to a more logical place.
2016-04-06 02:19:14 +00:00
_last_pixel_byte <<= 4;
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
_current_output_target += 2;
number_of_cycles--;
_current_pixel_column++;
}
while(number_of_cycles > 1)
{
get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
_current_output_target += 2;
Shifted responsibility for byte shifts, probably to a more logical place.
2016-04-06 02:19:14 +00:00
_last_pixel_byte <<= 4;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
_current_output_target += 2;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
number_of_cycles -= 2;
_current_pixel_column+=2;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
if(number_of_cycles)
{
get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
_current_output_target += 2;
_current_pixel_column++;
}
break;
Blank lines are back.
2016-03-11 03:19:54 +00:00
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
case 5:
if(_current_pixel_column&1)
Blank lines are back.
2016-03-11 03:19:54 +00:00
{
Shifted responsibility for byte shifts, probably to a more logical place.
2016-04-06 02:19:14 +00:00
_last_pixel_byte <<= 2;
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
Expanded interface to rgb_sample to eliminate its need to make assumptions about globals, used expanded interface to compact Electron data to two pixels per byte.
2016-04-06 00:32:55 +00:00
_current_output_target += 1;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
number_of_cycles--;
_current_pixel_column++;
Blank lines are back.
2016-03-11 03:19:54 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
while(number_of_cycles > 1)
{
get_pixel();
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
_current_output_target += 1;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
Shifted responsibility for byte shifts, probably to a more logical place.
2016-04-06 02:19:14 +00:00
_last_pixel_byte <<= 2;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
_current_output_target += 1;
number_of_cycles -= 2;
_current_pixel_column+=2;
}
if(number_of_cycles)
{
get_pixel();
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
_current_output_target += 1;
_current_pixel_column++;
}
break;
Blank lines are back.
2016-03-11 03:19:54 +00:00
}
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
#undef get_pixel
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
}
Played about with interrupt timing.
2016-02-21 02:24:02 +00:00
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
inline void Machine::update_display()
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
/*
Made an attempt to reintroduce interlacing and screen modes with gaps. Something's wrong with synchronisation though, so most likely I'm outputting a bad signal.
2016-02-20 22:32:51 +00:00
Odd field: Even field:
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
Made an attempt to reintroduce interlacing and screen modes with gaps. Something's wrong with synchronisation though, so most likely I'm outputting a bad signal.
2016-02-20 22:32:51 +00:00
|--S--| -S-|
|--S--| |--S--|
|-S-B-| = 3 |--S--| = 2.5
|--B--| |--B--|
|--P--| |--P--|
|--B--| = 312 |--B--| = 312.5
|-B-
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
*/
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
int final_line = _frameCycles >> 7;
while(_displayOutputPosition < _frameCycles)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
int line = _displayOutputPosition >> 7;
// Priority one: sync.
// ===================
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// full sync lines are 0, 1, field_divider_line+1 and field_divider_line+2
if(line == 0 || line == 1 || line == field_divider_line+1 || line == field_divider_line+2)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// wait for the line to complete before signalling
if(final_line == line) return;
I discovered a further post on this on the STH forums; apparently the Electron simply asserts sync continuously. No breaks.
2016-04-12 01:01:09 +00:00
_crt->output_sync(128 * crt_cycles_multiplier);
Simplified the run builder rather; put a double check of Electron timing in place.
2016-02-26 03:01:42 +00:00
_displayOutputPosition += 128;
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
continue;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// line 2 is a left-sync line
if(line == 2)
{
// wait for the line to complete before signalling
if(final_line == line) return;
I discovered a further post on this on the STH forums; apparently the Electron simply asserts sync continuously. No breaks.
2016-04-12 01:01:09 +00:00
_crt->output_sync(64 * crt_cycles_multiplier);
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_crt->output_blank(64 * crt_cycles_multiplier);
_displayOutputPosition += 128;
continue;
}
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// line field_divider_line is a right-sync line
if(line == field_divider_line)
{
// wait for the line to complete before signalling
if(final_line == line) return;
Switched horizontal sync detection back to differential, switched the Electron to an XOR-style sync output (believed to be accurate, but I need to check), fixed some latent issues around vertical sync detection.
2016-04-11 01:34:40 +00:00
_crt->output_sync(9 * crt_cycles_multiplier);
_crt->output_blank(55 * crt_cycles_multiplier);
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_crt->output_sync(64 * crt_cycles_multiplier);
_displayOutputPosition += 128;
continue;
}
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// Priority two: blank lines.
// ==========================
//
// Given that it is not a sync line, this is a blank line if it is less than first_graphics_line, or greater
// than first_graphics_line+255 and less than first_graphics_line+field_divider_line, or greater than
// first_graphics_line+field_divider_line+255 (TODO: or this is Mode 3 or 6 and this should be blank)
if(
line < first_graphics_line ||
(line > first_graphics_line+255 && line < first_graphics_line+field_divider_line) ||
line > first_graphics_line+field_divider_line+255)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
if(final_line == line) return;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_crt->output_sync(9 * crt_cycles_multiplier);
_crt->output_blank(119 * crt_cycles_multiplier);
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_displayOutputPosition += 128;
continue;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// Final possibility: this is a pixel line.
// ========================================
// determine how far we're going from left to right
unsigned int this_cycle = _displayOutputPosition&127;
unsigned int final_cycle = _frameCycles&127;
if(final_line > line)
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
final_cycle = 128;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// output format is:
// 9 cycles: sync
// ... to 24 cycles: colour burst
// ... to first_graphics_cycle: blank
// ... for 80 cycles: pixels
// ... until end of line: blank
while(this_cycle < final_cycle)
{
if(this_cycle < 9)
{
if(final_cycle < 9) return;
_crt->output_sync(9 * crt_cycles_multiplier);
_displayOutputPosition += 9;
this_cycle = 9;
}
Hard-coded to 40 columns of black and white, here's some text, at least.
2016-01-10 03:39:46 +00:00
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
if(this_cycle < 24)
{
if(final_cycle < 24) return;
Colour phase is now updated and varies per line.
2016-04-22 01:07:29 +00:00
_crt->output_colour_burst((24-9) * crt_cycles_multiplier, _phase, 12);
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_displayOutputPosition += 24-9;
this_cycle = 24;
// TODO: phase shouldn't be zero on every line
}
if(this_cycle < first_graphics_cycle)
{
if(final_cycle < first_graphics_cycle) return;
_crt->output_blank((first_graphics_cycle - 24) * crt_cycles_multiplier);
_displayOutputPosition += first_graphics_cycle - 24;
this_cycle = first_graphics_cycle;
start_pixel_line();
}
if(this_cycle < first_graphics_cycle + 80)
{
unsigned int length_to_output = std::min(final_cycle, (first_graphics_cycle + 80)) - this_cycle;
output_pixels(length_to_output);
_displayOutputPosition += length_to_output;
this_cycle += length_to_output;
}
if(this_cycle >= first_graphics_cycle + 80)
{
if(final_cycle < 128) return;
end_pixel_line();
_crt->output_blank((128 - (first_graphics_cycle + 80)) * crt_cycles_multiplier);
_displayOutputPosition += 128 - (first_graphics_cycle + 80);
this_cycle = 128;
}
}
Made an attempt to reintroduce interlacing and screen modes with gaps. Something's wrong with synchronisation though, so most likely I'm outputting a bad signal.
2016-02-20 22:32:51 +00:00
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Made an attempt to get RGB output mode up and running, and showing at least a box where pixels would be.
2016-01-10 02:32:56 +00:00
Added: key states are all cleared if the window loses focus. Which resolves sticky key issues. Allowing me just to use command+option+O for options and map both command and option as FUNC.
2016-04-20 01:29:10 +00:00
void Machine::clear_all_keys()
{
memset(_key_states, 0, sizeof(_key_states));
}
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
void Machine::set_key_state(Key key, bool isPressed)
{
if(key == KeyBreak)
{
set_reset_line(isPressed);
}
else
{
if(isPressed)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_key_states[key >> 4] |= key&0xf;
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
else
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_key_states[key >> 4] &= ~(key&0xf);
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
}
}
I'm not yet completely convinced by my approach to time basing, but it'll probably do? If so then this more or less gets me ready for a point-sampled filtering.
2016-01-14 03:02:39 +00:00
Bumped the speaker up to the full namespace, since Tape lives there to avoid delegation complexity. Turned the CRT into something the Electron statically owns, fixing a memory leak by simplifying.
2016-01-23 22:45:06 +00:00
/*
Speaker
*/
void Speaker::get_samples(unsigned int number_of_samples, int16_t *target)
I'm not yet completely convinced by my approach to time basing, but it'll probably do? If so then this more or less gets me ready for a point-sampled filtering.
2016-01-14 03:02:39 +00:00
{
Simplified sound generation.
2016-04-05 02:22:19 +00:00
if(_is_enabled)
Resolved some errors.
2016-01-14 03:11:33 +00:00
{
Simplified sound generation.
2016-04-05 02:22:19 +00:00
while(number_of_samples--)
{
*target = (int16_t)((_counter / (_divider+1)) * 8192);
target++;
_counter = (_counter + 1) % ((_divider+1) * 2);
}
}
else
{
memset(target, 0, sizeof(int16_t) * number_of_samples);
Resolved some errors.
2016-01-14 03:11:33 +00:00
}
Switched model for filter subclasses. Implemented test square[-ish] wave to check for obvious stream errors. None is clear.
2016-01-15 02:27:02 +00:00
}
Bumped the speaker up to the full namespace, since Tape lives there to avoid delegation complexity. Turned the CRT into something the Electron statically owns, fixing a memory leak by simplifying.
2016-01-23 22:45:06 +00:00
void Speaker::skip_samples(unsigned int number_of_samples)
Switched model for filter subclasses. Implemented test square[-ish] wave to check for obvious stream errors. None is clear.
2016-01-15 02:27:02 +00:00
{
Simplified sound generation.
2016-04-05 02:22:19 +00:00
_counter = (_counter + number_of_samples) % ((_divider+1) * 2);
Resolved some errors.
2016-01-14 03:11:33 +00:00
}
Bumped the speaker up to the full namespace, since Tape lives there to avoid delegation complexity. Turned the CRT into something the Electron statically owns, fixing a memory leak by simplifying.
2016-01-23 22:45:06 +00:00
void Speaker::set_divider(uint8_t divider)
Resolved some errors.
2016-01-14 03:11:33 +00:00
{
Introduced a compile-time configurable audio divider, set it arbitrarily to '8' for now. Discovered why my graphics aren't centred and added a TODO.
2016-04-14 02:31:59 +00:00
_divider = divider * 32 / clock_rate_audio_divider;
Resolved some errors.
2016-01-14 03:11:33 +00:00
}
Bumped the speaker up to the full namespace, since Tape lives there to avoid delegation complexity. Turned the CRT into something the Electron statically owns, fixing a memory leak by simplifying.
2016-01-23 22:45:06 +00:00
void Speaker::set_is_enabled(bool is_enabled)
Resolved some errors.
2016-01-14 03:11:33 +00:00
{
Fixed one off-by-one error.
2016-01-15 02:33:27 +00:00
_is_enabled = is_enabled;
_counter = 0;
I'm not yet completely convinced by my approach to time basing, but it'll probably do? If so then this more or less gets me ready for a point-sampled filtering.
2016-01-14 03:02:39 +00:00
}
As shown by the commented-out code, the aliasing-adaptation seems to be working. So something is wrong somewhere else.
2016-01-15 02:59:37 +00:00
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
/*
Tape
*/
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
Tape::Tape() :
_is_running(false),
_data_register(0),
_delegate(nullptr),
_output({.bits_remaining_until_empty = 0, .cycles_into_pulse = 0}),
_last_posted_interrupt_status(0),
_interrupt_status(0) {}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
void Tape::set_tape(std::shared_ptr<Storage::Tape> tape)
{
_tape = tape;
get_next_tape_pulse();
}
inline void Tape::get_next_tape_pulse()
{
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_input.time_into_pulse = 0;
Resolved potential crash if tape requests are made without one inserted. Softened glFinish to glFlush, though I'm still not sure I should strictly need even that.
2016-04-20 01:00:48 +00:00
if(_tape)
_input.current_pulse = _tape->get_next_pulse();
else
{
_input.current_pulse.length.length = 1;
_input.current_pulse.length.clock_rate = 1;
_input.current_pulse.type = Storage::Tape::Pulse::Zero;
}
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
if(_input.pulse_stepper == nullptr || _input.current_pulse.length.clock_rate != _input.pulse_stepper->get_output_rate())
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_input.pulse_stepper = std::unique_ptr<SignalProcessing::Stepper>(new SignalProcessing::Stepper(_input.current_pulse.length.clock_rate, 2000000));
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
}
inline void Tape::push_tape_bit(uint16_t bit)
{
_data_register = (uint16_t)((_data_register >> 1) | (bit << 10));
This is as simplified as things seem to be able to get without breaking at least Northern Star. Joe Blade et al remain stubbornly broken but I'm not immediately able to determine why.
2016-03-13 23:55:20 +00:00
Started taking baby steps towards a genuine unification of the tape interrupt generating code.
2016-03-13 23:45:50 +00:00
if(_input.minimum_bits_until_full) _input.minimum_bits_until_full--;
This is as simplified as things seem to be able to get without breaking at least Northern Star. Joe Blade et al remain stubbornly broken but I'm not immediately able to determine why.
2016-03-13 23:55:20 +00:00
if(_input.minimum_bits_until_full == 8) _interrupt_status &= ~Interrupt::ReceiveDataFull;
if(!_input.minimum_bits_until_full)
{
if((_data_register&0x3) == 0x1)
{
_interrupt_status |= Interrupt::ReceiveDataFull;
if(_is_in_input_mode) _input.minimum_bits_until_full = 9;
}
}
Started taking baby steps towards a genuine unification of the tape interrupt generating code.
2016-03-13 23:45:50 +00:00
if(_output.bits_remaining_until_empty) _output.bits_remaining_until_empty--;
if(!_output.bits_remaining_until_empty) _interrupt_status |= Interrupt::TransmitDataEmpty;
if(_data_register == 0x3ff) _interrupt_status |= Interrupt::HighToneDetect;
else _interrupt_status &= ~Interrupt::HighToneDetect;
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
evaluate_interrupts();
}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
inline void Tape::evaluate_interrupts()
{
if(_last_posted_interrupt_status != _interrupt_status)
{
_last_posted_interrupt_status = _interrupt_status;
if(_delegate) _delegate->tape_did_change_interrupt_status(this);
}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
inline void Tape::clear_interrupts(uint8_t interrupts)
{
This is as simplified as things seem to be able to get without breaking at least Northern Star. Joe Blade et al remain stubbornly broken but I'm not immediately able to determine why.
2016-03-13 23:55:20 +00:00
_interrupt_status &= ~interrupts;
evaluate_interrupts();
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
inline void Tape::set_is_in_input_mode(bool is_in_input_mode)
{
_is_in_input_mode = is_in_input_mode;
}
inline void Tape::set_counter(uint8_t value)
{
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_output.cycles_into_pulse = 0;
_output.bits_remaining_until_empty = 0;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
inline void Tape::set_data_register(uint8_t value)
{
_data_register = (uint16_t)((value << 2) | 1);
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_output.bits_remaining_until_empty = 9;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
Made an attempt to be more rigorous in display generation on the Electron, to make sure I deal with mid-line changes to/from blank line mode. Even if it turns out that they generate pixels.
2016-01-30 02:14:13 +00:00
inline uint8_t Tape::get_data_register()
{
Removed some logging.
2016-02-07 19:42:40 +00:00
return (uint8_t)(_data_register >> 2);
Made an attempt to be more rigorous in display generation on the Electron, to make sure I deal with mid-line changes to/from blank line mode. Even if it turns out that they generate pixels.
2016-01-30 02:14:13 +00:00
}
Made a further guess at the state interrupts would probably be left; slightly simplified interface.
2016-03-15 02:42:52 +00:00
inline void Tape::run_for_input_pulse()
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
get_next_tape_pulse();
_crossings[0] = _crossings[1];
_crossings[1] = _crossings[2];
_crossings[2] = _crossings[3];
_crossings[3] = Tape::Unrecognised;
if(_input.current_pulse.type != Storage::Tape::Pulse::Zero)
{
float pulse_length = (float)_input.current_pulse.length.length / (float)_input.current_pulse.length.clock_rate;
if(pulse_length >= 0.35 / 2400.0 && pulse_length < 0.7 / 2400.0) _crossings[3] = Tape::Short;
if(pulse_length >= 0.35 / 1200.0 && pulse_length < 0.7 / 1200.0) _crossings[3] = Tape::Long;
}
if(_crossings[0] == Tape::Long && _crossings[1] == Tape::Long)
{
push_tape_bit(0);
_crossings[0] = _crossings[1] = Tape::Recognised;
}
else
{
if(_crossings[0] == Tape::Short && _crossings[1] == Tape::Short && _crossings[2] == Tape::Short && _crossings[3] == Tape::Short)
{
push_tape_bit(1);
_crossings[0] = _crossings[1] =
_crossings[2] = _crossings[3] = Tape::Recognised;
}
}
}
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
inline void Tape::run_for_cycles(unsigned int number_of_cycles)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_enabled)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_in_input_mode)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_running && _tape != nullptr)
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
while(number_of_cycles--)
{
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_input.time_into_pulse += (unsigned int)_input.pulse_stepper->step();
if(_input.time_into_pulse == _input.current_pulse.length.length)
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
{
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
run_for_input_pulse();
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
}
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
}
else
{
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_output.cycles_into_pulse += number_of_cycles;
Switched to probably more accurate contended memory, resolved issue of not leaving the tape data received interrupt set when returning a byte from the fast tape, fixing Joe Blade, and tested slightly further to determine that interrupts probably signal upon entry into horizontal sync.
2016-03-14 23:29:28 +00:00
while(_output.cycles_into_pulse > 1664) // 1664 = the closest you can get to 1200 baud if you're looking for something
{ // that divides the 125,000Hz clock that the sound divider runs off.
_output.cycles_into_pulse -= 1664;
Started taking baby steps towards a genuine unification of the tape interrupt generating code.
2016-03-13 23:45:50 +00:00
push_tape_bit(1);
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
}
}
}
Reference in New Issue Copy Permalink