From fdef914137152114153067c6bec87d999c557c92 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Tue, 6 Mar 2018 18:32:21 -0500 Subject: [PATCH 1/7] Corrects test target regression. --- .../Clock SignalTests/MSXStaticAnalyserTests.mm | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm b/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm index 3f3f6afce..bbcc4840c 100644 --- a/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm +++ b/OSBindings/Mac/Clock SignalTests/MSXStaticAnalyserTests.mm @@ -10,21 +10,22 @@ #import #include "../../../Analyser/Static/StaticAnalyser.hpp" +#include "../../../Analyser/Static/MSX/Cartridge.hpp" @interface MSXROMRecord : NSObject -@property(nonatomic, readonly) Analyser::Static::MSXCartridgeType cartridgeType; -+ (instancetype)recordWithCartridgeType:(Analyser::Static::MSXCartridgeType)cartridgeType; +@property(nonatomic, readonly) Analyser::Static::MSX::Cartridge::Type cartridgeType; ++ (instancetype)recordWithCartridgeType:(Analyser::Static::MSX::Cartridge::Type)cartridgeType; @end @implementation MSXROMRecord -+ (instancetype)recordWithCartridgeType:(Analyser::Static::MSXCartridgeType)cartridgeType { ++ (instancetype)recordWithCartridgeType:(Analyser::Static::MSX::Cartridge::Type)cartridgeType { MSXROMRecord *record = [[MSXROMRecord alloc] init]; record->_cartridgeType = cartridgeType; return record; } @end -#define Record(sha, type) sha : [MSXROMRecord recordWithCartridgeType:Analyser::Static::MSXCartridgeType::type], +#define Record(sha, type) sha : [MSXROMRecord recordWithCartridgeType:Analyser::Static::MSX::Cartridge::type], static NSDictionary *romRecordsBySHA1 = @{ Record(@"da397e783d677d1a78fff222d9d6cb48b915dada", ASCII8kb) // 1942 (1986)(ASCII)(JP).rom Record(@"0733cd627467a866846e15caf1770a5594eaf4cc", ASCII8kb) // 1942 (1986)(ASCII)(JP)[a].rom @@ -222,7 +223,13 @@ static NSDictionary *romRecordsBySHA1 = @{ // assert equality XCTAssert(!targets.empty(), "%@ should be recognised as an MSX file", testFile); if(!targets.empty()) { - XCTAssert(targets.front()->msx.cartridge_type == romRecord.cartridgeType, @"%@; should be %d, is %d", testFile, romRecord.cartridgeType, targets.front()->msx.cartridge_type); + XCTAssert(!targets.front()->media.cartridges.empty(), "%@ should be interpreted as a cartridge", testFile); + + if(!targets.front()->media.cartridges.empty()) { + const Analyser::Static::MSX::Cartridge *const cartridge = + dynamic_cast(targets.front()->media.cartridges.front().get()); + XCTAssert(cartridge->type == romRecord.cartridgeType, @"%@; should be %d, is %d", testFile, romRecord.cartridgeType, cartridge->type); + } } } } From c82af4b8146dd73f6bcf409caabd112082822dc4 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Tue, 6 Mar 2018 19:06:35 -0500 Subject: [PATCH 2/7] Introduces `get_confidence` for the ColecoVision. Based almost entirely on joypad accesses for now. --- Machines/ColecoVision/ColecoVision.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/Machines/ColecoVision/ColecoVision.cpp b/Machines/ColecoVision/ColecoVision.cpp index a951a0eb6..d1df17ffa 100644 --- a/Machines/ColecoVision/ColecoVision.cpp +++ b/Machines/ColecoVision/ColecoVision.cpp @@ -23,6 +23,8 @@ #include "../../Outputs/Speaker/Implementation/CompoundSource.hpp" #include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp" +#include "../../Analyser/Dynamic/ConfidenceCounter.hpp" + namespace { const int sn76489_divider = 2; } @@ -195,6 +197,7 @@ class ConcreteMachine: uint16_t address = cycle.address ? *cycle.address : 0x0000; switch(cycle.operation) { case CPU::Z80::PartialMachineCycle::ReadOpcode: + if(!address) pc_zero_accesses_++; case CPU::Z80::PartialMachineCycle::Read: if(address < 0x2000) { if(super_game_module_.replace_bios) { @@ -245,6 +248,11 @@ class ConcreteMachine: } else { *cycle.value = joystick->get_direction_input(); } + + // Hitting exactly the recommended joypad input port is an indicator that + // this really is a ColecoVision game. The BIOS won't do this when just waiting + // to start a game (unlike accessing the VDP and SN). + if((address&0xfc) == 0xfc) confidence_counter_.add_hit(); } break; default: @@ -329,6 +337,11 @@ class ConcreteMachine: audio_queue_.perform(); } + float get_confidence() override { + if(pc_zero_accesses_ > 1) return 0.0f; + return confidence_counter_.get_confidence(); + } + private: inline void page_megacart(uint16_t address) { const std::size_t selected_start = (static_cast(address&63) << 14) % cartridge_.size(); @@ -368,6 +381,9 @@ class ConcreteMachine: HalfCycles time_since_vdp_update_; HalfCycles time_since_sn76489_update_; HalfCycles time_until_interrupt_; + + Analyser::Dynamic::ConfidenceCounter confidence_counter_; + int pc_zero_accesses_ = 0; }; } From 2452641844985693721b413a13befccccee24a82 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Tue, 6 Mar 2018 19:08:02 -0500 Subject: [PATCH 3/7] Introduces a fast workaround to avert a MultiMachine where it would instantly end. --- Analyser/Dynamic/MultiMachine/MultiMachine.cpp | 13 +++++++++---- Analyser/Dynamic/MultiMachine/MultiMachine.hpp | 8 ++++++++ Machines/Utility/MachineForTarget.cpp | 8 +++++++- 3 files changed, 24 insertions(+), 5 deletions(-) diff --git a/Analyser/Dynamic/MultiMachine/MultiMachine.cpp b/Analyser/Dynamic/MultiMachine/MultiMachine.cpp index fc018abd7..aac856216 100644 --- a/Analyser/Dynamic/MultiMachine/MultiMachine.cpp +++ b/Analyser/Dynamic/MultiMachine/MultiMachine.cpp @@ -62,8 +62,15 @@ Configurable::Device *MultiMachine::configurable_device() { } } +bool MultiMachine::would_collapse(const std::vector> &machines) { + return + (machines.front()->crt_machine()->get_confidence() > 0.9f) || + (machines.front()->crt_machine()->get_confidence() >= 2.0f * machines[1]->crt_machine()->get_confidence()); +} + void MultiMachine::multi_crt_did_run_machines() { std::lock_guard machines_lock(machines_mutex_); +#ifdef DEBUG for(const auto &machine: machines_) { CRTMachine::Machine *crt = machine->crt_machine(); printf("%0.2f ", crt->get_confidence()); @@ -71,6 +78,7 @@ void MultiMachine::multi_crt_did_run_machines() { printf("; "); } printf("\n"); +#endif DynamicMachine *front = machines_.front().get(); std::stable_sort(machines_.begin(), machines_.end(), @@ -84,10 +92,7 @@ void MultiMachine::multi_crt_did_run_machines() { crt_machine_.did_change_machine_order(); } - if( - (machines_.front()->crt_machine()->get_confidence() > 0.9f) || - (machines_.front()->crt_machine()->get_confidence() >= 2.0f * machines_[1]->crt_machine()->get_confidence()) - ) { + if(would_collapse(machines_)) { pick_first(); } } diff --git a/Analyser/Dynamic/MultiMachine/MultiMachine.hpp b/Analyser/Dynamic/MultiMachine/MultiMachine.hpp index cf4711422..de343e9c3 100644 --- a/Analyser/Dynamic/MultiMachine/MultiMachine.hpp +++ b/Analyser/Dynamic/MultiMachine/MultiMachine.hpp @@ -40,6 +40,14 @@ namespace Dynamic { */ class MultiMachine: public ::Machine::DynamicMachine, public MultiCRTMachine::Delegate { public: + /*! + Allows a potential MultiMachine creator to enquire as to whether there's any benefit in + requesting this class as a proxy. + + @returns @c true if the multimachine would discard all but the first machine in this list; + @c false otherwise. + */ + static bool would_collapse(const std::vector> &machines); MultiMachine(std::vector> &&machines); ConfigurationTarget::Machine *configuration_target() override; diff --git a/Machines/Utility/MachineForTarget.cpp b/Machines/Utility/MachineForTarget.cpp index dd8f205e1..7ec719686 100644 --- a/Machines/Utility/MachineForTarget.cpp +++ b/Machines/Utility/MachineForTarget.cpp @@ -79,7 +79,13 @@ namespace { } } - return new Analyser::Dynamic::MultiMachine(std::move(machines)); + // If a multimachine would just instantly collapse the list to a single machine, do + // so without the ongoing baggage of a multimachine. + if(Analyser::Dynamic::MultiMachine::would_collapse(machines)) { + return machines.front().release(); + } else { + return new Analyser::Dynamic::MultiMachine(std::move(machines)); + } } // There's definitely exactly one target. From a6ca69550f78fa9c3759546dd9777cf56d726a43 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Wed, 7 Mar 2018 14:24:52 -0500 Subject: [PATCH 4/7] Standardises machines that aren't making a real guess on reporting a confidence of 0.5. --- Analyser/Static/Acorn/StaticAnalyser.cpp | 2 +- Analyser/Static/AmstradCPC/StaticAnalyser.cpp | 2 +- Analyser/Static/Atari/StaticAnalyser.cpp | 2 +- Analyser/Static/Commodore/StaticAnalyser.cpp | 2 +- Analyser/Static/MSX/StaticAnalyser.cpp | 2 +- Analyser/Static/Oric/StaticAnalyser.cpp | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Analyser/Static/Acorn/StaticAnalyser.cpp b/Analyser/Static/Acorn/StaticAnalyser.cpp index cff55c8a1..3b2eed51e 100644 --- a/Analyser/Static/Acorn/StaticAnalyser.cpp +++ b/Analyser/Static/Acorn/StaticAnalyser.cpp @@ -59,7 +59,7 @@ static std::vector> void Analyser::Static::Acorn::AddTargets(const Media &media, std::vector> &destination) { std::unique_ptr target(new Target); target->machine = Machine::Electron; - target->confidence = 1.0; // TODO: a proper estimation + target->confidence = 0.5; // TODO: a proper estimation target->acorn.has_dfs = false; target->acorn.has_adfs = false; target->acorn.should_shift_restart = false; diff --git a/Analyser/Static/AmstradCPC/StaticAnalyser.cpp b/Analyser/Static/AmstradCPC/StaticAnalyser.cpp index e048af1c4..19438df8d 100644 --- a/Analyser/Static/AmstradCPC/StaticAnalyser.cpp +++ b/Analyser/Static/AmstradCPC/StaticAnalyser.cpp @@ -180,7 +180,7 @@ static bool CheckBootSector(const std::shared_ptr &disk, co void Analyser::Static::AmstradCPC::AddTargets(const Media &media, std::vector> &destination) { std::unique_ptr target(new Target); target->machine = Machine::AmstradCPC; - target->confidence = 1.0; + target->confidence = 0.5; target->media.disks = media.disks; target->media.tapes = media.tapes; target->media.cartridges = media.cartridges; diff --git a/Analyser/Static/Atari/StaticAnalyser.cpp b/Analyser/Static/Atari/StaticAnalyser.cpp index e3691e30a..423bb4afe 100644 --- a/Analyser/Static/Atari/StaticAnalyser.cpp +++ b/Analyser/Static/Atari/StaticAnalyser.cpp @@ -182,7 +182,7 @@ void Analyser::Static::Atari::AddTargets(const Media &media, std::vector target(new Target); target->machine = Machine::Atari2600; - target->confidence = 1.0; + target->confidence = 0.5; target->media.cartridges = media.cartridges; target->atari.paging_model = Atari2600PagingModel::None; target->atari.uses_superchip = false; diff --git a/Analyser/Static/Commodore/StaticAnalyser.cpp b/Analyser/Static/Commodore/StaticAnalyser.cpp index 055404f9d..872e0e3b9 100644 --- a/Analyser/Static/Commodore/StaticAnalyser.cpp +++ b/Analyser/Static/Commodore/StaticAnalyser.cpp @@ -41,7 +41,7 @@ static std::vector> void Analyser::Static::Commodore::AddTargets(const Media &media, std::vector> &destination) { std::unique_ptr target(new Target); target->machine = Machine::Vic20; // TODO: machine estimation - target->confidence = 1.0; // TODO: a proper estimation + target->confidence = 0.5; // TODO: a proper estimation int device = 0; std::vector files; diff --git a/Analyser/Static/MSX/StaticAnalyser.cpp b/Analyser/Static/MSX/StaticAnalyser.cpp index de0d0ef76..26351bf2b 100644 --- a/Analyser/Static/MSX/StaticAnalyser.cpp +++ b/Analyser/Static/MSX/StaticAnalyser.cpp @@ -286,7 +286,7 @@ void Analyser::Static::MSX::AddTargets(const Media &media, std::vectormedia.empty()) { target->machine = Machine::MSX; - target->confidence = 1.0; + target->confidence = 0.5; destination.push_back(std::move(target)); } } diff --git a/Analyser/Static/Oric/StaticAnalyser.cpp b/Analyser/Static/Oric/StaticAnalyser.cpp index 67c3c867e..364ba8bbf 100644 --- a/Analyser/Static/Oric/StaticAnalyser.cpp +++ b/Analyser/Static/Oric/StaticAnalyser.cpp @@ -76,7 +76,7 @@ static int Basic11Score(const Analyser::Static::MOS6502::Disassembly &disassembl void Analyser::Static::Oric::AddTargets(const Media &media, std::vector> &destination) { std::unique_ptr target(new Target); target->machine = Machine::Oric; - target->confidence = 1.0; + target->confidence = 0.5; int basic10_votes = 0; int basic11_votes = 0; From f212b185115bde220d51601981f611eb95685fa4 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Wed, 7 Mar 2018 14:25:25 -0500 Subject: [PATCH 5/7] Declares a confidence for the ColecoVision equal to the probability that the special bytes are wrong. --- Analyser/Static/Coleco/StaticAnalyser.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Analyser/Static/Coleco/StaticAnalyser.cpp b/Analyser/Static/Coleco/StaticAnalyser.cpp index 5796034cf..acad40f72 100644 --- a/Analyser/Static/Coleco/StaticAnalyser.cpp +++ b/Analyser/Static/Coleco/StaticAnalyser.cpp @@ -55,7 +55,7 @@ static std::vector> void Analyser::Static::Coleco::AddTargets(const Media &media, std::vector> &destination) { std::unique_ptr target(new Target); target->machine = Machine::ColecoVision; - target->confidence = 0.5; + target->confidence = 1.0f - 1.0f / 32768.0f; target->media.cartridges = ColecoCartridgesFrom(media.cartridges); if(!target->media.empty()) destination.push_back(std::move(target)); From 1100dc6993234310bb4ac93ead61ec9c68f17ba5 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Wed, 7 Mar 2018 14:26:07 -0500 Subject: [PATCH 6/7] Opens up .bin and .rom to all cartridge platforms, and adds a confidence estimate to the Atari 2600. --- Analyser/Static/StaticAnalyser.cpp | 7 ++---- Machines/Atari2600/Atari2600.cpp | 16 ++++++++---- Machines/Atari2600/Bus.hpp | 8 +++--- Machines/Atari2600/Cartridges/Cartridge.hpp | 27 +++++++++++++++++++-- Storage/TargetPlatforms.hpp | 3 ++- 5 files changed, 44 insertions(+), 17 deletions(-) diff --git a/Analyser/Static/StaticAnalyser.cpp b/Analyser/Static/StaticAnalyser.cpp index daae232ba..00794c325 100644 --- a/Analyser/Static/StaticAnalyser.cpp +++ b/Analyser/Static/StaticAnalyser.cpp @@ -88,7 +88,7 @@ static Media GetMediaAndPlatforms(const char *file_name, TargetPlatform::IntType Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081) // 81 Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600) // A26 Format("adf", result.disks, Disk::DiskImageHolder, TargetPlatform::Acorn) // ADF - Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600) // BIN + Format("bin", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge) // BIN Format("cas", result.tapes, Tape::CAS, TargetPlatform::MSX) // CAS Format("cdt", result.tapes, Tape::TZX, TargetPlatform::AmstradCPC) // CDT Format("col", result.cartridges, Cartridge::BinaryDump, TargetPlatform::ColecoVision) // COL @@ -117,10 +117,7 @@ static Media GetMediaAndPlatforms(const char *file_name, TargetPlatform::IntType } } - Format( "rom", - result.cartridges, - Cartridge::BinaryDump, - TargetPlatform::Acorn | TargetPlatform::MSX | TargetPlatform::ColecoVision) // ROM + Format("rom", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge) // ROM Format("ssd", result.disks, Disk::DiskImageHolder, TargetPlatform::Acorn) // SSD Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore) // TAP (Commodore) Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric) // TAP (Oric) diff --git a/Machines/Atari2600/Atari2600.cpp b/Machines/Atari2600/Atari2600.cpp index 70aa8753d..f9be6a8fc 100644 --- a/Machines/Atari2600/Atari2600.cpp +++ b/Machines/Atari2600/Atari2600.cpp @@ -74,9 +74,7 @@ class ConcreteMachine: public Machine, public Outputs::CRT::Delegate { public: - ConcreteMachine() : - frame_record_pointer_(0), - is_ntsc_(true) { + ConcreteMachine() { set_clock_rate(NTSC_clock_rate); } @@ -179,6 +177,7 @@ class ConcreteMachine: void run_for(const Cycles cycles) override { bus_->run_for(cycles); + bus_->apply_confidence(confidence_counter_); } // to satisfy Outputs::CRT::Delegate @@ -219,6 +218,10 @@ class ConcreteMachine: } } + float get_confidence() override { + return confidence_counter_.get_confidence(); + } + private: // the bus std::unique_ptr bus_; @@ -230,9 +233,12 @@ class ConcreteMachine: FrameRecord() : number_of_frames(0), number_of_unexpected_vertical_syncs(0) {} } frame_records_[4]; - unsigned int frame_record_pointer_; - bool is_ntsc_; + unsigned int frame_record_pointer_ = 0; + bool is_ntsc_ = true; std::vector> joysticks_; + + // a confidence counter + Analyser::Dynamic::ConfidenceCounter confidence_counter_; }; } diff --git a/Machines/Atari2600/Bus.hpp b/Machines/Atari2600/Bus.hpp index ffd63b64e..79d9dfbd4 100644 --- a/Machines/Atari2600/Bus.hpp +++ b/Machines/Atari2600/Bus.hpp @@ -14,6 +14,7 @@ #include "TIA.hpp" #include "TIASound.hpp" +#include "../../Analyser/Dynamic/ConfidenceCounter.hpp" #include "../../ClockReceiver/ClockReceiver.hpp" #include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp" @@ -23,11 +24,10 @@ class Bus { public: Bus() : tia_sound_(audio_queue_), - speaker_(tia_sound_), - tia_input_value_{0xff, 0xff}, - cycles_since_speaker_update_(0) {} + speaker_(tia_sound_) {} virtual void run_for(const Cycles cycles) = 0; + virtual void apply_confidence(Analyser::Dynamic::ConfidenceCounter &confidence_counter) = 0; virtual void set_reset_line(bool state) = 0; // the RIOT, TIA and speaker @@ -39,7 +39,7 @@ class Bus { Outputs::Speaker::LowpassSpeaker speaker_; // joystick state - uint8_t tia_input_value_[2]; + uint8_t tia_input_value_[2] = {0xff, 0xff}; protected: // speaker backlog accumlation counter diff --git a/Machines/Atari2600/Cartridges/Cartridge.hpp b/Machines/Atari2600/Cartridges/Cartridge.hpp index 1aa2fe0e5..44ee90109 100644 --- a/Machines/Atari2600/Cartridges/Cartridge.hpp +++ b/Machines/Atari2600/Cartridges/Cartridge.hpp @@ -39,7 +39,23 @@ template class Cartridge: // consider doing something less fragile. } - void run_for(const Cycles cycles) { m6502_.run_for(cycles); } + void run_for(const Cycles cycles) { + // Horizontal counter resets are used as a proxy for whether this really is an Atari 2600 + // title. Random memory accesses are likely to trigger random counter resets. + horizontal_counter_resets_ = 0; + cycle_count_ = cycles; + m6502_.run_for(cycles); + } + + /*! + Adjusts @c confidence_counter according to the results of the most recent run_for. + */ + void apply_confidence(Analyser::Dynamic::ConfidenceCounter &confidence_counter) { + if(cycle_count_.as_int() < 200) return; + if(horizontal_counter_resets_ > 10) + confidence_counter.add_miss(); + } + void set_reset_line(bool state) { m6502_.set_reset_line(state); } // to satisfy CPU::MOS6502::Processor @@ -108,7 +124,11 @@ template class Cartridge: case 0x01: update_video(); tia_->set_blank(*value & 0x02); break; case 0x02: m6502_.set_ready_line(true); break; - case 0x03: update_video(); tia_->reset_horizontal_counter(); break; + case 0x03: + update_video(); + tia_->reset_horizontal_counter(); + horizontal_counter_resets_++; + break; // TODO: audio will now be out of synchronisation — fix case 0x04: @@ -189,6 +209,9 @@ template class Cartridge: private: T bus_extender_; + int horizontal_counter_resets_ = 0; + Cycles cycle_count_; + }; } diff --git a/Storage/TargetPlatforms.hpp b/Storage/TargetPlatforms.hpp index b6b222cc8..b0a2ef317 100644 --- a/Storage/TargetPlatforms.hpp +++ b/Storage/TargetPlatforms.hpp @@ -29,8 +29,9 @@ enum Type: IntType { Acorn = AcornAtom | AcornElectron | BBCMaster | BBCModelA | BBCModelB, ZX8081 = ZX80 | ZX81, - AllTape = Acorn | AmstradCPC | Commodore | Oric | ZX80 | ZX81 | MSX, + AllCartridge = Atari2600 | AcornElectron | ColecoVision | MSX, AllDisk = Acorn | AmstradCPC | Commodore | Oric | MSX, + AllTape = Acorn | AmstradCPC | Commodore | Oric | ZX80 | ZX81 | MSX, }; class TypeDistinguisher { From 9e0a56b4f036c5dbea195e766dbf4f6761d5e0c8 Mon Sep 17 00:00:00 2001 From: Thomas Harte Date: Wed, 7 Mar 2018 16:21:17 -0500 Subject: [PATCH 7/7] Withdraws the 2600 from .rom consideration. Will return when it is performing more sanity checks; for the time being I don't want it constantly forcing multimachines. --- Analyser/Static/Atari/StaticAnalyser.cpp | 2 +- Analyser/Static/StaticAnalyser.cpp | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Analyser/Static/Atari/StaticAnalyser.cpp b/Analyser/Static/Atari/StaticAnalyser.cpp index 423bb4afe..59b92614f 100644 --- a/Analyser/Static/Atari/StaticAnalyser.cpp +++ b/Analyser/Static/Atari/StaticAnalyser.cpp @@ -179,7 +179,7 @@ static void DeterminePagingForCartridge(Analyser::Static::Target &target, const } void Analyser::Static::Atari::AddTargets(const Media &media, std::vector> &destination) { - // TODO: sanity checking; is this image really for an Atari 2600. + // TODO: sanity checking; is this image really for an Atari 2600? std::unique_ptr target(new Target); target->machine = Machine::Atari2600; target->confidence = 0.5; diff --git a/Analyser/Static/StaticAnalyser.cpp b/Analyser/Static/StaticAnalyser.cpp index 00794c325..feb5c3a32 100644 --- a/Analyser/Static/StaticAnalyser.cpp +++ b/Analyser/Static/StaticAnalyser.cpp @@ -117,7 +117,10 @@ static Media GetMediaAndPlatforms(const char *file_name, TargetPlatform::IntType } } - Format("rom", result.cartridges, Cartridge::BinaryDump, TargetPlatform::AllCartridge) // ROM + Format( "rom", + result.cartridges, + Cartridge::BinaryDump, + TargetPlatform::AcornElectron | TargetPlatform::ColecoVision | TargetPlatform::MSX) // ROM Format("ssd", result.disks, Disk::DiskImageHolder, TargetPlatform::Acorn) // SSD Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore) // TAP (Commodore) Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric) // TAP (Oric)