6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-11-26 23:52:26 +00:00
Code Issues Projects Releases Wiki Activity
30c670f8de
CLK/Machines/Electron/Electron.cpp

1197 lines
36 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),
It's likely this should be set at startup too, based on latest info.
2016-10-04 02:16:10 +00:00
_interrupt_status(Interrupt::PowerOnReset | Interrupt::TransmitDataEmpty | 0x80),
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);
Added some wiring for PAL/NTSC mode switching on the Vic, making an attempt to simplify the whole loop of having different clock rates.
2016-08-14 17:33:20 +00:00
set_clock_rate(2000000);
Switched to two-phase setup to deal with OpenGL scheduling.
2016-03-20 17:50:13 +00:00
}
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
{
Eliminated plain pointer passing for object types.
2016-07-04 23:33:55 +00:00
_speaker.reset(new Speaker);
`.reset` is the more normal way to reassign a `unique_ptr`.
2016-06-24 00:52:44 +00:00
_crt.reset(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.
Eliminated plain pointer passing for object types.
2016-07-04 23:33:55 +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
{
Corrected and sketched out state machine far enough to get to a complaint about unhandled work.
2016-09-20 19:56:31 +00:00
// if((address >> 8) == 0xfc)
// {
// printf("d");
// }
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
switch(address & 0xff0f)
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
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
case 0xfe00:
if(isReadOperation(operation))
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
*value = _interrupt_status;
_interrupt_status &= ~PowerOnReset;
}
else
{
_interrupt_control = (*value) & ~1;
evaluate_interrupts();
}
break;
case 0xfe02:
if(!isReadOperation(operation))
{
_startScreenAddress = (_startScreenAddress & 0xfe00) | (uint16_t)(((*value) & 0xe0) << 1);
if(!_startScreenAddress) _startScreenAddress |= 0x8000;
}
break;
case 0xfe03:
if(!isReadOperation(operation))
{
_startScreenAddress = (_startScreenAddress & 0x01ff) | (uint16_t)(((*value) & 0x3f) << 9);
if(!_startScreenAddress) _startScreenAddress |= 0x8000;
}
break;
case 0xfe04:
if(isReadOperation(operation))
{
*value = _tape.get_data_register();
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
}
else
{
_tape.set_data_register(*value);
_tape.clear_interrupts(Interrupt::TransmitDataEmpty);
}
break;
case 0xfe05:
if(!isReadOperation(operation))
{
const uint8_t interruptDisable = (*value)&0xf0;
if( interruptDisable )
{
if( interruptDisable&0x10 ) _interrupt_status &= ~Interrupt::DisplayEnd;
if( interruptDisable&0x20 ) _interrupt_status &= ~Interrupt::RealTimeClock;
if( interruptDisable&0x40 ) _interrupt_status &= ~Interrupt::HighToneDetect;
evaluate_interrupts();
Removed some logging.
2016-02-07 19:42:40 +00:00
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// TODO: NMI
}
Implemented what I now believe to be the real paging logic.
2016-05-05 12:28:06 +00:00
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// latch the paged ROM in case external hardware is being emulated
_active_rom = (Electron::ROMSlot)(*value & 0xf);
Implemented what I now believe to be the real paging logic.
2016-05-05 12:28:06 +00:00
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// apply the ULA's test
if(*value & 0x08)
{
if(*value & 0x04)
{
_keyboard_is_active = false;
_basic_is_active = false;
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
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
else
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
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
_keyboard_is_active = !(*value & 0x02);
_basic_is_active = !_keyboard_is_active;
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
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
}
}
break;
case 0xfe06:
if(!isReadOperation(operation))
{
update_audio();
_speaker->set_divider(*value);
_tape.set_counter(*value);
}
break;
case 0xfe07:
if(!isReadOperation(operation))
{
// update screen mode
uint8_t new_screen_mode = ((*value) >> 3)&7;
if(new_screen_mode == 7) new_screen_mode = 4;
if(new_screen_mode != _screen_mode)
{
update_display();
_screen_mode = new_screen_mode;
switch(_screen_mode)
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +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;
}
}
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
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// update speaker mode
bool new_speaker_is_enabled = (*value & 6) == 2;
That's thread safety, subject to the async task queue being made to work...
2016-10-07 21:02:36 +00:00
if(new_speaker_is_enabled != speaker_is_enabled_)
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
{
update_audio();
_speaker->set_is_enabled(new_speaker_is_enabled);
That's thread safety, subject to the async task queue being made to work...
2016-10-07 21:02:36 +00:00
speaker_is_enabled_ = new_speaker_is_enabled;
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +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
Adjusted per tests on StarDot; it appears the tape interrupts may fire during audio output, as if in tape output mode.
2016-10-04 00:03:14 +00:00
_tape.set_is_enabled((*value & 6) != 6);
_tape.set_is_in_input_mode((*value & 6) == 0);
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +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
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// TODO: caps lock LED
}
break;
case 0xfe08: case 0xfe09: case 0xfe0a: case 0xfe0b: case 0xfe0c: case 0xfe0d: case 0xfe0e: case 0xfe0f:
{
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)
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
_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);
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
_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);
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
_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
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
// regenerate all palette tables for now
Switched to table-based byte to output conversion.
2016-04-06 02:07:10 +00:00
#define pack(a, b) (uint8_t)((a << 4) | (b))
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
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)]);
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
#undef pack
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
}
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
break;
Corrected and sketched out state machine far enough to get to a complaint about unhandled work.
2016-09-20 19:56:31 +00:00
case 0xfc04: case 0xfc05: case 0xfc06: case 0xfc07:
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
if(_plus3 && (address&0x00f0) == 0x00c0)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
Attempted to ensure that ADFS disks get to an appropriately-configured Electron. Not immediately sure why the shift press isn't working; doesn't need to be dealt with immediately.
2016-09-25 23:59:46 +00:00
if(is_holding_shift_ && address == 0xfcc4)
Added shift-break as a better way to boot suitable disks. Continued attempting to clean the 1770.
2016-09-25 18:11:22 +00:00
{
is_holding_shift_ = false;
set_key_state(KeyShift, false);
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
if(isReadOperation(operation))
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
*value = _plus3->get_register(address);
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
else
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
_plus3->set_register(address, *value);
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
}
break;
Corrected and sketched out state machine far enough to get to a complaint about unhandled work.
2016-09-20 19:56:31 +00:00
case 0xfc00:
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
if(_plus3 && (address&0x00f0) == 0x00c0)
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
{
Renamed class, intending to turn a `Disk::Drive` into literally just that, and have a thing with a PLL that consumes events be a `Controller`.
2016-09-26 00:05:56 +00:00
if(!isReadOperation(operation))
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
{
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
_plus3->set_control_register(*value);
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
}
Made an attempt to add MFM decoding to the 1770; ensured something is returned when reading the Plus 3 status register again.
2016-09-26 01:38:52 +00:00
else
*value = 1;
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
}
break;
default:
if(address >= 0xc000)
{
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
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
if(
_use_fast_tape_hack &&
_tape.has_tape() &&
(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.
)
)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
uint8_t service_call = (uint8_t)get_value_of_register(CPU6502::Register::X);
if(address == 0xf0a8)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
if(!_ram[0x247] && service_call == 14)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
_tape.set_delegate(nullptr);
// TODO: handle tape wrap around.
int cycles_left_while_plausibly_in_data = 50;
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
Ensured emulation doesn't enter an infinite loop if the user attempts to read beyond the end of a tape.
2016-10-29 02:23:25 +00:00
while(!_tape.get_tape()->is_at_end())
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
{
_tape.run_for_input_pulse();
cycles_left_while_plausibly_in_data--;
if(!cycles_left_while_plausibly_in_data) _fast_load_is_in_data = false;
if( (_tape.get_interrupt_status() & Interrupt::ReceiveDataFull) &&
(_fast_load_is_in_data || _tape.get_data_register() == 0x2a)
) break;
}
_tape.set_delegate(this);
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
_interrupt_status |= _tape.get_interrupt_status();
_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
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
else
*value = _os[address & 16383];
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
}
else
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
*value = 0xea;
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
}
else
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
{
*value = _os[address & 16383];
}
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
}
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +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
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
if(isReadOperation(operation))
Implemented what I now believe to be the real paging logic.
2016-05-05 12:28:06 +00:00
{
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +00:00
*value = _roms[_active_rom][address & 16383];
if(_keyboard_is_active)
{
*value &= 0xf0;
for(int address_line = 0; address_line < 14; address_line++)
{
if(!(address&(1 << address_line))) *value |= _key_states[address_line];
}
}
if(_basic_is_active)
{
*value &= _roms[ROMSlotBASIC][address & 16383];
}
Fixed slots for DFS and ADFS to sideways RAM; continued working on the 1770 to get as far as trying to get the body of a sector.
2016-09-25 02:04:54 +00:00
} else if(_rom_write_masks[_active_rom])
{
_roms[_active_rom][address & 16383] = *value;
Implemented what I now believe to be the real paging logic.
2016-05-05 12:28:06 +00:00
}
}
Tweaked disk side density, added call-outs to a WD1770 if the Electron had one (albeit without `run_for_cycles` yet as I need to figure out the clock rate), added a shell of the basic functions of the WD1770. No implementation yet.
2016-09-20 02:06:56 +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 =
Attempted to normalise some style decisions.`
2016-04-25 02:32:24 +00:00
// if(_frameCycles < (256 + first_graphics_line) << 7))
Updated to latest information on interrupt timing.
2016-03-19 01:11:25 +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 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
Corrected type safety warning.
2016-06-20 01:41:01 +00:00
if(_typer) _typer->update((int)cycles);
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
if(_plus3) _plus3->run_for_cycles(4*cycles);
Implemented `Utility::Typer` for the Electron. So that now also receives pastes.
2016-06-19 21:25:35 +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
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
Finally started on generalising the C++ stuff so as to be able to be able to get a working audio binding on the OS-specific side without further repetition by factoring an appropriate protocol out from the Electron and sketching out the correct speaker class for the Atari. Added a method to ask it what a good output frequency would be.
2016-06-01 01:23:44 +00:00
void Machine::synchronise()
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
{
update_display();
update_audio();
}
I need to get a bit more definitive on naming but this gets all the way to setting a configuration upon an Electron.
2016-09-01 02:03:42 +00:00
void Machine::configure_as_target(const StaticAnalyser::Target &target)
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
{
I need to get a bit more definitive on naming but this gets all the way to setting a configuration upon an Electron.
2016-09-01 02:03:42 +00:00
if(target.tapes.size())
{
_tape.set_tape(target.tapes.front());
}
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
if(target.disks.size())
{
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
_plus3.reset(new Plus3);
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
if(target.acorn.has_dfs)
{
Fixed slots for DFS and ADFS to sideways RAM; continued working on the 1770 to get as far as trying to get the body of a sector.
2016-09-25 02:04:54 +00:00
set_rom(ROMSlot0, _dfs, true);
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
}
Attempted to ensure that ADFS disks get to an appropriately-configured Electron. Not immediately sure why the shift press isn't working; doesn't need to be dealt with immediately.
2016-09-25 23:59:46 +00:00
if(target.acorn.has_adfs)
{
Upped MFM clock cycles, switched back to using the typer for the ADFS and adjusted ADFS ROM slots.
2016-09-29 01:28:34 +00:00
set_rom(ROMSlot4, _adfs, true);
set_rom(ROMSlot5, std::vector<uint8_t>(_adfs.begin() + 16384, _adfs.end()), true);
Attempted to ensure that ADFS disks get to an appropriately-configured Electron. Not immediately sure why the shift press isn't working; doesn't need to be dealt with immediately.
2016-09-25 23:59:46 +00:00
}
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
Made a first stab at enabling multi-disk machines and thereby obeying (some of) the Plus 3's status register.
2016-09-26 01:24:16 +00:00
_plus3->set_disk(target.disks.front(), 0);
Fixed ROM loading by the Electron, turned the WD1770 into a 'disk drive' (it'll do for now), persuaded it to get all the way through a very specifically convenient type 1 command.
2016-09-21 02:14:33 +00:00
}
ROMSlot slot = ROMSlot12;
for(std::shared_ptr<Storage::Cartridge::Cartridge> cartridge : target.cartridges)
{
Fixed slots for DFS and ADFS to sideways RAM; continued working on the 1770 to get as far as trying to get the body of a sector.
2016-09-25 02:04:54 +00:00
set_rom(slot, cartridge->get_segments().front().data, false);
Fixed ROM loading by the Electron, turned the WD1770 into a 'disk drive' (it'll do for now), persuaded it to get all the way through a very specifically convenient type 1 command.
2016-09-21 02:14:33 +00:00
slot = (ROMSlot)(((int)slot + 1)&15);
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
}
I need to get a bit more definitive on naming but this gets all the way to setting a configuration upon an Electron.
2016-09-01 02:03:42 +00:00
if(target.loadingCommand.length()) // TODO: and automatic loading option enabled
{
set_typer_for_string(target.loadingCommand.c_str());
}
Added shift-break as a better way to boot suitable disks. Continued attempting to clean the 1770.
2016-09-25 18:11:22 +00:00
if(target.acorn.should_hold_shift)
{
set_key_state(KeyShift, true);
is_holding_shift_ = true;
}
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
Fixed slots for DFS and ADFS to sideways RAM; continued working on the 1770 to get as far as trying to get the body of a sector.
2016-09-25 02:04:54 +00:00
void Machine::set_rom(ROMSlot slot, std::vector<uint8_t> data, bool is_writeable)
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
{
uint8_t *target = nullptr;
switch(slot)
{
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
case ROMSlotDFS: _dfs = data; return;
case ROMSlotADFS: _adfs = data; return;
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;
Fixed slots for DFS and ADFS to sideways RAM; continued working on the 1770 to get as far as trying to get the body of a sector.
2016-09-25 02:04:54 +00:00
default:
target = _roms[slot];
_rom_write_masks[slot] = is_writeable;
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
}
Treading water some more, ensured the DFS and ADFS ROMs get to the Electron. It now even inserts the DFS ROM if it has a DFS disk image. Might need to make it a sideways RAM though? Regardless, the next job surely — surely! — has to be to stop avoiding the 1770?
2016-09-20 11:36:57 +00:00
memcpy(target, &data[0], std::min((size_t)16384, data.size()));
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 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;
Eliminated plain pointer passing for object types.
2016-07-04 23:33:55 +00:00
_speaker->run_for_cycles(difference / clock_rate_audio_divider);
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
_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;
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
_initial_output_target = _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
}
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(!_initial_output_target || divider != _current_output_divider)
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);
_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:
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_initial_output_target)
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
{
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
while(number_of_cycles--)
{
get_pixel();
*(uint32_t *)_current_output_target = _paletteTables.eighty1bpp[_last_pixel_byte];
_current_output_target += 4;
_current_pixel_column++;
}
} else _current_output_target += 4*number_of_cycles;
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:
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_initial_output_target)
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
{
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
while(number_of_cycles--)
{
get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.eighty2bpp[_last_pixel_byte];
_current_output_target += 2;
_current_pixel_column++;
}
} else _current_output_target += 2*number_of_cycles;
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:
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_initial_output_target)
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
{
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
while(number_of_cycles--)
{
get_pixel();
*_current_output_target = _paletteTables.eighty4bpp[_last_pixel_byte];
_current_output_target += 1;
_current_pixel_column++;
}
} else _current_output_target += number_of_cycles;
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:
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_initial_output_target)
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
{
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_current_pixel_column&1)
{
_last_pixel_byte <<= 4;
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
_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
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
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;
Pulled a bunch of selection parts outside of the loops. Probably exhausting this angle of attack.
2016-04-06 02:17:44 +00:00
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
_last_pixel_byte <<= 4;
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
_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
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
number_of_cycles -= 2;
_current_pixel_column+=2;
}
if(number_of_cycles)
{
get_pixel();
*(uint16_t *)_current_output_target = _paletteTables.forty1bpp[_last_pixel_byte];
_current_output_target += 2;
_current_pixel_column++;
}
} else _current_output_target += 2 * number_of_cycles;
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 5:
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_initial_output_target)
Blank lines are back.
2016-03-11 03:19:54 +00:00
{
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
if(_current_pixel_column&1)
{
_last_pixel_byte <<= 2;
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
_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
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
number_of_cycles--;
_current_pixel_column++;
}
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
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
_last_pixel_byte <<= 2;
*_current_output_target = _paletteTables.forty2bpp[_last_pixel_byte];
_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
Started on an attempt not to treat the various buffers as free to loop within, starting with the input texture.
2016-05-04 11:39:45 +00:00
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++;
}
} else _current_output_target += number_of_cycles;
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
#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
{
That's thread safety, subject to the async task queue being made to work...
2016-10-07 21:02:36 +00:00
enqueue([=]() {
_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
{
That's thread safety, subject to the async task queue being made to work...
2016-10-07 21:02:36 +00:00
enqueue([=]() {
_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() :
Factored out the stuff of playing a tape, started basic sketch of the Vic-related classes.
2016-06-26 23:03:57 +00:00
TapePlayer(2000000),
Made an attempt to separate and clarify on tape interrupts.
2016-03-13 01:32:26 +00:00
_is_running(false),
_data_register(0),
_delegate(nullptr),
_output({.bits_remaining_until_empty = 0, .cycles_into_pulse = 0}),
_last_posted_interrupt_status(0),
Factored out the stuff of playing a tape, started basic sketch of the Vic-related classes.
2016-06-26 23:03:57 +00:00
_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
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
}
Gave tapes their own namespace.
2016-08-27 21:09:45 +00:00
inline void Tape::process_input_pulse(Storage::Tape::Tape::Pulse pulse)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
_crossings[0] = _crossings[1];
_crossings[1] = _crossings[2];
_crossings[2] = _crossings[3];
_crossings[3] = Tape::Unrecognised;
Gave tapes their own namespace.
2016-08-27 21:09:45 +00:00
if(pulse.type != Storage::Tape::Tape::Pulse::Zero)
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
{
Factored out the stuff of playing a tape, started basic sketch of the Vic-related classes.
2016-06-26 23:03:57 +00:00
float pulse_length = (float)pulse.length.length / (float)pulse.length.clock_rate;
I think this is a prima facie acceptable implementation of the fast tape hack.
2016-03-13 21:39:53 +00:00
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
{
Factored out the stuff of playing a tape, started basic sketch of the Vic-related classes.
2016-06-26 23:03:57 +00:00
if(_is_running)
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
{
Formalised clock-rate multiplication within disk drives, discovered that the stepper didn't have ideal behaviour for my timed event loop and hence nailed down the semantics a ilttle more. (obiter: the 1540 now appears to discern the correct sequence of bits. Framing is off in my test printfs but that's neither here nor there).
2016-07-31 17:32:30 +00:00
TapePlayer::run_for_cycles((int)number_of_cycles);
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
}
}
}
}
Implemented `Utility::Typer` for the Electron. So that now also receives pastes.
2016-06-19 21:25:35 +00:00
#pragma mark - Typer
int Machine::get_typer_delay()
{
Fixed 6560 addressing error, added an autotyper for Vic disks (more work potentially needed), fixed semantics for testing whether a 6502 is about to reset.
2016-08-01 14:32:32 +00:00
return get_is_resetting() ? 625*25*128 : 0; // wait one second if resetting
Implemented `Utility::Typer` for the Electron. So that now also receives pastes.
2016-06-19 21:25:35 +00:00
}
int Machine::get_typer_frequency()
{
return 625*128; // accept a new character every frame
}
bool Machine::typer_set_next_character(::Utility::Typer *typer, char character, int phase)
{
if(!phase) clear_all_keys();
// The following table is arranged in ASCII order
Key key_sequences[][3] = {
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped}, {NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{KeyDelete, TerminateSequence},
{NotMapped},
{KeyReturn, TerminateSequence},
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{NotMapped}, {NotMapped}, {NotMapped}, {NotMapped},
{KeySpace, TerminateSequence}, // space
{KeyShift, Key1, TerminateSequence}, {KeyShift, Key2, TerminateSequence}, // !, "
{KeyShift, Key3, TerminateSequence}, {KeyShift, Key4, TerminateSequence}, // #, $
{KeyShift, Key5, TerminateSequence}, {KeyShift, Key6, TerminateSequence}, // %, &
{KeyShift, Key7, TerminateSequence}, {KeyShift, Key8, TerminateSequence}, // ', (
{KeyShift, Key9, TerminateSequence}, {KeyShift, KeyColon, TerminateSequence}, // ), *
{KeyShift, KeySemiColon, TerminateSequence}, {KeyComma, TerminateSequence}, // +, ,
{KeyMinus, TerminateSequence}, {KeyFullStop, TerminateSequence}, // -, .
{KeySlash, TerminateSequence}, // /
{Key0, TerminateSequence}, {Key1, TerminateSequence}, // 0, 1
{Key2, TerminateSequence}, {Key3, TerminateSequence}, // 2, 3
{Key4, TerminateSequence}, {Key5, TerminateSequence}, // 4, 5
{Key6, TerminateSequence}, {Key7, TerminateSequence}, // 6, 7
{Key8, TerminateSequence}, {Key9, TerminateSequence}, // 8, 9
Added mappings for the previously-missing characters @, [ and ].
2016-10-05 02:03:53 +00:00
{KeyColon, TerminateSequence}, {KeySemiColon, TerminateSequence}, // :, ;
{KeyShift, KeyComma, TerminateSequence}, {KeyShift, KeyMinus, TerminateSequence}, // <, =
{KeyShift, KeyFullStop, TerminateSequence}, {KeyShift, KeySlash, TerminateSequence}, // >, ?
{KeyShift, Key0, TerminateSequence}, // @
Implemented `Utility::Typer` for the Electron. So that now also receives pastes.
2016-06-19 21:25:35 +00:00
{KeyA, TerminateSequence}, {KeyB, TerminateSequence}, {KeyC, TerminateSequence}, {KeyD, TerminateSequence}, // A, B, C, D
{KeyE, TerminateSequence}, {KeyF, TerminateSequence}, {KeyG, TerminateSequence}, {KeyH, TerminateSequence}, // E, F, G, H
{KeyI, TerminateSequence}, {KeyJ, TerminateSequence}, {KeyK, TerminateSequence}, {KeyL, TerminateSequence}, // I, J, K L
{KeyM, TerminateSequence}, {KeyN, TerminateSequence}, {KeyO, TerminateSequence}, {KeyP, TerminateSequence}, // M, N, O, P
{KeyQ, TerminateSequence}, {KeyR, TerminateSequence}, {KeyS, TerminateSequence}, {KeyT, TerminateSequence}, // Q, R, S, T
{KeyU, TerminateSequence}, {KeyV, TerminateSequence}, {KeyW, TerminateSequence}, {KeyX, TerminateSequence}, // U, V, W X
{KeyY, TerminateSequence}, {KeyZ, TerminateSequence}, // Y, Z
Added mappings for the previously-missing characters @, [ and ].
2016-10-05 02:03:53 +00:00
{KeyShift, KeyCopy, TerminateSequence}, {KeyControl, KeyRight, TerminateSequence}, // [, '\'
{KeyControl, KeyCopy, TerminateSequence}, {KeyShift, KeyLeft, TerminateSequence}, // ], ^
Implemented `Utility::Typer` for the Electron. So that now also receives pastes.
2016-06-19 21:25:35 +00:00
{KeyShift, KeyDown, TerminateSequence}, {NotMapped}, // _, `
{KeyShift, KeyA, TerminateSequence}, {KeyShift, KeyB, TerminateSequence}, {KeyShift, KeyC, TerminateSequence}, {KeyShift, KeyD, TerminateSequence}, // a, b, c, d
{KeyShift, KeyE, TerminateSequence}, {KeyShift, KeyF, TerminateSequence}, {KeyShift, KeyG, TerminateSequence}, {KeyShift, KeyH, TerminateSequence}, // e, f, g, h
{KeyShift, KeyI, TerminateSequence}, {KeyShift, KeyJ, TerminateSequence}, {KeyShift, KeyK, TerminateSequence}, {KeyShift, KeyL, TerminateSequence}, // i, j, k, l
{KeyShift, KeyM, TerminateSequence}, {KeyShift, KeyN, TerminateSequence}, {KeyShift, KeyO, TerminateSequence}, {KeyShift, KeyP, TerminateSequence}, // m, n, o, p
{KeyShift, KeyQ, TerminateSequence}, {KeyShift, KeyR, TerminateSequence}, {KeyShift, KeyS, TerminateSequence}, {KeyShift, KeyT, TerminateSequence}, // q, r, s, t
{KeyShift, KeyU, TerminateSequence}, {KeyShift, KeyV, TerminateSequence}, {KeyShift, KeyW, TerminateSequence}, {KeyShift, KeyX, TerminateSequence}, // u, v, w, x
{KeyShift, KeyY, TerminateSequence}, {KeyShift, KeyZ, TerminateSequence}, // y, z
{KeyControl, KeyUp, TerminateSequence}, {KeyShift, KeyRight, TerminateSequence}, // {, |
{KeyControl, KeyDown, TerminateSequence}, {KeyControl, KeyLeft, TerminateSequence}, // }, ~
};
Key *key_sequence = nullptr;
character &= 0x7f;
if(character < sizeof(key_sequences) / sizeof(*key_sequences))
{
key_sequence = key_sequences[character];
if(key_sequence[0] != NotMapped)
{
if(phase > 0)
{
set_key_state(key_sequence[phase-1], true);
return key_sequence[phase] == TerminateSequence;
}
else
return false;
}
}
return true;
}
Reference in New Issue Copy Permalink