6502/CLK
1
0
Fork 0
mirror of https://github.com/TomHarte/CLK.git synced 2024-11-19 08:31:11 +00:00
Code Issues Projects Releases Wiki Activity
b836d74e18
CLK/Machines/Electron/Electron.cpp

919 lines
25 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
// 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 = 38;
static const unsigned int first_graphics_cycle = 33;
static const unsigned int last_graphics_cycle = 80 + first_graphics_cycle;
static const unsigned int real_time_clock_interrupt_line = 156;
static const unsigned int display_end_interrupt_line = 256;
}
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)
#define graphics_column(v) ((((v) %127) - first_graphics_cycle) % 127)
Disabled my various bits of rate interchange debugging; improved test for when to call update_display due to a RAM write.
2016-01-22 03:16:52 +00:00
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
Machine::Machine() :
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_control(0),
_interrupt_status(Interrupt::PowerOnReset),
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
_frameCycles(0),
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
_displayOutputPosition(0),
_audioOutputPosition(0),
_audioOutputPositionError(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),
Started trying to clean up my Outputs namespace by moving stuff related to the CRT underneath a separate subnamespace.
2016-03-09 01:49:07 +00:00
_crt(std::unique_ptr<Outputs::CRT::CRT>(new Outputs::CRT::CRT(crt_cycles_per_line, 8, Outputs::CRT::DisplayType::PAL50, 1, 1)))
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
{
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(
Still stepping slowly towards a working composite mode, switched the RGB sampling function to returning a `vec4`, which may be of benefit to any machine with a brightness part of an RGB signal, and started edging towards at least having the correct GLSL programs ready for converting composite output.
2016-03-08 00:08:26 +00:00
"vec4 rgb_sample(vec2 coordinate)"
There is now a semi-reasonable amount of screen output again.
2016-02-06 02:35:39 +00:00
"{"
"float texValue = texture(texID, coordinate).r;"
Still stepping slowly towards a working composite mode, switched the RGB sampling function to returning a `vec4`, which may be of benefit to any machine with a brightness part of an RGB signal, and started edging towards at least having the correct GLSL programs ready for converting composite output.
2016-03-08 00:08:26 +00:00
"return vec4(step(4.0/256.0, mod(texValue, 8.0/256.0)), step(2.0/256.0, mod(texValue, 4.0/256.0)), step(1.0/256.0, mod(texValue, 2.0/256.0)), 1.0);"
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
"}");
Basic attempts to organise myself into shape for composite output continue.
2016-03-08 02:22:47 +00:00
_crt->set_output_device(Outputs::CRT::Monitor);
Got back to a stable image, at least when staying in a mode. Which is what I was trying to fix. Hmmm.
2016-02-20 04:41:09 +00:00
// _crt->set_visible_area(Outputs::Rect(0.23108f, 0.0f, 0.8125f, 0.98f)); //1875
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
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
memset(_key_states, 0, sizeof(_key_states));
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
memset(_palette, 0xf, sizeof(_palette));
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
for(int c = 0; c < 16; c++)
memset(_roms[c], 0xff, 16384);
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
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
_speaker.set_input_rate(125000);
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
_tape.set_delegate(this);
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
{
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
// If we're still before the display will start to be painted, or the address is
// less than both the current line address and 0x3000, (the minimum screen mode
// base address) then there's no way this write can affect the current frame. Sp
// no need to flush the display. Otherwise, output up until now so that any
// write doesn't have retroactive effect on the video output.
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(!(
// (_fieldCycles < first_graphics_line * cycles_per_line) ||
// (address < _startLineAddress && address < 0x3000)
// ))
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
{
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
const int current_line = graphics_line(_frameCycles + cycles);
const int current_column = graphics_column(_frameCycles + cycles);
if(current_line < 256 && current_column < 80)
cycles += (unsigned int)(80 - current_column);
Made an attempt at correct timing, adding support for additional paged ROMs, added file association for .rom.
2016-01-13 03:34:26 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
else
{
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
if(address >= 0xc000)
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
{
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
if((address & 0xff00) == 0xfe00)
{
switch(address&0xf)
{
case 0x0:
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(isReadOperation(operation))
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
*value = _interrupt_status;
Some minor optimisations and timing tweaks. Nothing of substance.
2016-03-11 00:58:50 +00:00
_interrupt_status &= ~PowerOnReset;
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
else
{
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 = *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
evaluate_interrupts();
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x1:
break;
case 0x2:
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
printf("%02x to [2] mutates %04x ", *value, _startScreenAddress);
Fixed screen start address.
2016-01-10 03:52:08 +00:00
_startScreenAddress = (_startScreenAddress & 0xfe00) | (uint16_t)(((*value) & 0xe0) << 1);
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
printf("into %04x\n", _startScreenAddress);
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
break;
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
case 0x3:
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
printf("%02x to [3] mutates %04x ", *value, _startScreenAddress);
Fixed screen start address.
2016-01-10 03:52:08 +00:00
_startScreenAddress = (_startScreenAddress & 0x01ff) | (uint16_t)(((*value) & 0x3f) << 9);
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
printf("into %04x\n", _startScreenAddress);
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x4:
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
if(isReadOperation(operation))
{
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
*value = _tape.get_data_register();
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_tape.clear_interrupts(Interrupt::ReceiveDataFull);
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
Shushed.
2016-01-20 04:33:15 +00:00
else
{
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_data_register(*value);
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_tape.clear_interrupts(Interrupt::TransmitDataEmpty);
Shushed.
2016-01-20 04:33:15 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x5:
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(!isReadOperation(operation))
{
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
const uint8_t interruptDisable = (*value)&0xf0;
if( interruptDisable )
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if( interruptDisable&0x10 ) _interrupt_status &= ~Interrupt::DisplayEnd;
if( interruptDisable&0x20 ) _interrupt_status &= ~Interrupt::RealTimeClock;
if( interruptDisable&0x40 ) _interrupt_status &= ~Interrupt::HighToneDetect;
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
evaluate_interrupts();
Removed some logging.
2016-02-07 19:42:40 +00:00
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
// TODO: NMI (?)
}
// else
{
uint8_t nextROM = (*value)&0xf;
// if(nextROM&0x08)
// {
// _activeRom = (Electron::ROMSlot)(nextROM&0x0e);
// printf("%d -> Paged %d\n", nextROM, _activeRom);
// }
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(((_active_rom&12) != 8) || (nextROM&8))
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_active_rom = (Electron::ROMSlot)nextROM;
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
}
// else
// {
// printf("Ignored!");
// }
// printf("%d -> Paged %d\n", nextROM, _activeRom);
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
}
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x6:
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
if(!isReadOperation(operation))
{
Resolved some errors.
2016-01-14 03:11:33 +00:00
update_audio();
_speaker.set_divider(*value);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_counter(*value);
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
case 0x7:
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
if(!isReadOperation(operation))
{
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
// update screen mode
uint8_t new_screen_mode = ((*value) >> 3)&7;
if(new_screen_mode == 7) new_screen_mode = 4;
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(new_screen_mode != _screen_mode)
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
{
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
// printf("To mode %d, at %d cycles into field (%d)\n", new_screen_mode, _fieldCycles, _fieldCycles >> 7);
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
update_display();
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_screen_mode = new_screen_mode;
switch(_screen_mode)
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
{
case 0: case 1: case 2: _screenModeBaseAddress = 0x3000; break;
case 3: _screenModeBaseAddress = 0x4000; break;
case 4: case 5: _screenModeBaseAddress = 0x5800; break;
case 6: _screenModeBaseAddress = 0x6000; break;
}
}
// update speaker mode
bool new_speaker_is_enabled = (*value & 6) == 2;
Resolved some errors.
2016-01-14 03:11:33 +00:00
if(new_speaker_is_enabled != _speaker.get_is_enabled())
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
update_audio();
Resolved some errors.
2016-01-14 03:11:33 +00:00
_speaker.set_is_enabled(new_speaker_is_enabled);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_is_enabled(!new_speaker_is_enabled);
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
_tape.set_is_running(((*value)&0x40) ? true : false);
Ensured that all relevant information is given to the tape class. Made an attempt not to write to a screen output buffer if we don't have one. Added some debug printing.
2016-01-23 18:09:56 +00:00
_tape.set_is_in_input_mode(((*value)&0x04) ? false : true);
// TODO: caps lock LED
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
default:
Made an attempt to get video output correct.
2016-01-12 03:08:30 +00:00
{
if(!isReadOperation(operation))
{
update_display();
static const int registers[4][4] = {
{10, 8, 2, 0},
{14, 12, 6, 4},
{15, 13, 7, 5},
{11, 9, 3, 1},
};
const int index = (address >> 1)&3;
const uint8_t colour = ~(*value);
if(address&1)
{
_palette[registers[index][0]] = (_palette[registers[index][0]]&3) | ((colour >> 1)&4);
_palette[registers[index][1]] = (_palette[registers[index][1]]&3) | ((colour >> 0)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&3) | ((colour << 1)&4);
_palette[registers[index][3]] = (_palette[registers[index][3]]&3) | ((colour << 2)&4);
_palette[registers[index][2]] = (_palette[registers[index][2]]&5) | ((colour >> 4)&2);
_palette[registers[index][3]] = (_palette[registers[index][3]]&5) | ((colour >> 3)&2);
}
else
{
_palette[registers[index][0]] = (_palette[registers[index][0]]&6) | ((colour >> 7)&1);
_palette[registers[index][1]] = (_palette[registers[index][1]]&6) | ((colour >> 6)&1);
_palette[registers[index][2]] = (_palette[registers[index][2]]&6) | ((colour >> 5)&1);
_palette[registers[index][3]] = (_palette[registers[index][3]]&6) | ((colour >> 4)&1);
_palette[registers[index][0]] = (_palette[registers[index][0]]&5) | ((colour >> 2)&2);
_palette[registers[index][1]] = (_palette[registers[index][1]]&5) | ((colour >> 1)&2);
}
}
}
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
break;
}
}
else
{
if(isReadOperation(operation))
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
*value = _os[address & 16383];
This is the bare minimum to prove that the ROM is trying properly to boot.
2016-01-08 01:36:27 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
else
{
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
if(isReadOperation(operation))
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
switch(_active_rom)
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
{
case ROMSlotKeyboard:
case ROMSlotKeyboard+1:
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
*value = 0xf0;
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
for(int address_line = 0; address_line < 14; address_line++)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(!(address&(1 << address_line))) *value |= _key_states[address_line];
Implemented keyboard input.
2016-01-12 00:48:31 +00:00
}
I'm not really sure what's going wrong with paging yet but this fixes the 0xc000 byte error.
2016-01-10 17:30:24 +00:00
break;
default:
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
*value = _roms[_active_rom][address & 16383];
Added just enough that this is probably a successful boot. I guess I'm going to need to get invested in graphics next? Hmmm.
2016-01-08 02:01:13 +00:00
break;
}
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
}
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
// if(operation == CPU6502::BusOperation::ReadOpcode)
// {
Made an attempt to put interrupts in the correct places regardless of even/odd field.
2016-02-17 01:36:19 +00:00
// printf("%04x: %02x (%d)\n", address, *value, _fieldCycles);
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
// }
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
const unsigned int line_before_cycle = graphics_line(_frameCycles);
const unsigned int line_after_cycle = graphics_line(_frameCycles + 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.
switch(line_before_cycle)
Made an attempt to put interrupts in the correct places regardless of even/odd field.
2016-02-17 01:36:19 +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
case real_time_clock_interrupt_line:
if(line_after_cycle > real_time_clock_interrupt_line)
signal_interrupt(Interrupt::RealTimeClock);
break;
case real_time_clock_interrupt_line+1:
if(line_after_cycle > real_time_clock_interrupt_line+1)
clear_interrupt(Interrupt::RealTimeClock);
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
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
case display_end_interrupt_line:
if(line_after_cycle > display_end_interrupt_line)
signal_interrupt(Interrupt::DisplayEnd);
break;
case display_end_interrupt_line+1:
if(line_after_cycle > 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
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
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
}
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(!(_frameCycles&31))
update_audio();
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
_tape.run_for_cycles(cycles);
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
return cycles;
Started working on a shell for the Electron emulation, including factoring out the common CRT delegate -> Objective-C bridging, serial dispatch queue and frameskipping logic from the Atari 2600 shell.
2016-01-05 04:12:47 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
Fixes: now setting correct frame time estimate, properly enabling the timestamp attribute, and ensuring that the Electron flushes screen work at least once per host frame update.
2016-02-15 00:28:02 +00:00
void Machine::update_output()
{
update_display();
update_audio();
}
Moved set_tape so that the inline definition of get_next_tape_pulse is visible to it. Also eliminated some dead typedefs.
2016-01-20 13:27:25 +00:00
void Machine::set_tape(std::shared_ptr<Storage::Tape> tape)
{
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
_tape.set_tape(tape);
Some data is marginally reaching the CPU from the tape.
2016-01-20 03:05:34 +00:00
}
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
void Machine::set_rom(ROMSlot slot, size_t length, const uint8_t *data)
{
uint8_t *target = nullptr;
switch(slot)
{
Made an attempt at correct timing, adding support for additional paged ROMs, added file association for .rom.
2016-01-13 03:34:26 +00:00
case ROMSlotOS: target = _os; break;
default: target = _roms[slot]; break;
You now get an Electron only if you ask for a new file. That'll do for now while it's the only thing that one might want to start without supplying a file. The 6502 now starts from a defined point — being reset. The Electron is starting to grow the absolute most simple buds of its memory map.
2016-01-07 02:09:49 +00:00
}
memcpy(target, data, std::min((size_t)16384, length));
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
inline void Machine::signal_interrupt(Electron::Interrupt interrupt)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status |= interrupt;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
evaluate_interrupts();
}
Believing the previous implementation to be overly complicated through premature optimisation, simplified video. It's slightly slower now. Will need work. Immediately to do: figure out how to deal with blank scan lines.
2016-03-11 03:08:50 +00:00
inline void Machine::clear_interrupt(Electron::Interrupt interrupt)
{
_interrupt_status &= ~interrupt;
evaluate_interrupts();
}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
void Machine::tape_did_change_interrupt_status(Tape *tape)
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status = (_interrupt_status & ~(Interrupt::TransmitDataEmpty | Interrupt::ReceiveDataFull | Interrupt::HighToneDetect)) | _tape.get_interrupt_status();
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
evaluate_interrupts();
}
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
inline void Machine::evaluate_interrupts()
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
if(_interrupt_status & _interrupt_control)
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status |= 1;
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
else
{
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
_interrupt_status &= ~1;
Made an attempt at getting some interrupts all up inside this thing.
2016-01-11 00:06:46 +00:00
}
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
set_irq_line(_interrupt_status & 1);
This is intended to be enough to start producing something of an output. But something's obviously still broken.
2016-01-10 01:26:40 +00:00
}
Edging towards audio output; the speaker is given appropriate input and output rates, and then updated with current divider and enabled/disabled status.
2016-01-14 02:03:43 +00:00
inline void Machine::update_audio()
{
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 difference = (int)_frameCycles - _audioOutputPosition;
_audioOutputPosition = (int)_frameCycles;
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
_speaker.run_for_cycles((_audioOutputPositionError + difference) >> 4);
_audioOutputPositionError = (_audioOutputPositionError + difference)&15;
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&7))
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
_startLineAddress += ((_screen_mode < 4) ? 80 : 40) * 8 - 8;
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(!_current_pixel_line)
{
_startLineAddress = _startScreenAddress;
}
else
{
_startLineAddress++;
}
_currentScreenAddress = _startLineAddress;
_current_pixel_column = 0;
_crt->allocate_write_area(640);
_currentLine = _crt->get_write_target_for_buffer(0);
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
{
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_data(640, 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
}
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
{
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
while(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
{
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(!(_current_pixel_column&1) || _screen_mode < 4)
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
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(_currentScreenAddress&32768)
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
_currentScreenAddress = (_screenModeBaseAddress + _currentScreenAddress)&32767;
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
_last_pixel_byte = _ram[_currentScreenAddress];
_currentScreenAddress = _currentScreenAddress+8;
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
switch(_screen_mode)
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
case 3:
case 0:
Got back to a stable image, at least when staying in a mode. Which is what I was trying to fix. Hmmm.
2016-02-20 04:41:09 +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
_currentLine[0] = _palette[(_last_pixel_byte&0x80) >> 4];
_currentLine[1] = _palette[(_last_pixel_byte&0x40) >> 3];
_currentLine[2] = _palette[(_last_pixel_byte&0x20) >> 2];
_currentLine[3] = _palette[(_last_pixel_byte&0x10) >> 1];
_currentLine[4] = _palette[(_last_pixel_byte&0x08) >> 0];
_currentLine[5] = _palette[(_last_pixel_byte&0x04) << 1];
_currentLine[6] = _palette[(_last_pixel_byte&0x02) << 2];
_currentLine[7] = _palette[(_last_pixel_byte&0x01) << 3];
Got back to a stable image, at least when staying in a mode. Which is what I was trying to fix. Hmmm.
2016-02-20 04:41:09 +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
break;
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
case 1:
{
_currentLine[0] =
_currentLine[1] = _palette[((_last_pixel_byte&0x80) >> 4) | ((_last_pixel_byte&0x08) >> 2)];
_currentLine[2] =
_currentLine[3] = _palette[((_last_pixel_byte&0x40) >> 3) | ((_last_pixel_byte&0x04) >> 1)];
_currentLine[4] =
_currentLine[5] = _palette[((_last_pixel_byte&0x20) >> 2) | ((_last_pixel_byte&0x02) >> 0)];
_currentLine[6] =
_currentLine[7] = _palette[((_last_pixel_byte&0x10) >> 1) | ((_last_pixel_byte&0x01) << 1)];
}
break;
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
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
case 2:
{
_currentLine[0] =
_currentLine[1] =
_currentLine[2] =
_currentLine[3] = _palette[((_last_pixel_byte&0x80) >> 4) | ((_last_pixel_byte&0x20) >> 3) | ((_last_pixel_byte&0x08) >> 2) | ((_last_pixel_byte&0x02) >> 1)];
_currentLine[4] =
_currentLine[5] =
_currentLine[6] =
_currentLine[7] = _palette[((_last_pixel_byte&0x40) >> 3) | ((_last_pixel_byte&0x10) >> 2) | ((_last_pixel_byte&0x04) >> 1) | ((_last_pixel_byte&0x01) >> 0)];
}
break;
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
case 6:
case 4:
Commuted some camelCase variables into more standard C++ underscore names; decided the best fix for the graphics output is to break it down into much simpler chunks. output_pixels is currently a placeholder that simply outputs blank so the current effect is that all data is missing but it should be easy enough now to put pixels back in.
2016-02-19 04:23:49 +00:00
{
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(_current_pixel_column&1)
{
_currentLine[0] =
_currentLine[1] = _palette[(_last_pixel_byte&0x08) >> 0];
_currentLine[2] =
_currentLine[3] = _palette[(_last_pixel_byte&0x04) << 1];
_currentLine[4] =
_currentLine[5] = _palette[(_last_pixel_byte&0x02) << 2];
_currentLine[6] =
_currentLine[7] = _palette[(_last_pixel_byte&0x01) << 3];
}
else
{
_currentLine[0] =
_currentLine[1] = _palette[(_last_pixel_byte&0x80) >> 4];
_currentLine[2] =
_currentLine[3] = _palette[(_last_pixel_byte&0x40) >> 3];
_currentLine[4] =
_currentLine[5] = _palette[(_last_pixel_byte&0x20) >> 2];
_currentLine[6] =
_currentLine[7] = _palette[(_last_pixel_byte&0x10) >> 1];
}
}
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
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
case 5:
{
if(_current_pixel_column&1)
{
_currentLine[0] =
_currentLine[1] =
_currentLine[2] =
_currentLine[3] = _palette[((_last_pixel_byte&0x20) >> 2) | ((_last_pixel_byte&0x02) >> 0)];
_currentLine[4] =
_currentLine[5] =
_currentLine[6] =
_currentLine[7] = _palette[((_last_pixel_byte&0x10) >> 1) | ((_last_pixel_byte&0x01) << 1)];
}
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
{
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
_currentLine[0] =
_currentLine[1] =
_currentLine[2] =
_currentLine[3] = _palette[((_last_pixel_byte&0x80) >> 4) | ((_last_pixel_byte&0x08) >> 2)];
_currentLine[4] =
_currentLine[5] =
_currentLine[6] =
_currentLine[7] = _palette[((_last_pixel_byte&0x40) >> 3) | ((_last_pixel_byte&0x04) >> 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
}
}
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
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
}
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_column++;
_currentLine += 8;
}
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;
_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;
_crt->output_sync(64 * crt_cycles_multiplier);
_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;
_crt->output_blank(64 * crt_cycles_multiplier);
_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;
_crt->output_colour_burst((24-9) * crt_cycles_multiplier, 0, 12);
_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
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
{
Fixed one off-by-one error.
2016-01-15 02:33:27 +00:00
if(!_is_enabled)
{
*target = 0;
}
else
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
*target = _output_level;
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
skip_samples(number_of_samples);
}
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
{
while(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
_counter ++;
if(_counter > _divider)
{
_counter = 0;
Fixed one off-by-one error.
2016-01-15 02:33:27 +00:00
_output_level ^= 8192;
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
}
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
{
Fixed one off-by-one error.
2016-01-15 02:33:27 +00:00
_divider = divider;
Resolved some errors.
2016-01-14 03:11:33 +00:00
}
Bumped the speaker up to the full namespace, since Tape lives there to avoid delegation complexity. Turned the CRT into something the Electron statically owns, fixing a memory leak by simplifying.
2016-01-23 22:45:06 +00:00
void Speaker::set_is_enabled(bool is_enabled)
Resolved some errors.
2016-01-14 03:11:33 +00:00
{
Fixed one off-by-one error.
2016-01-15 02:33:27 +00:00
_is_enabled = is_enabled;
_counter = 0;
I'm not yet completely convinced by my approach to time basing, but it'll probably do? If so then this more or less gets me ready for a point-sampled filtering.
2016-01-14 03:02:39 +00:00
}
As shown by the commented-out code, the aliasing-adaptation seems to be working. So something is wrong somewhere else.
2016-01-15 02:59:37 +00:00
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
/*
Tape
*/
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
Tape::Tape() : _is_running(false), _data_register(0), _delegate(nullptr), _output_bits_remaining(0), _last_posted_interrupt_status(0), _interrupt_status(0) {}
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
void Tape::set_tape(std::shared_ptr<Storage::Tape> tape)
{
_tape = tape;
get_next_tape_pulse();
}
inline void Tape::get_next_tape_pulse()
{
_time_into_pulse = 0;
_current_pulse = _tape->get_next_pulse();
Working towards HQ UEF support: fixed bug whereby writing to tape output would reset input pulse stepper; added support for chunk 0116 and approximate support for 0113.
2016-02-21 03:03:14 +00:00
if(_input_pulse_stepper == nullptr || _current_pulse.length.clock_rate != _input_pulse_stepper->get_output_rate())
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Working towards HQ UEF support: fixed bug whereby writing to tape output would reset input pulse stepper; added support for chunk 0116 and approximate support for 0113.
2016-02-21 03:03:14 +00:00
_input_pulse_stepper = std::unique_ptr<SignalProcessing::Stepper>(new SignalProcessing::Stepper(_current_pulse.length.clock_rate, 2000000));
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
}
inline void Tape::push_tape_bit(uint16_t bit)
{
_data_register = (uint16_t)((_data_register >> 1) | (bit << 10));
if(_bits_since_start)
{
_bits_since_start--;
if(_bits_since_start == 7)
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_interrupt_status &= ~Interrupt::ReceiveDataFull;
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
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
inline void Tape::reset_tape_input()
{
_bits_since_start = 0;
// _interrupt_status &= ~(Interrupt::ReceiveDataFull | Interrupt::TransmitDataEmpty | Interrupt::HighToneDetect);
//
// if(_last_posted_interrupt_status != _interrupt_status)
// {
// _last_posted_interrupt_status = _interrupt_status;
// if(_delegate) _delegate->tape_did_change_interrupt_status(this);
// }
}
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
inline void Tape::evaluate_interrupts()
{
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
if(!_bits_since_start)
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
{
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
if((_data_register&0x3) == 0x1)
{
_interrupt_status |= Interrupt::ReceiveDataFull;
if(_is_in_input_mode) _bits_since_start = 9;
}
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(_data_register == 0x3ff)
_interrupt_status |= Interrupt::HighToneDetect;
else
_interrupt_status &= ~Interrupt::HighToneDetect;
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)
{
if(_interrupt_status & interrupts)
{
_interrupt_status &= ~interrupts;
if(_delegate) _delegate->tape_did_change_interrupt_status(this);
}
}
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)
{
Working towards HQ UEF support: fixed bug whereby writing to tape output would reset input pulse stepper; added support for chunk 0116 and approximate support for 0113.
2016-02-21 03:03:14 +00:00
_output_pulse_stepper = std::unique_ptr<SignalProcessing::Stepper>(new SignalProcessing::Stepper(1200, 2000000));
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 fix tape output interrupts; offloaded raster width and placing conversion to the GPU.
2016-02-28 01:37:41 +00:00
printf("Loaded — %03x\n", _data_register);
_bits_since_start = _output_bits_remaining = 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
}
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
inline void Tape::run_for_cycles(unsigned int number_of_cycles)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_enabled)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_in_input_mode)
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_is_running && _tape != nullptr)
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
while(number_of_cycles--)
{
Working towards HQ UEF support: fixed bug whereby writing to tape output would reset input pulse stepper; added support for chunk 0116 and approximate support for 0113.
2016-02-21 03:03:14 +00:00
_time_into_pulse += (unsigned int)_input_pulse_stepper->step();
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_time_into_pulse == _current_pulse.length.length)
{
get_next_tape_pulse();
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
_crossings[0] = _crossings[1];
_crossings[1] = _crossings[2];
_crossings[2] = _crossings[3];
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
_crossings[3] = Tape::Unrecognised;
if(_current_pulse.type != Storage::Tape::Pulse::Zero)
{
float pulse_length = (float)_current_pulse.length.length / (float)_current_pulse.length.clock_rate;
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +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;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +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
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(_crossings[0] == Tape::Long && _crossings[1] == Tape::Long)
{
push_tape_bit(0);
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
_crossings[0] = _crossings[1] = Tape::Recognised;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
else
{
if(_crossings[0] == Tape::Short && _crossings[1] == Tape::Short && _crossings[2] == Tape::Short && _crossings[3] == Tape::Short)
{
push_tape_bit(1);
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
_crossings[0] = _crossings[1] =
_crossings[2] = _crossings[3] = Tape::Recognised;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
}
Continued slow migration of shader ownership to CRT. Attempted to start debugging the tape interface.
2016-01-28 02:35:57 +00:00
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
}
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
}
}
else
{
while(number_of_cycles--)
{
Working towards HQ UEF support: fixed bug whereby writing to tape output would reset input pulse stepper; added support for chunk 0116 and approximate support for 0113.
2016-02-21 03:03:14 +00:00
if(_output_pulse_stepper->step())
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_output_bits_remaining--;
Made an attempt to fix tape output interrupts; offloaded raster width and placing conversion to the GPU.
2016-02-28 01:37:41 +00:00
_bits_since_start--;
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
if(!_output_bits_remaining)
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
{
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
_output_bits_remaining = 9;
_interrupt_status |= Interrupt::TransmitDataEmpty;
Fixed failure to set a delegate, slowed tape speed if operating in RAM.
2016-01-23 16:42:14 +00:00
}
Made a very basic attempt to emulate tape output.
2016-01-24 23:20:55 +00:00
evaluate_interrupts();
_data_register = (_data_register >> 1) | 0x200;
Made an attempt to fix tape output interrupts; offloaded raster width and placing conversion to the GPU.
2016-02-28 01:37:41 +00:00
printf("Shifted — %03x\n", _data_register);
It'll be helpful to be able to isolate the tape interface when I'm faking a fast load. So factored out.
2016-01-23 05:14:44 +00:00
}
}
}
}
}
Reference in New Issue Copy Permalink