// 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 #include #include #include using namespace VCC::Mac; namespace { void require(bool v,const char* text) { if(!v) throw std::runtime_error(text); } template 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 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 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(); auto orchestra = std::make_shared(); 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({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 fixture(44,0); auto put=[&](unsigned offset,std::uint32_t value,unsigned width) { for(unsigned j=0;j>(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>(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.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()); 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"); }