// SPDX-License-Identifier: GPL-3.0-or-later #include "../ssc/session.h" #include "../guest-captures.h" // Observe the actual guest writes in a spare MPI slot. The Orchestra-90 in a // different slot supplies every host audio sample independently of this probe. struct DacLog final : CartridgeDevice { struct Write { unsigned audioTick; unsigned char port, value; }; std::vector writes; unsigned audioTick = 0; void reset() override { writes.clear(); audioTick = 0; } void horizontalSync(DeviceHost&) override {} void advanceAudio() override { ++audioTick; } std::uint8_t readMemory(std::uint16_t) const override { return 0xff; } std::uint8_t readPort(std::uint8_t, DeviceHost&) override { return 0; } void writePort(std::uint8_t port, std::uint8_t value, DeviceHost&) override { if (port == 0x7a || port == 0x7b) writes.push_back({audioTick, port, value}); } }; static void frames(Session& session, unsigned count) { for (unsigned i = 0; i < count; ++i) session.tick(); } static void verifyBasic(Session& session) { session.until("OK", 180); frames(session, 12); session.press(47, true); session.press(39); session.press(43, true); session.press(35); session.press(48); // ?7+3 session.until(" 10"); } struct Pair { unsigned tick; unsigned char left, right; }; static std::vector pairs(const DacLog& log) { std::vector result; require(log.writes.size() % 2 == 0, "An incomplete stereo DAC pair"); for (std::size_t i = 0; i < log.writes.size(); i += 2) { const auto& l = log.writes[i]; const auto& r = log.writes[i + 1]; require(l.port == 0x7a && r.port == 0x7b, "DAC writes out of stereo order"); result.push_back({l.audioTick, l.value, r.value}); } return result; } static double measuredRate(std::size_t intervals, unsigned audioTicks) { require(audioTicks != 0, "Elapsed audio ticks must be positive"); return 44100.0 * intervals / audioTicks; } static void qualify(Session& run, DacLog& log, bool fast) { run.launch(readFile("QUAL.BIN")); run.until("SELECT CLOCK"); log.writes.clear(); run.press(fast ? 34 : 33); run.until("RESTORED", 240); const auto writes = pairs(log); require(writes.size() > 518, "One-shot or loop failed to write frames"); require(writes[0].left == 19 && writes[0].right == 235, "Missing fixture DAC marker"); require(writes[1].left == 128 && writes[1].right == 128, "Cancelled startup emitted a sample"); for (unsigned i = 0; i < 512; ++i) { auto level = (i & 8) ? 64 : 192; require(writes[i + 2].left == (i < 256 ? level : 128) && writes[i + 2].right == (i < 256 ? 128 : level), "One-shot frames dropped, reordered or distorted"); } require(writes[514].left == 128 && writes[514].right == 128, "Natural end left a DAC on"); require(writes[515].left == 192 && writes[515].right == 128 && writes[516].left == 128 && writes[516].right == 128, "Single-frame replay failed"); const auto count = writes.size(); require(writes[count - 1].left == 21 && writes[count - 1].right == 233, "Missing final DAC marker"); require(writes[count - 2].left == 128 && writes[count - 2].right == 128, "Manual stop left a DAC on"); for (unsigned i = 517; i + 2 < count; ++i) { auto level = ((i - 517) & 8) ? 64 : 192; require(writes[i].left == level && writes[i].right == 128, "Loop boundary or frame mismatch"); } const auto rate = measuredRate(511, writes[513].tick - writes[2].tick); require(rate > 3600 && rate < 4050, "Quiet foreground sample rate: " + std::to_string(rate)); std::cout << " " << (fast ? "fast" : "normal") << " entry, " << rate << " frames/s, CPU speed and interrupts restored\n"; verifyBasic(run); } // Look at the real text scanout so a frozen picture can't pass as animation. static int marker(Session& run, unsigned row, char symbol) { const auto screen = run.machine.copyScreenText(); std::size_t start = 0; for (unsigned i = 0; i < row; ++i) { auto next = screen.find('\n', start); if (next == std::string::npos) return -1; start = next + 1; } const auto end = screen.find('\n', start); auto column = screen.substr(start, end - start).find(symbol); return column == std::string::npos ? -1 : int(column); } static void bookExercise(Session& run, DacLog& log, bool disk, bool capture, bool installed = true) { if (disk) run.diskExec(readFile("VOL.DSK"), "FLYBY"); else run.launch(readFile("FLYBY.BIN")); run.until("STEREO FLYBY", 1200); for (unsigned i = 0; i < 180 && marker(run, 10, '^') != 15; ++i) run.tick(); require(marker(run, 10, '^') == 15, "Ship did not appear at its starting position"); run.press(33); run.until("BEACON ON AIR", 240); run.machine.setJoystick(0, 16383, 8191, 0, 0); const auto logsBefore = log.writes.size(); const auto originalTick = log.audioTick; run.audio.clear(); int firstStar = marker(run, 8, '*'); bool moved = false; for (unsigned f = 0; f < 120; ++f) { run.tick(); int star = marker(run, 8, '*'); if (star >= 2 && firstStar >= 2 && star != firstStar) moved = true; } require(moved && marker(run, 10, '^') >= 28, "Star or joystick-controlled ship stalled during sound"); run.machine.setJoystick(0, 8191, 8191, 0, 0); const double rate = measuredRate((log.writes.size() - logsBefore) / 2, log.audioTick - originalTick); require(rate > 3450 && rate < 4050, "Active foreground sample rate: " + std::to_string(rate)); std::size_t channelFrames[2] = {}, periods[2] = {}, elapsed[2] = {}, last[2] = {}; bool high[2] = {}; for (std::size_t i = 0; i < run.audio.size(); ++i) { const auto sample = run.audio[i]; if (!installed) { require(sample.left == sample.right, "Unexpected stereo with cartridge absent"); continue; } const float levels[] = {sample.left, sample.right}; require(sample.left == 0.5f || sample.right == 0.5f, "A stereo note crossed or dropped out"); for (unsigned side = 0; side < 2; ++side) { channelFrames[side] += std::abs(levels[side] - 0.5f) > 0.04f; bool nowHigh = levels[side] > 0.55f; if (nowHigh && !high[side]) { auto distance = i - last[side]; // The loop has silent gaps between its two notes. Count only // adjacent waveform periods inside one note, ignoring gaps. if (last[side] && distance < 300) { ++periods[side]; elapsed[side] += distance; } last[side] = i; } high[side] = nowHigh; } } if (installed) { for (unsigned side = 0; side < 2; ++side) { require(channelFrames[side] > 2000 && periods[side] > 30, "Missing stereo cycles"); const double frequency = 44100.0 * periods[side] / elapsed[side]; const double expected = rate / (side ? 8 : 16); require(std::abs(frequency - expected) < expected * 0.05, "Incorrect stereo note pitch"); std::cout << (side ? "right " : " left ") << frequency << " Hz "; } std::cout << '\n'; } if (capture) { BasicDiskTests::saveActiveFrame(*run.machine.snapshot().frame, "flyby.ppm"); saveWav("flyby.wav", run.audio); } run.press(17); run.until("FLYBY COMPLETE"); const auto stopped = log.writes.size(); verifyBasic(run); require(log.writes.size() == stopped, "Background writes continued after BASIC regained control"); if (disk) require(run.floppy->readEvents(0) > 0 && run.floppy->writeEvents(0) == 0, "Unexpected demo disk I/O"); std::cout << " " << (installed ? "stereo" : "absent") << " " << (disk ? "disk" : "direct") << ", steering/animation: " << rate << " frames/s\n"; } int main(int argc, char** argv) { try { require(argc == 2 || argc == 3, "Usage: run ROM_DIRECTORY [capture]"); const fs::path rom(argv[1]); const auto system = readFile(rom / "coco3.rom"), disk = readFile(rom / "disk11.rom"); for (auto cpu : {Processor::MC6809, Processor::HD6309}) { std::cout << (cpu == Processor::MC6809 ? "6809" : "6309") << std::endl; for (bool fast : {false, true}) { auto log = std::make_shared(); Session guest(cpu, system, disk, nullptr, true, log); qualify(guest, *log, fast); } for (bool fromDisk : {false, true}) { auto log = std::make_shared(); Session guest(cpu, system, disk, nullptr, true, log); bookExercise(guest, *log, fromDisk, argc == 3 && cpu == Processor::MC6809 && !fromDisk); } auto log = std::make_shared(); Session absent(cpu, system, disk, nullptr, false, log); bookExercise(absent, *log, false, false, false); } } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } }