From 38d096cad63e104bace75c8ee027dde152bf61cb Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Thu, 25 Apr 2024 22:01:38 -0400 Subject: [PATCH] Begin new state machine, losing all non-cursor pixels. --- Machines/Acorn/Archimedes/Video.hpp | 363 ++++++++++++++++------------ 1 file changed, 206 insertions(+), 157 deletions(-) diff --git a/Machines/Acorn/Archimedes/Video.hpp b/Machines/Acorn/Archimedes/Video.hpp index 5c9a90400..de76d43ee 100644 --- a/Machines/Acorn/Archimedes/Video.hpp +++ b/Machines/Acorn/Archimedes/Video.hpp @@ -26,7 +26,7 @@ struct Video { ram_(ram), crt_(Outputs::Display::InputDataType::Red4Green4Blue4) { set_clock_divider(3); - crt_.set_visible_area(Outputs::Display::Rect(0.06f, 0.07f, 0.9f, 0.9f)); +// crt_.set_visible_area(Outputs::Display::Rect(0.06f, 0.07f, 0.9f, 0.9f)); crt_.set_display_type(Outputs::Display::DisplayType::RGB); } @@ -131,9 +131,10 @@ struct Video { horizontal_state_.increment_position(horizontal_timing_); if(horizontal_state_.did_restart()) { + end_horizontal(); + const auto old_phase = vertical_state_.phase(); vertical_state_.increment_position(vertical_timing_); - pixel_count_ = 0; const auto phase = vertical_state_.phase(); if(phase != old_phase) { @@ -167,158 +168,14 @@ struct Video { cursor_pixel_ = 32; } - // Accumulate total phase. - ++time_in_phase_; - - // Determine current output phase. - Phase new_phase; + // Move along line. switch(vertical_state_.phase()) { - case Phase::Sync: new_phase = Phase::Sync; break; - case Phase::Blank: new_phase = Phase::Blank; break; - case Phase::Border: - new_phase = horizontal_state_.phase() == Phase::Display ? Phase::Border : horizontal_state_.phase(); - break; - case Phase::Display: - new_phase = horizontal_state_.phase(); - break; + case Phase::Sync: tick_horizontal(); break; + case Phase::Blank: tick_horizontal(); break; + case Phase::Border: tick_horizontal(); break; + case Phase::Display: tick_horizontal(); break; } - - const auto flush_pixels = [&]() { - const auto duration = static_cast(time_in_phase_); - crt_.output_data(duration, static_cast(time_in_phase_) * 2); - time_in_phase_ = 0; - pixels_ = nullptr; - }; - - // Possibly output something. - if(new_phase != phase_ || (phase_ == Phase::Border && phased_border_colour_ != border_colour_)) { - if(time_in_phase_) { - const auto duration = static_cast(time_in_phase_); - - switch(phase_) { - case Phase::Sync: crt_.output_sync(duration); break; - case Phase::Blank: crt_.output_blank(duration); break; - case Phase::Display: flush_pixels(); break; - case Phase::Border: crt_.output_level(duration, phased_border_colour_); break; - } - time_in_phase_ = 0; - } - phase_ = new_phase; - phased_border_colour_ = border_colour_; - } - - // Update cursor pixel counter if applicable; this might mean triggering it - // and it might just mean advancing it if it has already been triggered. - if(vertical_state_.cursor_active) { - const auto pixel_position = horizontal_state_.position << 1; - if(pixel_position <= horizontal_timing_.cursor_start && (pixel_position + 2) > horizontal_timing_.cursor_start) { - cursor_pixel_ = int(horizontal_timing_.cursor_start) - int(pixel_position); - } - } - - // Grab some more pixels if appropriate. - if(vertical_state_.display_active() && horizontal_state_.display_active()) { - const auto next_byte = [&]() -> uint8_t { - const auto next = ram_[address_]; - ++address_; - - // `buffer_end_` is the final address that a 16-byte block will be fetched from; - // the +16 here papers over the fact that I'm not accurately implementing DMA. - if(address_ == buffer_end_ + 16) { - address_ = buffer_start_; - } - return next; - }; - - switch(colour_depth_) { - case Depth::EightBPP: - pixel_data_[0] = next_byte(); - pixel_data_[1] = next_byte(); - break; - case Depth::FourBPP: - pixel_data_[0] = next_byte(); - break; - case Depth::TwoBPP: - if(!(pixel_count_&1)) { - pixel_data_[0] = next_byte(); - } - break; - case Depth::OneBPP: - if(!(pixel_count_&3)) { - pixel_data_[0] = next_byte(); - } - break; - } - ++pixel_count_; - } - - if(phase_ == Phase::Display) { - if(pixels_ && time_in_phase_ == PixelBufferSize/2) { - flush_pixels(); - } - - if(!pixels_) { - if(time_in_phase_) { - flush_pixels(); - } - - pixels_ = reinterpret_cast(crt_.begin_data(PixelBufferSize)); - } - - if(pixels_) { - // Each tick in here is two ticks of the pixel clock, so: - // - // 8bpp mode: output two bytes; - // 4bpp mode: output one byte; - // 2bpp mode: output one byte every second tick; - // 1bpp mode: output one byte every fourth tick. - switch(colour_depth_) { - case Depth::EightBPP: - pixels_[0] = (colours_[pixel_data_[0] & 0xf] & colour(0b0111'0011'0111)) | high_spread[pixel_data_[0] >> 4]; - pixels_[1] = (colours_[pixel_data_[1] & 0xf] & colour(0b0111'0011'0111)) | high_spread[pixel_data_[1] >> 4]; - break; - - case Depth::FourBPP: - pixels_[0] = colours_[pixel_data_[0] & 0xf]; - pixels_[1] = colours_[pixel_data_[0] >> 4]; - break; - - case Depth::TwoBPP: - pixels_[0] = colours_[pixel_data_[0] & 3]; - pixels_[1] = colours_[(pixel_data_[0] >> 2) & 3]; - pixel_data_[0] >>= 4; - break; - - case Depth::OneBPP: - pixels_[0] = colours_[pixel_data_[0] & 1]; - pixels_[1] = colours_[(pixel_data_[0] >> 1) & 1]; - pixel_data_[0] >>= 2; - break; - } - - // Overlay cursor if applicable. - // TODO: pull this so far out that the cursor can display over the border, too. - if(cursor_pixel_ < 32) { - if(cursor_pixel_ >= 0) { - const auto pixel = cursor_image_[static_cast(cursor_pixel_)]; - if(pixel) { - pixels_[0] = cursor_colours_[pixel]; - } - } - if(cursor_pixel_ < 31) { - const auto pixel = cursor_image_[static_cast(cursor_pixel_ + 1)]; - if(pixel) { - pixels_[1] = cursor_colours_[pixel]; - } - } - } - - pixels_ += 2; - } - } - - // Advance cursor position. - if(cursor_pixel_ < 32) cursor_pixel_ += 2; + ++time_in_phase_; } /// @returns @c true if a vertical retrace interrupt has been signalled since the last call to @c interrupt(); @c false otherwise. @@ -433,14 +290,16 @@ private: }; State horizontal_state_; State vertical_state_; - Phase phase_ = Phase::Sync; - uint32_t time_in_phase_ = 0; - uint32_t pixel_count_ = 0; - uint16_t *pixels_ = nullptr; + + int time_in_phase_ = 0; + Phase phase_; uint16_t phased_border_colour_; + uint32_t pixel_count_ = 0; + uint16_t *pixels_ = nullptr; + // It is elsewhere assumed that this size is a multiple of 8. - static constexpr size_t PixelBufferSize = 320; + static constexpr size_t PixelBufferSize = 256; // Programmer-set addresses. uint32_t buffer_start_ = 0; @@ -499,6 +358,196 @@ private: Outputs::CRT::PAL::AlternatesPhase); clock_rate_observer_.update_clock_rates(); } + + void flush_pixels() { + crt_.output_data(time_in_phase_, static_cast(pixel_count_)); + time_in_phase_ = 0; + pixel_count_ = 0; + pixels_ = nullptr; + } + + void set_phase(Phase phase) { + if(time_in_phase_) { + switch(phase_) { + case Phase::Sync: crt_.output_sync(time_in_phase_); break; + case Phase::Blank: crt_.output_blank(time_in_phase_); break; + case Phase::Border: crt_.output_level(time_in_phase_, phased_border_colour_); break; + case Phase::Display: flush_pixels(); break; + } + } + + phase_ = phase; + time_in_phase_ = 0; + phased_border_colour_ = border_colour_; + pixel_count_ = 0; + } + + void end_horizontal() { + set_phase(Phase::Sync); + } + + template void tick_horizontal() { + // Sync lines: obey nothing. All sync, all the time. + if constexpr (vertical_phase == Phase::Sync) { + return; + } + + // Blank lines: obey only the transition from sync to non-sync. + if constexpr (vertical_phase == Phase::Blank) { + if(phase_ == Phase::Sync && horizontal_state_.phase() != Phase::Sync) { + set_phase(Phase::Blank); + } + return; + } + + // Border lines: ignore display phases; also reset the border phase if the colour changes. + const auto horizontal_phase = horizontal_state_.phase(); + const auto phase = horizontal_phase != Phase::Display ? horizontal_phase : Phase::Border; + + if(phase != phase_ || (phase_ == Phase::Border && border_colour_ != phased_border_colour_)) { + set_phase(phase); + } + } + + template <> + void tick_horizontal() { + // Some timing facts, to explain what would otherwise be magic constants. + static constexpr int CursorDelay = 6; // The cursor will appear six pixels after its programmed trigger point. +// static constexpr int Delay1bpp = 19; +// static constexpr int Delay2bpp = 11; +// static constexpr int Delay4bpp = 7; +// static constexpr int Delay8bpp = 7; + + // Deal with sync and blank via set_phase(); collapse display and border into Phase::Display. + const auto horizontal_phase = horizontal_state_.phase(); + const auto phase = horizontal_phase == Phase::Border ? Phase::Display : horizontal_phase; + if(phase != phase_) set_phase(phase); + + // Update cursor pixel counter if applicable; this might mean triggering it + // and it might just mean advancing it if it has already been triggered. + if(vertical_state_.cursor_active) { + const auto pixel_position = horizontal_state_.position << 1; + if(pixel_position <= horizontal_timing_.cursor_start && (pixel_position + 2) > horizontal_timing_.cursor_start) { + cursor_pixel_ = int(horizontal_timing_.cursor_start) - int(pixel_position) - CursorDelay; + } + } + + // TODO: if in the display phase, do some fetching. + + // If this is not [collapsed] Phase::Display, just stop here. + if(phase_ != Phase::Display) return; + + // Display phase: maintain an output buffer (if available). + if(pixel_count_ == PixelBufferSize) flush_pixels(); + if(!pixel_count_) pixels_ = reinterpret_cast(crt_.begin_data(PixelBufferSize)); + + // TOOD: proper here. + if(pixels_) { + pixels_[0] = border_colour_; + pixels_[1] = border_colour_; + + // Overlay cursor if applicable. + if(cursor_pixel_ < 32) { + if(cursor_pixel_ >= 0) { + const auto pixel = cursor_image_[static_cast(cursor_pixel_)]; + if(pixel) { + pixels_[0] = cursor_colours_[pixel]; + } + } + if(cursor_pixel_ >= -1 && cursor_pixel_ < 31) { + const auto pixel = cursor_image_[static_cast(cursor_pixel_ + 1)]; + if(pixel) { + pixels_[1] = cursor_colours_[pixel]; + } + } + } + + pixels_ += 2; + } + + cursor_pixel_ += 2; + pixel_count_ += 2; + } + +// // Grab some more pixels if appropriate. +// if(vertical_state_.display_active() && horizontal_state_.display_active()) { +// const auto next_byte = [&]() -> uint8_t { +// const auto next = ram_[address_]; +// ++address_; +// +// // `buffer_end_` is the final address that a 16-byte block will be fetched from; +// // the +16 here papers over the fact that I'm not accurately implementing DMA. +// if(address_ == buffer_end_ + 16) { +// address_ = buffer_start_; +// } +// return next; +// }; +// +// switch(colour_depth_) { +// case Depth::EightBPP: +// pixel_data_[0] = next_byte(); +// pixel_data_[1] = next_byte(); +// break; +// case Depth::FourBPP: +// pixel_data_[0] = next_byte(); +// break; +// case Depth::TwoBPP: +// if(!(pixel_count_&1)) { +// pixel_data_[0] = next_byte(); +// } +// break; +// case Depth::OneBPP: +// if(!(pixel_count_&3)) { +// pixel_data_[0] = next_byte(); +// } +// break; +// } +// ++pixel_count_; +// } +// +// if(phase_ == Phase::Display) { +// if(pixels_ && time_in_phase_ == PixelBufferSize/2) { +// flush_pixels(); +// } +// +// if(!pixels_) { +// if(time_in_phase_) { +// flush_pixels(); +// } +// +// pixels_ = reinterpret_cast(crt_.begin_data(PixelBufferSize)); +// } +// +// if(pixels_) { +// // Each tick in here is two ticks of the pixel clock, so: +// // +// // 8bpp mode: output two bytes; +// // 4bpp mode: output one byte; +// // 2bpp mode: output one byte every second tick; +// // 1bpp mode: output one byte every fourth tick. +// switch(colour_depth_) { +// case Depth::EightBPP: +// pixels_[0] = (colours_[pixel_data_[0] & 0xf] & colour(0b0111'0011'0111)) | high_spread[pixel_data_[0] >> 4]; +// pixels_[1] = (colours_[pixel_data_[1] & 0xf] & colour(0b0111'0011'0111)) | high_spread[pixel_data_[1] >> 4]; +// break; +// +// case Depth::FourBPP: +// pixels_[0] = colours_[pixel_data_[0] & 0xf]; +// pixels_[1] = colours_[pixel_data_[0] >> 4]; +// break; +// +// case Depth::TwoBPP: +// pixels_[0] = colours_[pixel_data_[0] & 3]; +// pixels_[1] = colours_[(pixel_data_[0] >> 2) & 3]; +// pixel_data_[0] >>= 4; +// break; +// +// case Depth::OneBPP: +// pixels_[0] = colours_[pixel_data_[0] & 1]; +// pixels_[1] = colours_[(pixel_data_[0] >> 1) & 1]; +// pixel_data_[0] >>= 2; +// break; +// } }; }