mirror of
https://github.com/TomHarte/CLK.git
synced 2024-12-25 03:32:01 +00:00
198 lines
6.7 KiB
C++
198 lines
6.7 KiB
C++
//
|
|
// Video.cpp
|
|
// Clock Signal
|
|
//
|
|
// Created by Thomas Harte on 03/05/2019.
|
|
// Copyright © 2019 Thomas Harte. All rights reserved.
|
|
//
|
|
|
|
#include "Video.hpp"
|
|
|
|
#include <algorithm>
|
|
|
|
using namespace Apple::Macintosh;
|
|
|
|
namespace {
|
|
|
|
#if TARGET_RT_BIG_ENDIAN
|
|
constexpr uint64_t PixelMask = 0x8040201008040201;
|
|
#else
|
|
constexpr uint64_t PixelMask = 0x0102040810204080;
|
|
#endif
|
|
|
|
}
|
|
|
|
// Re: CRT timings, see the Apple Guide to the Macintosh Hardware Family,
|
|
// bottom of page 400:
|
|
//
|
|
// "For each scan line, 512 pixels are drawn on the screen ...
|
|
// The horizontal blanking interval takes the time of an additional 192 pixels"
|
|
//
|
|
// And, at the top of 401:
|
|
//
|
|
// "The visible portion of a full-screen display consists of 342 horizontal scan lines...
|
|
// During the vertical blanking interval, the turned-off beam ... traces out an additional 28 scan lines,"
|
|
//
|
|
Video::Video(DeferredAudio &audio, DriveSpeedAccumulator &drive_speed_accumulator) :
|
|
audio_(audio),
|
|
drive_speed_accumulator_(drive_speed_accumulator),
|
|
crt_(704, 1, 370, 6, Outputs::Display::InputDataType::Luminance1) {
|
|
|
|
crt_.set_display_type(Outputs::Display::DisplayType::RGB);
|
|
|
|
// UGLY HACK. UGLY, UGLY HACK. UGLY!
|
|
// The OpenGL scan target fails properly to place visible areas which are not 4:3.
|
|
// The [newer] Metal scan target has no such issue. So assume that Apple => Metal,
|
|
// and set a visible area to work around the OpenGL issue if required.
|
|
// TODO: eliminate UGLY HACK.
|
|
#if defined(__APPLE__) && !defined(IGNORE_APPLE)
|
|
crt_.set_visible_area(Outputs::Display::Rect(0.08f, 10.0f / 368.0f, 0.82f, 344.0f / 368.0f));
|
|
#else
|
|
crt_.set_visible_area(Outputs::Display::Rect(0.08f, -0.025f, 0.82f, 0.82f));
|
|
#endif
|
|
crt_.set_aspect_ratio(1.73f); // The Mac uses a non-standard scanning area.
|
|
}
|
|
|
|
void Video::set_scan_target(Outputs::Display::ScanTarget *scan_target) {
|
|
crt_.set_scan_target(scan_target);
|
|
}
|
|
|
|
Outputs::Display::ScanStatus Video::get_scaled_scan_status() const {
|
|
return crt_.get_scaled_scan_status() / 2.0f;
|
|
}
|
|
|
|
void Video::run_for(HalfCycles duration) {
|
|
// Determine the current video and audio bases. These values don't appear to be latched, they apply immediately.
|
|
const size_t video_base = (use_alternate_screen_buffer_ ? (0xffff2700 >> 1) : (0xffffa700 >> 1)) & ram_mask_;
|
|
const size_t audio_base = (use_alternate_audio_buffer_ ? (0xffffa100 >> 1) : (0xfffffd00 >> 1)) & ram_mask_;
|
|
|
|
// The number of HalfCycles is literally the number of pixel clocks to move through,
|
|
// since pixel output occurs at twice the processor clock. So divide by 16 to get
|
|
// the number of fetches.
|
|
while(duration > HalfCycles(0)) {
|
|
const auto pixel_start = frame_position_ % line_length;
|
|
const int line = int((frame_position_ / line_length).as_integral());
|
|
|
|
const auto cycles_left_in_line = std::min(line_length - pixel_start, duration);
|
|
|
|
// Line timing, entirely invented as I can find exactly zero words of documentation:
|
|
//
|
|
// First 342 lines:
|
|
//
|
|
// First 32 words = pixels;
|
|
// next 5 words = right border;
|
|
// next 2 words = sync level;
|
|
// final 5 words = left border.
|
|
//
|
|
// Then 12 lines of border, 3 of sync, 11 more of border.
|
|
|
|
const int first_word = int(pixel_start.as_integral()) >> 4;
|
|
const int final_word = int((pixel_start + cycles_left_in_line).as_integral()) >> 4;
|
|
|
|
if(first_word != final_word) {
|
|
if(line < 342) {
|
|
// If there are any pixels left to output, do so.
|
|
if(first_word < 32) {
|
|
const int final_pixel_word = std::min(final_word, 32);
|
|
|
|
if(!first_word) {
|
|
pixel_buffer_ = reinterpret_cast<uint64_t *>(crt_.begin_data(512, 8));
|
|
}
|
|
|
|
if(pixel_buffer_) {
|
|
for(int c = first_word; c < final_pixel_word; ++c) {
|
|
const uint16_t pixels = ram_[video_base + video_address_] ^ 0xffff;
|
|
++video_address_;
|
|
|
|
const uint64_t low_pixels = (pixels & 0xff) * 0x0101010101010101;
|
|
const uint64_t high_pixels = (pixels >> 8) * 0x0101010101010101;
|
|
|
|
pixel_buffer_[0] = high_pixels & PixelMask;
|
|
pixel_buffer_[1] = low_pixels & PixelMask;
|
|
pixel_buffer_ += 2;
|
|
}
|
|
} else {
|
|
video_address_ += size_t(final_pixel_word - first_word);
|
|
}
|
|
|
|
if(final_pixel_word == 32) {
|
|
crt_.output_data(512);
|
|
pixel_buffer_ = nullptr;
|
|
}
|
|
}
|
|
|
|
if(first_word < sync_start && final_word >= sync_start) crt_.output_blank((sync_start - 32) * 16);
|
|
if(first_word < sync_end && final_word >= sync_end) crt_.output_sync((sync_end - sync_start) * 16);
|
|
if(final_word == 44) crt_.output_blank((44 - sync_end) * 16);
|
|
} else if(final_word == 44) {
|
|
if(line >= 353 && line < 356) {
|
|
/* Output a sync line. */
|
|
crt_.output_sync(sync_start * 16);
|
|
crt_.output_blank((sync_end - sync_start) * 16);
|
|
crt_.output_sync((44 - sync_end) * 16);
|
|
} else {
|
|
/* Output a blank line. */
|
|
crt_.output_blank(sync_start * 16);
|
|
crt_.output_sync((sync_end - sync_start) * 16);
|
|
crt_.output_blank((44 - sync_end) * 16);
|
|
}
|
|
}
|
|
|
|
// Audio and disk fetches occur "just before video data".
|
|
if(final_word == 44) {
|
|
const uint16_t audio_word = ram_[audio_address_ + audio_base];
|
|
++audio_address_;
|
|
audio_.audio.post_sample(audio_word >> 8);
|
|
drive_speed_accumulator_.post_sample(audio_word & 0xff);
|
|
}
|
|
}
|
|
|
|
duration -= cycles_left_in_line;
|
|
frame_position_ = frame_position_ + cycles_left_in_line;
|
|
if(frame_position_ == frame_length) {
|
|
frame_position_ = HalfCycles(0);
|
|
/*
|
|
Video: $1A700 and the alternate buffer starts at $12700; for a 512K Macintosh, add $60000 to these numbers.
|
|
*/
|
|
video_address_ = 0;
|
|
|
|
/*
|
|
"The main sound buffer is at $1FD00 in a 128K Macintosh, and the alternate buffer is at $1A100;
|
|
for a 512K Macintosh, add $60000 to these values."
|
|
*/
|
|
audio_address_ = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Video::vsync() {
|
|
const auto line = (frame_position_ / line_length).as_integral();
|
|
return line >= 353 && line < 356;
|
|
}
|
|
|
|
HalfCycles Video::get_next_sequence_point() {
|
|
const auto line = (frame_position_ / line_length).as_integral();
|
|
if(line >= 353 && line < 356) {
|
|
// Currently in vsync, so get time until start of line 357,
|
|
// when vsync will end.
|
|
return HalfCycles(356) * line_length - frame_position_;
|
|
} else {
|
|
// Not currently in vsync, so get time until start of line 353.
|
|
const auto start_of_vsync = HalfCycles(353) * line_length;
|
|
if(frame_position_ < start_of_vsync)
|
|
return start_of_vsync - frame_position_;
|
|
else
|
|
return start_of_vsync + HalfCycles(number_of_lines) * line_length - frame_position_;
|
|
}
|
|
}
|
|
|
|
void Video::set_use_alternate_buffers(bool use_alternate_screen_buffer, bool use_alternate_audio_buffer) {
|
|
use_alternate_screen_buffer_ = use_alternate_screen_buffer;
|
|
use_alternate_audio_buffer_ = use_alternate_audio_buffer;
|
|
}
|
|
|
|
void Video::set_ram(uint16_t *ram, uint32_t mask) {
|
|
ram_ = ram;
|
|
ram_mask_ = mask;
|
|
}
|