Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,209 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
#include "CoreChecks.h"
|
||||
#include "../../src/core/MachineSession.h"
|
||||
#include "../../src/core/AudioBuffer.h"
|
||||
#include "../../src/devices/Orchestra90Device.h"
|
||||
#include "../../src/core/FramePacing.h"
|
||||
#include "../../src/core/mc6821.h"
|
||||
#include "../../src/core/tcc1014mmu.h"
|
||||
#include <stdexcept>
|
||||
#include <cmath>
|
||||
#include <thread>
|
||||
#include <algorithm>
|
||||
using namespace VCC::Mac;
|
||||
namespace {
|
||||
void require(bool v,const char* text) { if(!v) throw std::runtime_error(text); }
|
||||
template<class F> void rejects(F f) { bool rejected=false; try { f(); } catch(const std::exception&) { rejected=true; } require(rejected,"Malformed cassette must be rejected"); }
|
||||
}
|
||||
void CheckAudioBuffer() {
|
||||
auto s=ConvertDAC(0x4000c000); require(s.left==0.5f && s.right==-0.5f,"Explicit signed PCM and stereo order");
|
||||
AudioBuffer ring; ring.gain=1;
|
||||
StereoSample input[2]={{.25f,-.5f},{.5f,-.25f}};
|
||||
float left[4],right[4]; ring.write(input,2); ring.read(left,right,4);
|
||||
require(left[0]==.25f && right[1]==-.25f && left[3]==0 && ring.underruns==2,"Bounded render fills underruns with silence");
|
||||
std::vector<StereoSample> full(9000,{1,-1}); ring.write(full.data(),full.size());
|
||||
require(ring.size()==8192 && ring.overruns==808,"Audio overflow bounded and counted");
|
||||
require(ring.submitted==9002 && ring.signalSamples==8194,"Diagnostics count submitted and accepted nonzero samples independently of gain");
|
||||
ring.clear(); ring.gain=0; ring.write(input,2); ring.read(left,right,2);
|
||||
require(left[0]==0 && right[1]==0 && ring.size()==0,"Mute still consumes audio clock");
|
||||
ring.gain=1;
|
||||
std::thread producer([&] { for(unsigned i=0;i<100000;++i) { while(ring.size()>=4000) std::this_thread::yield(); StereoSample value{float(i),-float(i)}; ring.write(&value,1); } });
|
||||
bool ordered=true;
|
||||
for(unsigned i=0;i<100000;++i) { while(!ring.size()) std::this_thread::yield(); ring.read(left,right,1); ordered &= left[0]==float(i) && right[0]==-float(i); }
|
||||
producer.join(); require(ordered,"Concurrent audio preserves order across wraparound");
|
||||
// Model an 80 ms producer stall while the device continues reading every 10 ms.
|
||||
// The previous 50 ms target would underrun during this interval.
|
||||
AudioBuffer reserve; reserve.gain = 1;
|
||||
std::vector<StereoSample> frame(739, {.25f, -.25f});
|
||||
while (reserve.size() < audioTargetSamples) reserve.write(frame.data(), frame.size());
|
||||
float blockLeft[441], blockRight[441];
|
||||
for (unsigned block = 0; block < 8; ++block) {
|
||||
reserve.read(blockLeft, blockRight, 441);
|
||||
require(blockLeft[440] == .25f && blockRight[440] == -.25f, "Audio reserve survives an 80 ms producer stall");
|
||||
}
|
||||
require(reserve.underruns == 0 && reserve.maximumRequest == 441, "Stall recovery preserves samples and records callback demand");
|
||||
while (reserve.size() < audioTargetSamples) reserve.write(frame.data(), frame.size());
|
||||
require(reserve.overruns == 0 && reserve.size() < audioTargetSamples + frame.size(), "Refill stays bounded to the target plus one guest frame");
|
||||
}
|
||||
void CheckAudioScheduling() {
|
||||
for(auto cpu:{Processor::MC6809,Processor::HD6309}) {
|
||||
MachineSession machine; machine.loadDiagnostic(cpu); machine.resume();
|
||||
pia1_write(4,0x21); pia1_write(12,0x23); pia1_write(128,0x20);
|
||||
unsigned samples=0;
|
||||
for(unsigned i=0;i<60;++i) { machine.advance(); auto a=machine.takeAudio(); samples+=a.size(); require(!a.empty() && a[0].left==.25f,"Real PIA DAC reaches audio frames"); }
|
||||
require(samples>44300 && samples<44400,"44.1 kHz audio follows nominal emulated NTSC time");
|
||||
machine.pause(); machine.advance(); require(machine.takeAudio().empty(),"Pause generates no samples");
|
||||
machine.softReset(); require(GetDACSample()==0 && GetCasSample()==0,"Reset clears PIA sound latches");
|
||||
machine.resume(); machine.advance(); require(machine.takeAudio().size()<800,"Reset schedules one sampler, not duplicate callbacks");
|
||||
}
|
||||
}
|
||||
void CheckAudioRouting() {
|
||||
struct SpeakerSource final : VCC::Devices::CartridgeDevice {
|
||||
std::uint16_t value = 0x8080;
|
||||
void reset() override { }
|
||||
void horizontalSync(VCC::Devices::DeviceHost&) override { }
|
||||
std::uint8_t readMemory(std::uint16_t) const override { return 0xff; }
|
||||
std::uint8_t readPort(std::uint8_t, VCC::Devices::DeviceHost&) override { return 0; }
|
||||
void writePort(std::uint8_t, std::uint8_t, VCC::Devices::DeviceHost&) override { }
|
||||
bool hasCartridgeAudioOutput() const override { return true; }
|
||||
std::uint16_t audio() const override { return value; }
|
||||
};
|
||||
for (auto cpu : {Processor::MC6809, Processor::HD6309}) {
|
||||
MachineSession machine;
|
||||
auto speaker = std::make_shared<SpeakerSource>();
|
||||
auto orchestra = std::make_shared<VCC::Devices::Orchestra90Device>();
|
||||
machine.cartridges().configure({nullptr, speaker, orchestra, nullptr, nullptr}, true, 4);
|
||||
machine.loadDiagnostic(cpu); machine.resume();
|
||||
auto mux = [&](unsigned selection) {
|
||||
pia0_write(0x34 | ((selection & 1) << 3), 0x01);
|
||||
pia0_write(0x34 | ((selection & 2) << 2), 0x03);
|
||||
};
|
||||
auto sample = [&](float left, float right, const char* reason) {
|
||||
machine.takeAudio(); machine.advance(); const auto pcm = machine.takeAudio();
|
||||
require(!pcm.empty() && std::all_of(pcm.begin(), pcm.end(), [&](auto value) {
|
||||
return value.left == left && value.right == right;
|
||||
}), reason);
|
||||
};
|
||||
pia1_write(0x34, 0x21); pia1_write(0x34, 0x23);
|
||||
// Joystick conversion writes the DAC while the sound gate is closed.
|
||||
pia1_write(252, 0x20);
|
||||
for (unsigned repeat = 0; repeat < 3; ++repeat) for (unsigned selection = 0; selection < 4; ++selection) {
|
||||
mux(selection); speaker->value = repeat == 0 ? 0x8080 : 0x10f0;
|
||||
sample(0, 0, "Disabled analog sound must remain silent through joystick-style mux changes");
|
||||
}
|
||||
pia1_write(0x3c, 0x23); mux(0);
|
||||
sample(126/256.0f, 126/256.0f, "Re-enabling sound reads the current DAC latch");
|
||||
speaker->value = 0x4080; mux(2);
|
||||
sample(-.25f, 0, "Cartridge SND is centered and selected only on its analog input");
|
||||
speaker->value = 0;
|
||||
sample(-.5f, -.5f, "A cartridge zero sample is a valid negative peak, not absence");
|
||||
speaker->value = 0x8080;
|
||||
sample(0, 0, "An idle cartridge midpoint is silence");
|
||||
mux(3); sample(0, 0, "Unused analog mux input is grounded");
|
||||
// The stopped cassette has midpoint128, even with a cartridge installed.
|
||||
mux(1); sample(0, 0, "Stopped tape does not leak cartridge sound");
|
||||
machine.cartridges().writePort(0x7a, 64); machine.cartridges().writePort(0x7b, 192);
|
||||
pia1_write(0x34, 0x23);
|
||||
for (unsigned selection = 0; selection < 4; ++selection) {
|
||||
mux(selection); sample(.25f, .75f, "External Orchestra-90 stereo bypasses the speaker gate and mux");
|
||||
}
|
||||
machine.cartridges().writePort(0x7a, 0); machine.cartridges().writePort(0x7b, 0);
|
||||
// Configure the one-bit output and check that it is independent too.
|
||||
pia1_write(0x30, 0x23); pia1_write(2, 0x22); pia1_write(0x34, 0x23); pia1_write(2, 0x22);
|
||||
sample(.5f, .5f, "Single-bit sound remains audible with the analog gate closed");
|
||||
machine.cartridges().writePort(0x7a, 255); machine.cartridges().writePort(0x7b, 0);
|
||||
mux(0); pia1_write(0x3c, 0x23);
|
||||
sample(1.0f, 254/256.0f, "Combined sources saturate instead of wrapping signed PCM");
|
||||
}
|
||||
}
|
||||
void CheckCassetteImages() {
|
||||
CassetteDeck deck; deck.mount({0x55,0x3c,0xa5},TapeFormat::CAS); deck.play();
|
||||
for(unsigned i=0;i<1000;++i) require(deck.tick(0)==128,"Motor gates tape movement");
|
||||
require(deck.snapshot().position==0,"Motor-off playback preserves position"); deck.motor(true);
|
||||
for(unsigned i=0;i<32000;++i) deck.tick(0);
|
||||
require(deck.snapshot().mode==TapeMode::Stopped && deck.snapshot().position==3,"CAS playback ends without wrapping");
|
||||
deck.seek(1000); require(deck.snapshot().position==3,"Seeking clamps to end of tape");
|
||||
deck.seek(1); require(deck.snapshot().position==1 && deck.snapshot().mode==TapeMode::Stopped,"Seeking stops at selected byte");
|
||||
deck.rewind(); require(deck.exportImage()==std::vector<std::uint8_t>({0x55,0x3c,0xa5}),"CAS export retains original bytes");
|
||||
rejects([&]{deck.mount({1,2,3},TapeFormat::WAV);});
|
||||
require(deck.exportImage().size()==3,"Failed mount leaves old tape intact");
|
||||
deck.record(TapeFormat::WAV); deck.motor(true);
|
||||
for(unsigned i=0;i<101;++i) deck.tick(i*2);
|
||||
auto wav=deck.exportImage(); require(deck.snapshot().dirty,"Export does not mark an unsaved recording as saved");
|
||||
deck.markSaved(); require(!deck.snapshot().dirty,"Successful save clears dirty state");
|
||||
require(wav.size()==146 && wav[40]==101,"WAV header sizes include odd-byte padding correctly");
|
||||
deck.mount(wav,TapeFormat::WAV); deck.play();
|
||||
for(unsigned i=0;i<101;++i) require(deck.tick(0)==i*2,"WAV recording reloads sample-exactly");
|
||||
auto truncated=wav; truncated.resize(30); rejects([&]{deck.mount(truncated,TapeFormat::WAV);});
|
||||
auto bad=wav; bad[22]=3; rejects([&]{deck.mount(bad,TapeFormat::WAV);});
|
||||
auto chunked=wav; chunked.insert(chunked.begin()+12,{'J','U','N','K',2,0,0,0,0,0}); chunked[4]+=10;
|
||||
deck.mount(chunked,TapeFormat::WAV); require(deck.snapshot().length==101,"WAV parser walks unknown chunks");
|
||||
// Independent PCM fixtures: stereo extrema at 22.05 kHz, each repeated twice
|
||||
// by the 44.1 kHz tape input. Exercise sign extension and float conversion.
|
||||
for(unsigned bits:{8,16,24,32}) for(unsigned encoding:{1,3}) {
|
||||
if(encoding==3 && bits!=32) continue;
|
||||
std::vector<std::uint8_t> fixture(44,0);
|
||||
auto put=[&](unsigned offset,std::uint32_t value,unsigned width) {
|
||||
for(unsigned j=0;j<width;++j) fixture[offset+j]=(value>>(8*j))&255;
|
||||
};
|
||||
const char* riff="RIFF"; const char* wave="WAVEfmt "; const char* data="data";
|
||||
std::copy_n(riff,4,fixture.begin()); std::copy_n(wave,8,fixture.begin()+8); std::copy_n(data,4,fixture.begin()+36);
|
||||
unsigned align=bits/8*2;
|
||||
put(16,16,4); put(20,encoding,2); put(22,2,2); put(24,22050,4);
|
||||
put(28,22050*align,4); put(32,align,2); put(34,bits,2); put(40,align*3,4); put(4,36+align*3,4);
|
||||
for(unsigned level=0;level<3;++level) for(unsigned channel=0;channel<2;++channel) {
|
||||
std::uint32_t sample=encoding==3 ? (level==0 ? 0xbf800000u : level==1 ? 0 : 0x3f800000u) :
|
||||
bits==8 ? (level==0 ? 0 : level==1 ? 128 : 255) :
|
||||
level==0 ? (std::uint32_t(1)<<(bits-1)) : level==1 ? 0 : (std::uint32_t(1)<<(bits-1))-1;
|
||||
for(unsigned j=0;j<bits/8;++j) fixture.push_back((sample>>(8*j))&255);
|
||||
}
|
||||
deck.mount(fixture,TapeFormat::WAV); deck.play();
|
||||
for(unsigned expected:{0,0,128,128,255,255}) require(deck.tick(0)==expected,"PCM/float stereo conversion and sample-rate normalization");
|
||||
if(encoding==3) { fixture[46]=0xc0; fixture[47]=0x7f; rejects([&]{deck.mount(fixture,TapeFormat::WAV);}); }
|
||||
}
|
||||
for(std::size_t n=0;n<wav.size();++n) {
|
||||
auto prefix=std::vector<std::uint8_t>(wav.begin(),wav.begin()+n);
|
||||
rejects([&]{deck.mount(prefix,TapeFormat::WAV);});
|
||||
}
|
||||
deck.eject(); rejects([&]{deck.play();});
|
||||
}
|
||||
void CheckCassetteMachine() {
|
||||
MachineSession machine; machine.loadDiagnostic();
|
||||
auto& deck=machine.cassette(); deck.mount({0x55,0xaa},TapeFormat::CAS); deck.setFast(true); deck.play();
|
||||
pia1_write(12,0x21); // actual PIA motor and data-register selection
|
||||
require(deck.snapshot().motor && deck.fastLoading(),"PIA motor connects to CAS transport");
|
||||
for(unsigned i=0;i<30000;++i) deck.tick(0);
|
||||
for(unsigned bit=0;bit<8;++bit) {
|
||||
require((pia1_read(0x20)&1)==1 && SafeMemRead8(0x83)==((0x55>>bit)&1?10:20),"Fast load supplies ROM pulse width");
|
||||
require((pia1_read(0x20)&1)==0,"Fast load alternates half bits");
|
||||
}
|
||||
require(deck.snapshot().position==1,"Fast load advances exactly one byte");
|
||||
machine.softReset(); require(!deck.snapshot().motor && deck.snapshot().position==1,"Soft reset stops motor and retains media position");
|
||||
machine.reset(); require(machine.cassette().snapshot().length==2,"Cold reset retains mounted tape");
|
||||
|
||||
// Tape is a mono speaker source. The two Orchestra-90 jacks are external.
|
||||
deck.record(TapeFormat::WAV);
|
||||
deck.motor(true);
|
||||
for (unsigned i = 0; i < 4096; ++i) deck.tick(160);
|
||||
deck.mount(deck.exportImage(), TapeFormat::WAV);
|
||||
deck.play();
|
||||
deck.motor(true);
|
||||
pia0_write(12, 0x01);
|
||||
pia0_write(4, 0x03);
|
||||
pia1_write(0x3c, 0x23); // explicitly enable the selected analog source
|
||||
require(GetMuxState() == PIA_MUX_CASSETTE, "Tape input selected");
|
||||
machine.resume();
|
||||
machine.advance();
|
||||
auto tapeOnly = machine.takeAudio();
|
||||
require(!tapeOnly.empty() && std::all_of(tapeOnly.begin(), tapeOnly.end(), [](auto sample) {
|
||||
return sample.left == .125f && sample.right == .125f;
|
||||
}), "Tape monitor plays its mono input on both channels");
|
||||
machine.cartridges().install(std::make_unique<VCC::Devices::Orchestra90Device>());
|
||||
machine.cartridges().writePort(0x7a, 32);
|
||||
machine.cartridges().writePort(0x7b, 160);
|
||||
machine.advance();
|
||||
auto mixed = machine.takeAudio();
|
||||
require(!mixed.empty() && std::all_of(mixed.begin(), mixed.end(), [](auto sample) {
|
||||
return sample.left == .25f && sample.right == .75f;
|
||||
}), "External left and right DACs remain audible alongside a playing tape");
|
||||
}
|
||||
Reference in new issue
Block a user