Merge pull request #408 from TomHarte/MixerBalance

Enhances the CompoundSource so that constituents can have different volumes.

.travis.yml

@@ -1,5 +1,13 @@
-language: objective-c
-osx_image: xcode8.2
-xcode_project: OSBindings/Mac/Clock Signal.xcodeproj
-xcode_scheme: Clock Signal
-xcode_sdk: macosx10.12
+# language: objective-c
+# osx_image: xcode8.2
+# xcode_project: OSBindings/Mac/Clock Signal.xcodeproj
+# xcode_scheme: Clock Signal
+# xcode_sdk: macosx10.12
+
+language: cpp
+before_install:
+	- sudo apt-get install libsdl2-dev
+script: cd OSBindings/SDL && scons
+compiler:
+	- clang
+	- gcc

Analyser/Dynamic/ConfidenceCounter.cpp

@@ -0,0 +1,30 @@
+//
+//  ConfidenceCounter.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "ConfidenceCounter.hpp"
+
+using namespace Analyser::Dynamic;
+
+float ConfidenceCounter::get_confidence() {
+	return static_cast<float>(hits_) / static_cast<float>(hits_ + misses_);
+}
+
+void ConfidenceCounter::add_hit() {
+	hits_++;
+}
+
+void ConfidenceCounter::add_miss() {
+	misses_++;
+}
+
+void ConfidenceCounter::add_equivocal() {
+	if(hits_ > misses_) {
+		hits_++;
+		misses_++;
+	}
+}

Analyser/Dynamic/ConfidenceCounter.hpp

@@ -0,0 +1,47 @@
+//
+//  ConfidenceCounter.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceCounter_hpp
+#define ConfidenceCounter_hpp
+
+#include "ConfidenceSource.hpp"
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a confidence source that calculates its probability by virtual of a history of events.
+
+	The initial value of the confidence counter is 0.5.
+*/
+class ConfidenceCounter: public ConfidenceSource {
+	public:
+		/*! @returns The computed probability, based on the history of events. */
+		float get_confidence() override;
+
+		/*! Records an event that implies this is the appropriate class — pushes probability up towards 1.0. */
+		void add_hit();
+
+		/*! Records an event that implies this is not the appropriate class — pushes probability down towards 0.0. */
+		void add_miss();
+
+		/*!
+			Records an event that could be correct but isn't necessarily so; which can push probability
+			down towards 0.5, but will never push it upwards.
+		*/
+		void add_equivocal();
+
+	private:
+		int hits_ = 1;
+		int misses_ = 1;
+};
+
+}
+}
+
+#endif /* ConfidenceCounter_hpp */

Analyser/Dynamic/ConfidenceSource.hpp

@@ -0,0 +1,28 @@
+//
+//  ConfidenceSource.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceSource_hpp
+#define ConfidenceSource_hpp
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides an abstract interface through which objects can declare the probability
+	that they are the proper target for their input; e.g. if an Acorn Electron is asked
+	to run an Atari 2600 program then its confidence should shrink towards 0.0; if the
+	program is handed to an Atari 2600 then its confidence should grow towards 1.0.
+*/
+struct ConfidenceSource {
+	virtual float get_confidence() = 0;
+};
+
+}
+}
+
+#endif /* ConfidenceSource_hpp */

Analyser/Dynamic/ConfidenceSummary.cpp

@@ -0,0 +1,28 @@
+//
+//  ConfidenceSummary.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "ConfidenceSummary.hpp"
+
+#include <cassert>
+#include <numeric>
+
+using namespace Analyser::Dynamic;
+
+ConfidenceSummary::ConfidenceSummary(const std::vector<ConfidenceSource *> &sources, const std::vector<float> &weights) :
+	sources_(sources), weights_(weights) {
+	assert(weights.size() == sources.size());
+	weight_sum_ = std::accumulate(weights.begin(), weights.end(), 0.0f);
+}
+
+float ConfidenceSummary::get_confidence() {
+	float result = 0.0f;
+	for(std::size_t index = 0; index < sources_.size(); ++index) {
+		result += sources_[index]->get_confidence() * weights_[index];
+	}
+	return result / weight_sum_;
+}

Analyser/Dynamic/ConfidenceSummary.hpp

@@ -0,0 +1,46 @@
+//
+//  ConfidenceSummary.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ConfidenceSummary_hpp
+#define ConfidenceSummary_hpp
+
+#include "ConfidenceSource.hpp"
+
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Summaries a collection of confidence sources by calculating their weighted sum.
+*/
+class ConfidenceSummary: public ConfidenceSource {
+	public:
+		/*!
+			Instantiates a summary that will produce the weighted sum of
+			@c sources, each using the corresponding entry of @c weights.
+
+			Requires that @c sources and @c weights are of the same length.
+		*/
+		ConfidenceSummary(
+			const std::vector<ConfidenceSource *> &sources,
+			const std::vector<float> &weights);
+
+		/*! @returns The weighted sum of all sources. */
+		float get_confidence() override;
+
+	private:
+		std::vector<ConfidenceSource *> sources_;
+		std::vector<float> weights_;
+		float weight_sum_;
+};
+
+}
+}
+
+#endif /* ConfidenceSummary_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.cpp

@@ -0,0 +1,90 @@
+//
+//  MultiCRTMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiCRTMachine.hpp"
+
+#include <condition_variable>
+#include <mutex>
+
+using namespace Analyser::Dynamic;
+
+MultiCRTMachine::MultiCRTMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::mutex &machines_mutex) :
+	machines_(machines), machines_mutex_(machines_mutex), queues_(machines.size()) {
+	speaker_ = MultiSpeaker::create(machines);
+}
+
+void MultiCRTMachine::perform_parallel(const std::function<void(::CRTMachine::Machine *)> &function) {
+	// Apply a blunt force parallelisation of the machines; each run_for is dispatched
+	// to a separate queue and this queue will block until all are done.
+	volatile std::size_t outstanding_machines;
+	std::condition_variable condition;
+	std::mutex mutex;
+	{
+		std::lock_guard<std::mutex> machines_lock(machines_mutex_);
+		std::lock_guard<std::mutex> lock(mutex);
+		outstanding_machines = machines_.size();
+
+		for(std::size_t index = 0; index < machines_.size(); ++index) {
+			CRTMachine::Machine *crt_machine = machines_[index]->crt_machine();
+			queues_[index].enqueue([&mutex, &condition, crt_machine, function, &outstanding_machines]() {
+				if(crt_machine) function(crt_machine);
+
+				std::lock_guard<std::mutex> lock(mutex);
+				outstanding_machines--;
+				condition.notify_all();
+			});
+		}
+	}
+
+	std::unique_lock<std::mutex> lock(mutex);
+	condition.wait(lock, [&outstanding_machines] { return !outstanding_machines; });
+}
+
+void MultiCRTMachine::perform_serial(const std::function<void (::CRTMachine::Machine *)> &function) {
+	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
+	for(const auto &machine: machines_) {
+		CRTMachine::Machine *crt_machine = machine->crt_machine();
+		if(crt_machine) function(crt_machine);
+	}
+}
+
+void MultiCRTMachine::setup_output(float aspect_ratio) {
+	perform_serial([=](::CRTMachine::Machine *machine) {
+		machine->setup_output(aspect_ratio);
+	});
+}
+
+void MultiCRTMachine::close_output() {
+	perform_serial([=](::CRTMachine::Machine *machine) {
+		machine->close_output();
+	});
+}
+
+Outputs::CRT::CRT *MultiCRTMachine::get_crt() {
+	std::lock_guard<std::mutex> machines_lock(machines_mutex_);
+	CRTMachine::Machine *crt_machine = machines_.front()->crt_machine();
+	return crt_machine ? crt_machine->get_crt() : nullptr;
+}
+
+Outputs::Speaker::Speaker *MultiCRTMachine::get_speaker() {
+	return speaker_;
+}
+
+void MultiCRTMachine::run_for(Time::Seconds duration) {
+	perform_parallel([=](::CRTMachine::Machine *machine) {
+		if(machine->get_confidence() >= 0.01f) machine->run_for(duration);
+	});
+
+	if(delegate_) delegate_->multi_crt_did_run_machines();
+}
+
+void MultiCRTMachine::did_change_machine_order() {
+	if(speaker_) {
+		speaker_->set_new_front_machine(machines_.front().get());
+	}
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiCRTMachine.hpp

@@ -0,0 +1,89 @@
+//
+//  MultiCRTMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiCRTMachine_hpp
+#define MultiCRTMachine_hpp
+
+#include "../../../../Concurrency/AsyncTaskQueue.hpp"
+#include "../../../../Machines/CRTMachine.hpp"
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include "MultiSpeaker.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the CRT machine interface to multiple machines.
+
+	Keeps a reference to the original vector of machines; will access it only after
+	acquiring a supplied mutex. The owner should also call did_change_machine_order()
+	if the order of machines changes.
+*/
+class MultiCRTMachine: public CRTMachine::Machine {
+	public:
+		MultiCRTMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines, std::mutex &machines_mutex);
+
+		/*!
+			Informs the MultiCRTMachine that the order of machines has changed; the MultiCRTMachine
+			uses this as an opportunity to synthesis any CRTMachine::Machine::Delegate messages that
+			are necessary to bridge the gap between one machine and the next.
+		*/
+		void did_change_machine_order();
+
+		/*!
+			Provides a mechanism by which a delegate can be informed each time a call to run_for has
+			been received.
+		*/
+		struct Delegate {
+			virtual void multi_crt_did_run_machines() = 0;
+		};
+		/// Sets @c delegate as the receiver of delegate messages.
+		void set_delegate(Delegate *delegate) {
+			delegate_ = delegate;
+		}
+
+		// Below is the standard CRTMachine::Machine interface; see there for documentation.
+		void setup_output(float aspect_ratio) override;
+		void close_output() override;
+		Outputs::CRT::CRT *get_crt() override;
+		Outputs::Speaker::Speaker *get_speaker() override;
+		void run_for(Time::Seconds duration) override;
+
+	private:
+		void run_for(const Cycles cycles) override {}
+		const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines_;
+		std::mutex &machines_mutex_;
+		std::vector<Concurrency::AsyncTaskQueue> queues_;
+		MultiSpeaker *speaker_ = nullptr;
+		Delegate *delegate_ = nullptr;
+
+		/*!
+			Performs a parallel for operation across all machines, performing the supplied
+			function on each and returning only once all applications have completed.
+
+			No guarantees are extended as to which thread operations will occur on.
+		*/
+		void perform_parallel(const std::function<void(::CRTMachine::Machine *)> &);
+
+		/*!
+			Performs a serial for operation across all machines, performing the supplied
+			function on each on the calling thread.
+		*/
+		void perform_serial(const std::function<void(::CRTMachine::Machine *)> &);
+};
+
+}
+}
+
+
+#endif /* MultiCRTMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.cpp

@@ -0,0 +1,64 @@
+//
+//  MultiConfigurable.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiConfigurable.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Dynamic;
+
+MultiConfigurable::MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		Configurable::Device *device = machine->configurable_device();
+		if(device) devices_.push_back(device);
+    }
+}
+
+std::vector<std::unique_ptr<Configurable::Option>> MultiConfigurable::get_options() {
+	std::vector<std::unique_ptr<Configurable::Option>> options;
+
+	// Produce the list of unique options.
+	for(const auto &device : devices_) {
+		std::vector<std::unique_ptr<Configurable::Option>> device_options = device->get_options();
+		for(auto &option : device_options) {
+			if(std::find(options.begin(), options.end(), option) == options.end()) {
+				options.push_back(std::move(option));
+			}
+		}
+	}
+
+	return options;
+}
+
+void MultiConfigurable::set_selections(const Configurable::SelectionSet &selection_by_option) {
+	for(const auto &device : devices_) {
+		device->set_selections(selection_by_option);
+	}
+}
+
+Configurable::SelectionSet MultiConfigurable::get_accurate_selections() {
+	Configurable::SelectionSet set;
+	for(const auto &device : devices_) {
+		Configurable::SelectionSet device_set = device->get_accurate_selections();
+		for(auto &selection : device_set) {
+			set.insert(std::move(selection));
+		}
+	}
+	return set;
+}
+
+Configurable::SelectionSet MultiConfigurable::get_user_friendly_selections() {
+	Configurable::SelectionSet set;
+	for(const auto &device : devices_) {
+		Configurable::SelectionSet device_set = device->get_user_friendly_selections();
+		for(auto &selection : device_set) {
+			set.insert(std::move(selection));
+		}
+	}
+	return set;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurable.hpp

@@ -0,0 +1,43 @@
+//
+//  MultiConfigurable.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiConfigurable_hpp
+#define MultiConfigurable_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the configurable interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiConfigurable: public Configurable::Device {
+	public:
+		MultiConfigurable(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard Configurable::Device interface; see there for documentation.
+		std::vector<std::unique_ptr<Configurable::Option>> get_options() override;
+		void set_selections(const Configurable::SelectionSet &selection_by_option) override;
+		Configurable::SelectionSet get_accurate_selections() override;
+		Configurable::SelectionSet get_user_friendly_selections() override;
+
+	private:
+		std::vector<Configurable::Device *> devices_;
+};
+
+}
+}
+
+#endif /* MultiConfigurable_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurationTarget.cpp

@@ -0,0 +1,29 @@
+//
+//  MultiConfigurationTarget.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiConfigurationTarget.hpp"
+
+using namespace Analyser::Dynamic;
+
+MultiConfigurationTarget::MultiConfigurationTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		ConfigurationTarget::Machine *configuration_target = machine->configuration_target();
+		if(configuration_target) targets_.push_back(configuration_target);
+    }
+}
+
+void MultiConfigurationTarget::configure_as_target(const Analyser::Static::Target *target) {
+}
+
+bool MultiConfigurationTarget::insert_media(const Analyser::Static::Media &media) {
+	bool inserted = false;
+	for(const auto &target : targets_) {
+		inserted |= target->insert_media(media);
+	}
+	return inserted;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiConfigurationTarget.hpp

@@ -0,0 +1,42 @@
+//
+//  MultiConfigurationTarget.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 29/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiConfigurationTarget_hpp
+#define MultiConfigurationTarget_hpp
+
+#include "../../../../Machines/ConfigurationTarget.hpp"
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the configuration target interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+struct MultiConfigurationTarget: public ConfigurationTarget::Machine {
+	public:
+		MultiConfigurationTarget(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard ConfigurationTarget::Machine interface; see there for documentation.
+		void configure_as_target(const Analyser::Static::Target *target) override;
+		bool insert_media(const Analyser::Static::Media &media) override;
+
+	private:
+		std::vector<ConfigurationTarget::Machine *> targets_;
+};
+
+}
+}
+
+#endif /* MultiConfigurationTarget_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.cpp

@@ -0,0 +1,78 @@
+//
+//  MultiJoystickMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiJoystickMachine.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Dynamic;
+
+namespace {
+
+class MultiJoystick: public Inputs::Joystick {
+	public:
+		MultiJoystick(std::vector<JoystickMachine::Machine *> &machines, std::size_t index) {
+			for(const auto &machine: machines) {
+				const auto &joysticks = machine->get_joysticks();
+				if(joysticks.size() >= index) {
+					joysticks_.push_back(joysticks[index].get());
+				}
+			}
+		}
+
+		std::vector<DigitalInput> get_inputs() override {
+			std::vector<DigitalInput> inputs;
+
+			for(const auto &joystick: joysticks_) {
+				std::vector<DigitalInput> joystick_inputs = joystick->get_inputs();
+				for(const auto &input: joystick_inputs) {
+					if(std::find(inputs.begin(), inputs.end(), input) != inputs.end()) {
+						inputs.push_back(input);
+					}
+				}
+			}
+
+			return inputs;
+		}
+
+		void set_digital_input(const DigitalInput &digital_input, bool is_active) override {
+			for(const auto &joystick: joysticks_) {
+				joystick->set_digital_input(digital_input, is_active);
+			}
+		}
+		void reset_all_inputs() override {
+			for(const auto &joystick: joysticks_) {
+				joystick->reset_all_inputs();
+			}
+		}
+
+	private:
+		std::vector<Inputs::Joystick *> joysticks_;
+};
+
+}
+
+MultiJoystickMachine::MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	std::size_t total_joysticks = 0;
+	std::vector<JoystickMachine::Machine *> joystick_machines;
+	for(const auto &machine: machines) {
+		JoystickMachine::Machine *joystick_machine = machine->joystick_machine();
+		if(joystick_machine) {
+			joystick_machines.push_back(joystick_machine);
+			total_joysticks = std::max(total_joysticks, joystick_machine->get_joysticks().size());
+		}
+    }
+
+	for(std::size_t index = 0; index < total_joysticks; ++index) {
+		joysticks_.emplace_back(new MultiJoystick(joystick_machines, index));
+	}
+}
+
+std::vector<std::unique_ptr<Inputs::Joystick>> &MultiJoystickMachine::get_joysticks() {
+	return joysticks_;
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiJoystickMachine.hpp

@@ -0,0 +1,40 @@
+//
+//  MultiJoystickMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiJoystickMachine_hpp
+#define MultiJoystickMachine_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the joystick machine interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiJoystickMachine: public JoystickMachine::Machine {
+	public:
+		MultiJoystickMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard JoystickMachine::Machine interface; see there for documentation.
+		std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override;
+
+	private:
+		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+};
+
+}
+}
+
+#endif /* MultiJoystickMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.cpp

@@ -0,0 +1,43 @@
+//
+//  MultiKeyboardMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiKeyboardMachine.hpp"
+
+using namespace Analyser::Dynamic;
+
+MultiKeyboardMachine::MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	for(const auto &machine: machines) {
+		KeyboardMachine::Machine *keyboard_machine = machine->keyboard_machine();
+		if(keyboard_machine) machines_.push_back(keyboard_machine);
+    }
+}
+
+void MultiKeyboardMachine::clear_all_keys() {
+	for(const auto &machine: machines_) {
+		machine->clear_all_keys();
+    }
+}
+
+void MultiKeyboardMachine::set_key_state(uint16_t key, bool is_pressed) {
+    for(const auto &machine: machines_) {
+        machine->set_key_state(key, is_pressed);
+    }
+}
+
+void MultiKeyboardMachine::type_string(const std::string &string) {
+    for(const auto &machine: machines_) {
+        machine->type_string(string);
+    }
+}
+
+void MultiKeyboardMachine::keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) {
+    for(const auto &machine: machines_) {
+		uint16_t mapped_key = machine->get_keyboard_mapper()->mapped_key_for_key(key);
+		if(mapped_key != KeyNotMapped) machine->set_key_state(mapped_key, is_pressed);
+    }
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiKeyboardMachine.hpp

@@ -0,0 +1,44 @@
+//
+//  MultiKeyboardMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiKeyboardMachine_hpp
+#define MultiKeyboardMachine_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Machines/KeyboardMachine.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes the keyboard machine interface to multiple machines.
+
+	Makes a static internal copy of the list of machines; makes no guarantees about the
+	order of delivered messages.
+*/
+class MultiKeyboardMachine: public KeyboardMachine::Machine {
+	public:
+		MultiKeyboardMachine(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		// Below is the standard KeyboardMachine::Machine interface; see there for documentation.
+		void clear_all_keys() override;
+		void set_key_state(uint16_t key, bool is_pressed) override;
+		void type_string(const std::string &) override;
+		void keyboard_did_change_key(Inputs::Keyboard *keyboard, Inputs::Keyboard::Key key, bool is_pressed) override;
+
+	private:
+		std::vector<::KeyboardMachine::Machine *> machines_;
+};
+
+}
+}
+
+#endif /* MultiKeyboardMachine_hpp */

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.cpp

@@ -0,0 +1,76 @@
+//
+//  MultiSpeaker.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiSpeaker.hpp"
+
+using namespace Analyser::Dynamic;
+
+MultiSpeaker *MultiSpeaker::create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines) {
+	std::vector<Outputs::Speaker::Speaker *> speakers;
+	for(const auto &machine: machines) {
+		Outputs::Speaker::Speaker *speaker = machine->crt_machine()->get_speaker();
+		if(speaker) speakers.push_back(speaker);
+	}
+	if(speakers.empty()) return nullptr;
+
+	return new MultiSpeaker(speakers);
+}
+
+MultiSpeaker::MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers) :
+	speakers_(speakers), front_speaker_(speakers.front()) {
+	for(const auto &speaker: speakers_) {
+		speaker->set_delegate(this);
+	}
+}
+
+float MultiSpeaker::get_ideal_clock_rate_in_range(float minimum, float maximum) {
+	float ideal = 0.0f;
+	for(const auto &speaker: speakers_) {
+		ideal += speaker->get_ideal_clock_rate_in_range(minimum, maximum);
+	}
+
+	return ideal / static_cast<float>(speakers_.size());
+}
+
+void MultiSpeaker::set_output_rate(float cycles_per_second, int buffer_size) {
+	for(const auto &speaker: speakers_) {
+		speaker->set_output_rate(cycles_per_second, buffer_size);
+	}
+}
+
+void MultiSpeaker::set_delegate(Outputs::Speaker::Speaker::Delegate *delegate) {
+	delegate_ = delegate;
+}
+
+void MultiSpeaker::speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) {
+	if(!delegate_) return;
+	{
+		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		if(speaker != front_speaker_) return;
+	}
+	delegate_->speaker_did_complete_samples(this, buffer);
+}
+
+void MultiSpeaker::speaker_did_change_input_clock(Speaker *speaker) {
+	if(!delegate_) return;
+	{
+		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		if(speaker != front_speaker_) return;
+	}
+	delegate_->speaker_did_change_input_clock(this);
+}
+
+void MultiSpeaker::set_new_front_machine(::Machine::DynamicMachine *machine) {
+	{
+		std::lock_guard<std::mutex> lock_guard(front_speaker_mutex_);
+		front_speaker_ = machine->crt_machine()->get_speaker();
+	}
+	if(delegate_) {
+		delegate_->speaker_did_change_input_clock(this);
+	}
+}

Analyser/Dynamic/MultiMachine/Implementation/MultiSpeaker.hpp

@@ -0,0 +1,59 @@
+//
+//  MultiSpeaker.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 18/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiSpeaker_hpp
+#define MultiSpeaker_hpp
+
+#include "../../../../Machines/DynamicMachine.hpp"
+#include "../../../../Outputs/Speaker/Speaker.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides a class that multiplexes calls to and from Outputs::Speaker::Speaker in order
+	transparently to connect a single caller to multiple destinations.
+
+	Makes a static internal copy of the list of machines; expects the owner to keep it
+	abreast of the current frontmost machine.
+*/
+class MultiSpeaker: public Outputs::Speaker::Speaker, Outputs::Speaker::Speaker::Delegate {
+	public:
+		/*!
+			Provides a construction mechanism that may return nullptr, in the case that all included
+			machines return nullptr as their speaker.
+		*/
+		static MultiSpeaker *create(const std::vector<std::unique_ptr<::Machine::DynamicMachine>> &machines);
+
+		/// This class requires the caller to nominate changes in the frontmost machine.
+		void set_new_front_machine(::Machine::DynamicMachine *machine);
+
+		// Below is the standard Outputs::Speaker::Speaker interface; see there for documentation.
+		float get_ideal_clock_rate_in_range(float minimum, float maximum) override;
+		void set_output_rate(float cycles_per_second, int buffer_size) override;
+		void set_delegate(Outputs::Speaker::Speaker::Delegate *delegate) override;
+
+	private:
+		void speaker_did_complete_samples(Speaker *speaker, const std::vector<int16_t> &buffer) override;
+		void speaker_did_change_input_clock(Speaker *speaker) override;
+		MultiSpeaker(const std::vector<Outputs::Speaker::Speaker *> &speakers);
+
+		std::vector<Outputs::Speaker::Speaker *> speakers_;
+		Outputs::Speaker::Speaker *front_speaker_ = nullptr;
+		Outputs::Speaker::Speaker::Delegate *delegate_ = nullptr;
+		std::mutex front_speaker_mutex_;
+};
+
+}
+}
+
+#endif /* MultiSpeaker_hpp */

Analyser/Dynamic/MultiMachine/MultiMachine.cpp

@@ -0,0 +1,109 @@
+//
+//  MultiMachine.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 28/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "MultiMachine.hpp"
+
+#include <algorithm>
+
+using namespace Analyser::Dynamic;
+
+MultiMachine::MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines) :
+	machines_(std::move(machines)),
+	configurable_(machines_),
+	configuration_target_(machines_),
+	crt_machine_(machines_, machines_mutex_),
+	joystick_machine_(machines),
+	keyboard_machine_(machines_) {
+	crt_machine_.set_delegate(this);
+}
+
+ConfigurationTarget::Machine *MultiMachine::configuration_target() {
+	if(has_picked_) {
+		return machines_.front()->configuration_target();
+	} else {
+		return &configuration_target_;
+	}
+}
+
+CRTMachine::Machine *MultiMachine::crt_machine() {
+	if(has_picked_) {
+		return machines_.front()->crt_machine();
+	} else {
+		return &crt_machine_;
+	}
+}
+
+JoystickMachine::Machine *MultiMachine::joystick_machine() {
+	if(has_picked_) {
+		return machines_.front()->joystick_machine();
+	} else {
+		return &joystick_machine_;
+	}
+}
+
+KeyboardMachine::Machine *MultiMachine::keyboard_machine() {
+	if(has_picked_) {
+		return machines_.front()->keyboard_machine();
+	} else {
+		return &keyboard_machine_;
+	}
+}
+
+Configurable::Device *MultiMachine::configurable_device() {
+	if(has_picked_) {
+		return machines_.front()->configurable_device();
+	} else {
+		return &configurable_;
+	}
+}
+
+bool MultiMachine::would_collapse(const std::vector<std::unique_ptr<DynamicMachine>> &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<std::mutex> machines_lock(machines_mutex_);
+#ifdef DEBUG
+	for(const auto &machine: machines_) {
+		CRTMachine::Machine *crt = machine->crt_machine();
+		printf("%0.2f ", crt->get_confidence());
+		crt->print_type();
+		printf("; ");
+	}
+	printf("\n");
+#endif
+
+	DynamicMachine *front = machines_.front().get();
+	std::stable_sort(machines_.begin(), machines_.end(),
+        [] (const std::unique_ptr<DynamicMachine> &lhs, const std::unique_ptr<DynamicMachine> &rhs){
+		    CRTMachine::Machine *lhs_crt = lhs->crt_machine();
+		    CRTMachine::Machine *rhs_crt = rhs->crt_machine();
+		    return lhs_crt->get_confidence() > rhs_crt->get_confidence();
+	    });
+
+	if(machines_.front().get() != front) {
+		crt_machine_.did_change_machine_order();
+	}
+
+	if(would_collapse(machines_)) {
+		pick_first();
+	}
+}
+
+void MultiMachine::pick_first() {
+	has_picked_ = true;
+//	machines_.erase(machines_.begin() + 1, machines_.end());
+	// TODO: this isn't quite correct, because it may leak OpenGL/etc resources through failure to
+	// request a close_output while the context is active.
+}
+
+void *MultiMachine::raw_pointer() {
+	return nullptr;
+}

Analyser/Dynamic/MultiMachine/MultiMachine.hpp

@@ -0,0 +1,79 @@
+//
+//  MultiMachine.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 28/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef MultiMachine_hpp
+#define MultiMachine_hpp
+
+#include "../../../Machines/DynamicMachine.hpp"
+
+#include "Implementation/MultiConfigurable.hpp"
+#include "Implementation/MultiConfigurationTarget.hpp"
+#include "Implementation/MultiCRTMachine.hpp"
+#include "Implementation/MultiJoystickMachine.hpp"
+#include "Implementation/MultiKeyboardMachine.hpp"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace Analyser {
+namespace Dynamic {
+
+/*!
+	Provides the same interface as to a single machine, while multiplexing all
+	underlying calls to an array of real dynamic machines.
+
+	Calls to crt_machine->get_crt will return that for the frontmost machine;
+	anything installed as the speaker's delegate will similarly receive
+	feedback only from that machine.
+
+	Following each crt_machine->run_for, reorders the supplied machines by
+	confidence.
+
+	If confidence for any machine becomes disproportionately low compared to
+	the others in the set, that machine stops running.
+*/
+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<std::unique_ptr<DynamicMachine>> &machines);
+		MultiMachine(std::vector<std::unique_ptr<DynamicMachine>> &&machines);
+
+		ConfigurationTarget::Machine *configuration_target() override;
+		CRTMachine::Machine *crt_machine() override;
+		JoystickMachine::Machine *joystick_machine() override;
+		KeyboardMachine::Machine *keyboard_machine() override;
+		Configurable::Device *configurable_device() override;
+		void *raw_pointer() override;
+
+	private:
+		void multi_crt_did_run_machines() override;
+
+		std::vector<std::unique_ptr<DynamicMachine>> machines_;
+		std::mutex machines_mutex_;
+
+		MultiConfigurable configurable_;
+		MultiConfigurationTarget configuration_target_;
+		MultiCRTMachine crt_machine_;
+		MultiJoystickMachine joystick_machine_;
+		MultiKeyboardMachine keyboard_machine_;
+
+		void pick_first();
+		bool has_picked_ = false;
+};
+
+}
+}
+
+#endif /* MultiMachine_hpp */

Analyser/Machines.hpp

@@ -0,0 +1,27 @@
+//
+//  Machines.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 24/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Machines_h
+#define Machines_h
+
+namespace Analyser {
+
+enum class Machine {
+	AmstradCPC,
+	Atari2600,
+	ColecoVision,
+	Electron,
+	MSX,
+	Oric,
+	Vic20,
+	ZX8081
+};
+
+}
+
+#endif /* Machines_h */

Analyser/Static/Acorn/Disk.cpp

@@ -7,14 +7,16 @@
 //
 
 #include "Disk.hpp"
-#include "../../Storage/Disk/Controller/DiskController.hpp"
-#include "../../Storage/Disk/Encodings/MFM/Parser.hpp"
-#include "../../NumberTheory/CRC.hpp"
+
+#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "../../../NumberTheory/CRC.hpp"
+
 #include <algorithm>
 
-using namespace StaticAnalyser::Acorn;
+using namespace Analyser::Static::Acorn;
 
-std::unique_ptr<Catalogue> StaticAnalyser::Acorn::GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	// c.f. http://beebwiki.mdfs.net/Acorn_DFS_disc_format
 	std::unique_ptr<Catalogue> catalogue(new Catalogue);
 	Storage::Encodings::MFM::Parser parser(false, disk);
@@ -41,9 +43,7 @@ std::unique_ptr<Catalogue> StaticAnalyser::Acorn::GetDFSCatalogue(const std::sha
 		case 3: catalogue->bootOption = Catalogue::BootOption::ExecBOOT;	break;
 	}
 
-	// DFS files are stored contiguously, and listed in descending order of distance from track 0.
-	// So iterating backwards implies the least amount of seeking.
-	for(std::size_t file_offset = final_file_offset - 8; file_offset > 0; file_offset -= 8) {
+	for(std::size_t file_offset = 8; file_offset < final_file_offset; file_offset += 8) {
 		File new_file;
 		char name[10];
 		snprintf(name, 10, "%c.%.7s", names->samples[0][file_offset + 7] & 0x7f, &names->samples[0][file_offset]);
@@ -69,12 +69,12 @@ std::unique_ptr<Catalogue> StaticAnalyser::Acorn::GetDFSCatalogue(const std::sha
 			new_file.data.insert(new_file.data.end(), next_sector->samples[0].begin(), next_sector->samples[0].begin() + length_from_sector);
 			data_length -= length_from_sector;
 		}
-		if(!data_length) catalogue->files.push_front(new_file);
+		if(!data_length) catalogue->files.push_back(new_file);
 	}
 
 	return catalogue;
 }
-std::unique_ptr<Catalogue> StaticAnalyser::Acorn::GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+std::unique_ptr<Catalogue> Analyser::Static::Acorn::GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk) {
 	std::unique_ptr<Catalogue> catalogue(new Catalogue);
 	Storage::Encodings::MFM::Parser parser(true, disk);
 

Analyser/Static/Acorn/Disk.hpp

@@ -10,15 +10,16 @@
 #define StaticAnalyser_Acorn_Disk_hpp
 
 #include "File.hpp"
-#include "../../Storage/Disk/Disk.hpp"
+#include "../../../Storage/Disk/Disk.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
 /// Describes a DFS- or ADFS-format catalogue(/directory) — the list of files available and the catalogue's boot option.
 struct Catalogue {
 	std::string name;
-	std::list<File> files;
+	std::vector<File> files;
 	enum class BootOption {
 		None,
 		LoadBOOT,
@@ -30,6 +31,7 @@ struct Catalogue {
 std::unique_ptr<Catalogue> GetDFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 std::unique_ptr<Catalogue> GetADFSCatalogue(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
+}
 }
 }
 

Analyser/Static/Acorn/File.hpp

@@ -9,12 +9,12 @@
 #ifndef StaticAnalyser_Acorn_File_hpp
 #define StaticAnalyser_Acorn_File_hpp
 
-#include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
 struct File {
@@ -38,9 +38,10 @@ struct File {
 		std::vector<uint8_t> data;
 	};
 
-	std::list<Chunk> chunks;
+	std::vector<Chunk> chunks;
 };
 
+}
 }
 }
 

Analyser/Static/Acorn/StaticAnalyser.cpp

@@ -10,12 +10,13 @@
 
 #include "Disk.hpp"
 #include "Tape.hpp"
+#include "Target.hpp"
 
-using namespace StaticAnalyser::Acorn;
+using namespace Analyser::Static::Acorn;
 
-static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
-		AcornCartridgesFrom(const std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
-	std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> acorn_cartridges;
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		AcornCartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> acorn_cartridges;
 
 	for(const auto &cartridge : cartridges) {
 		const auto &segments = cartridge->get_segments();
@@ -23,9 +24,9 @@ static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
 		// only one mapped item is allowed
 		if(segments.size() != 1) continue;
 
-		// which must be 16 kb in size
-		Storage::Cartridge::Cartridge::Segment segment = segments.front();
-		if(segment.data.size() != 0x4000) continue;
+		// which must be 8 or 16 kb in size
+		const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
+		if(segment.data.size() != 0x4000 && segment.data.size() != 0x2000) continue;
 
 		// is a copyright string present?
 		uint8_t copyright_offset = segment.data[7];
@@ -56,21 +57,21 @@ static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	return acorn_cartridges;
 }
 
-void StaticAnalyser::Acorn::AddTargets(const Media &media, std::list<Target> &destination) {
-	Target target;
-	target.machine = Target::Electron;
-	target.probability = 1.0; // TODO: a proper estimation
-	target.acorn.has_dfs = false;
-	target.acorn.has_adfs = false;
-	target.acorn.should_shift_restart = false;
+void Analyser::Static::Acorn::AddTargets(const Media &media, std::vector<std::unique_ptr<::Analyser::Static::Target>> &destination) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Electron;
+	target->confidence = 0.5; // TODO: a proper estimation
+	target->has_dfs = false;
+	target->has_adfs = false;
+	target->should_shift_restart = false;
 
 	// strip out inappropriate cartridges
-	target.media.cartridges = AcornCartridgesFrom(media.cartridges);
+	target->media.cartridges = AcornCartridgesFrom(media.cartridges);
 
 	// if there are any tapes, attempt to get data from the first
 	if(media.tapes.size() > 0) {
 		std::shared_ptr<Storage::Tape::Tape> tape = media.tapes.front();
-		std::list<File> files = GetFiles(tape);
+		std::vector<File> files = GetFiles(tape);
 		tape->reset();
 
 		// continue if there are any files
@@ -96,9 +97,9 @@ void StaticAnalyser::Acorn::AddTargets(const Media &media, std::list<Target> &de
 
 			// Inspect first file. If it's protected or doesn't look like BASIC
 			// then the loading command is *RUN. Otherwise it's CHAIN"".
-			target.loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
+			target->loading_command = is_basic ? "CHAIN\"\"\n" : "*RUN\n";
 
-			target.media.tapes = media.tapes;
+			target->media.tapes = media.tapes;
 		}
 	}
 
@@ -108,18 +109,19 @@ void StaticAnalyser::Acorn::AddTargets(const Media &media, std::list<Target> &de
 		dfs_catalogue = GetDFSCatalogue(disk);
 		if(dfs_catalogue == nullptr) adfs_catalogue = GetADFSCatalogue(disk);
 		if(dfs_catalogue || adfs_catalogue) {
-			target.media.disks = media.disks;
-			target.acorn.has_dfs = !!dfs_catalogue;
-			target.acorn.has_adfs = !!adfs_catalogue;
+			target->media.disks = media.disks;
+			target->has_dfs = !!dfs_catalogue;
+			target->has_adfs = !!adfs_catalogue;
 
 			Catalogue::BootOption bootOption = (dfs_catalogue ?: adfs_catalogue)->bootOption;
 			if(bootOption != Catalogue::BootOption::None)
-				target.acorn.should_shift_restart = true;
+				target->should_shift_restart = true;
 			else
-				target.loading_command = "*CAT\n";
+				target->loading_command = "*CAT\n";
 		}
 	}
 
-	if(target.media.tapes.size() || target.media.disks.size() || target.media.cartridges.size())
-		destination.push_back(target);
+	if(target->media.tapes.size() || target->media.disks.size() || target->media.cartridges.size()) {
+		destination.push_back(std::move(target));
+	}
 }

Analyser/Static/Acorn/StaticAnalyser.hpp

@@ -11,11 +11,13 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
 
+}
 }
 }
 

Analyser/Static/Acorn/Tape.cpp

@@ -9,10 +9,11 @@
 #include "Tape.hpp"
 
 #include <deque>
-#include "../../NumberTheory/CRC.hpp"
-#include "../../Storage/Tape/Parsers/Acorn.hpp"
 
-using namespace StaticAnalyser::Acorn;
+#include "../../../NumberTheory/CRC.hpp"
+#include "../../../Storage/Tape/Parsers/Acorn.hpp"
+
+using namespace Analyser::Static::Acorn;
 
 static std::unique_ptr<File::Chunk> GetNextChunk(const std::shared_ptr<Storage::Tape::Tape> &tape, Storage::Tape::Acorn::Parser &parser) {
 	std::unique_ptr<File::Chunk> new_chunk(new File::Chunk);
@@ -118,7 +119,7 @@ static std::unique_ptr<File> GetNextFile(std::deque<File::Chunk> &chunks) {
 	return file;
 }
 
-std::list<File> StaticAnalyser::Acorn::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+std::vector<File> Analyser::Static::Acorn::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	Storage::Tape::Acorn::Parser parser;
 
 	// populate chunk list
@@ -131,7 +132,7 @@ std::list<File> StaticAnalyser::Acorn::GetFiles(const std::shared_ptr<Storage::T
 	}
 
 	// decompose into file list
-	std::list<File> file_list;
+	std::vector<File> file_list;
 
 	while(chunk_list.size()) {
 		std::unique_ptr<File> next_file = GetNextFile(chunk_list);

Analyser/Static/Acorn/Tape.hpp

@@ -12,13 +12,15 @@
 #include <memory>
 
 #include "File.hpp"
-#include "../../Storage/Tape/Tape.hpp"
+#include "../../../Storage/Tape/Tape.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Acorn {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Acorn/Target.hpp

@@ -0,0 +1,28 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Acorn_Target_h
+#define Analyser_Static_Acorn_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace Acorn {
+
+struct Target: public ::Analyser::Static::Target {
+	bool has_adfs = false;
+	bool has_dfs = false;
+	bool should_shift_restart = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Acorn_Target_h */

Analyser/Static/AmstradCPC/StaticAnalyser.cpp

@@ -11,8 +11,10 @@
 #include <algorithm>
 #include <cstring>
 
-#include "../../Storage/Disk/Parsers/CPM.hpp"
-#include "../../Storage/Disk/Encodings/MFM/Parser.hpp"
+#include "Target.hpp"
+
+#include "../../../Storage/Disk/Parsers/CPM.hpp"
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
 
 static bool strcmp_insensitive(const char *a, const char *b) {
 	if(std::strlen(a) != std::strlen(b)) return false;
@@ -58,7 +60,7 @@ static std::string RunCommandFor(const Storage::Disk::CPM::File &file) {
 
 static void InspectCatalogue(
 	const Storage::Disk::CPM::Catalogue &catalogue,
-	StaticAnalyser::Target &target) {
+	const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
 
 	std::vector<const Storage::Disk::CPM::File *> candidate_files;
 	candidate_files.reserve(catalogue.files.size());
@@ -95,7 +97,7 @@ static void InspectCatalogue(
 
 	// If there's just one file, run that.
 	if(candidate_files.size() == 1) {
-		target.loading_command = RunCommandFor(*candidate_files[0]);
+		target->loading_command = RunCommandFor(*candidate_files[0]);
 		return;
 	}
 
@@ -126,7 +128,7 @@ static void InspectCatalogue(
 	}
 	if(basic_files == 1 || implicit_suffixed_files == 1) {
 		std::size_t selected_file = (basic_files == 1) ? last_basic_file : last_implicit_suffixed_file;
-		target.loading_command = RunCommandFor(*candidate_files[selected_file]);
+		target->loading_command = RunCommandFor(*candidate_files[selected_file]);
 		return;
 	}
 
@@ -143,20 +145,20 @@ static void InspectCatalogue(
 	if(name_counts.size() == 2) {
 		for(auto &pair : name_counts) {
 			if(pair.second == 1) {
-				target.loading_command = RunCommandFor(*candidate_files[indices_by_name[pair.first]]);
+				target->loading_command = RunCommandFor(*candidate_files[indices_by_name[pair.first]]);
 				return;
 			}
 		}
 	}
 
 	// Desperation.
-	target.loading_command = "cat\n";
+	target->loading_command = "cat\n";
 }
 
-static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, StaticAnalyser::Target &target) {
+static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, const std::unique_ptr<Analyser::Static::AmstradCPC::Target> &target) {
 	Storage::Encodings::MFM::Parser parser(true, disk);
 	Storage::Encodings::MFM::Sector *boot_sector = parser.get_sector(0, 0, 0x41);
-	if(boot_sector != nullptr && !boot_sector->samples.empty()) {
+	if(boot_sector != nullptr && !boot_sector->samples.empty() && boot_sector->samples[0].size() == 512) {
 		// Check that the first 64 bytes of the sector aren't identical; if they are then probably
 		// this disk was formatted and the filler byte never replaced.
 		bool matched = true;
@@ -169,7 +171,7 @@ static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, St
 
 		// This is a system disk, then launch it as though it were CP/M.
 		if(!matched) {
-			target.loading_command = "|cpm\n";
+			target->loading_command = "|cpm\n";
 			return true;
 		}
 	}
@@ -177,24 +179,24 @@ static bool CheckBootSector(const std::shared_ptr<Storage::Disk::Disk> &disk, St
 	return false;
 }
 
-void StaticAnalyser::AmstradCPC::AddTargets(const Media &media, std::list<Target> &destination) {
-	Target target;
-	target.machine = Target::AmstradCPC;
-	target.probability = 1.0;
-	target.media.disks = media.disks;
-	target.media.tapes = media.tapes;
-	target.media.cartridges = media.cartridges;
+void Analyser::Static::AmstradCPC::AddTargets(const Media &media, std::vector<std::unique_ptr<Analyser::Static::Target>> &destination) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::AmstradCPC;
+	target->confidence = 0.5;
 
-	target.amstradcpc.model = AmstradCPCModel::CPC6128;
+	target->model = Target::Model::CPC6128;
+
+	if(!media.tapes.empty()) {
+		// TODO: which of these are actually potentially CPC tapes?
+		target->media.tapes = media.tapes;
 
-	if(!target.media.tapes.empty()) {
 		// Ugliness flows here: assume the CPC isn't smart enough to pause between pressing
 		// enter and responding to the follow-on prompt to press a key, so just type for
 		// a while. Yuck!
-		target.loading_command = "|tape\nrun\"\n1234567890";
+		target->loading_command = "|tape\nrun\"\n1234567890";
 	}
 
-	if(!target.media.disks.empty()) {
+	if(!media.disks.empty()) {
 		Storage::Disk::CPM::ParameterBlock data_format;
 		data_format.sectors_per_track = 9;
 		data_format.tracks = 40;
@@ -203,26 +205,40 @@ void StaticAnalyser::AmstradCPC::AddTargets(const Media &media, std::list<Target
 		data_format.catalogue_allocation_bitmap = 0xc000;
 		data_format.reserved_tracks = 0;
 
-		std::unique_ptr<Storage::Disk::CPM::Catalogue> data_catalogue = Storage::Disk::CPM::GetCatalogue(target.media.disks.front(), data_format);
-		if(data_catalogue) {
-			InspectCatalogue(*data_catalogue, target);
-		} else {
-			if(!CheckBootSector(target.media.disks.front(), target)) {
-				Storage::Disk::CPM::ParameterBlock system_format;
-				system_format.sectors_per_track = 9;
-				system_format.tracks = 40;
-				system_format.block_size = 1024;
-				system_format.first_sector = 0x41;
-				system_format.catalogue_allocation_bitmap = 0xc000;
-				system_format.reserved_tracks = 2;
+		Storage::Disk::CPM::ParameterBlock system_format;
+		system_format.sectors_per_track = 9;
+		system_format.tracks = 40;
+		system_format.block_size = 1024;
+		system_format.first_sector = 0x41;
+		system_format.catalogue_allocation_bitmap = 0xc000;
+		system_format.reserved_tracks = 2;
 
-				std::unique_ptr<Storage::Disk::CPM::Catalogue> system_catalogue = Storage::Disk::CPM::GetCatalogue(target.media.disks.front(), system_format);
-				if(system_catalogue) {
-					InspectCatalogue(*system_catalogue, target);
-				}
+		for(const auto &disk: media.disks) {
+			// Check for an ordinary catalogue.
+			std::unique_ptr<Storage::Disk::CPM::Catalogue> data_catalogue = Storage::Disk::CPM::GetCatalogue(disk, data_format);
+			if(data_catalogue) {
+				InspectCatalogue(*data_catalogue, target);
+				target->media.disks.push_back(disk);
+				continue;
+			}
+
+			// Failing that check for a boot sector.
+			if(CheckBootSector(disk, target)) {
+				target->media.disks.push_back(disk);
+				continue;
+			}
+
+			// Failing that check for a system catalogue.
+			std::unique_ptr<Storage::Disk::CPM::Catalogue> system_catalogue = Storage::Disk::CPM::GetCatalogue(disk, system_format);
+			if(system_catalogue) {
+				InspectCatalogue(*system_catalogue, target);
+				target->media.disks.push_back(disk);
+				continue;
 			}
 		}
 	}
 
-	destination.push_back(target);
+	// If any media survived, add the target.
+	if(!target->media.empty())
+		destination.push_back(std::move(target));
 }

Analyser/Static/AmstradCPC/StaticAnalyser.hpp

@@ -11,11 +11,13 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace AmstradCPC {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
 
+}
 }
 }
 

Analyser/Static/AmstradCPC/Target.hpp

@@ -0,0 +1,33 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_AmstradCPC_Target_h
+#define Analyser_Static_AmstradCPC_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace AmstradCPC {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class Model {
+		CPC464,
+		CPC664,
+		CPC6128
+	};
+
+	Model model = Model::CPC464;
+};
+
+}
+}
+}
+
+
+#endif /* Analyser_Static_AmstradCPC_Target_h */

Analyser/Static/Atari/StaticAnalyser.cpp

@@ -8,11 +8,13 @@
 
 #include "StaticAnalyser.hpp"
 
+#include "Target.hpp"
+
 #include "../Disassembler/6502.hpp"
 
-using namespace StaticAnalyser::Atari;
+using namespace Analyser::Static::Atari;
 
-static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+static void DeterminePagingFor2kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
 	// if this is a 2kb cartridge then it's definitely either unpaged or a CommaVid
 	uint16_t entry_address, break_address;
 
@@ -26,17 +28,17 @@ static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const
 		address &= 0x1fff;
 		return static_cast<std::size_t>(address - 0x1800);
 	};
-	StaticAnalyser::MOS6502::Disassembly high_location_disassembly =
-		StaticAnalyser::MOS6502::Disassemble(segment.data, high_location_mapper, {entry_address, break_address});
+	Analyser::Static::MOS6502::Disassembly high_location_disassembly =
+		Analyser::Static::MOS6502::Disassemble(segment.data, high_location_mapper, {entry_address, break_address});
 
 	// assume that any kind of store that looks likely to be intended for large amounts of memory implies
 	// large amounts of memory
 	bool has_wide_area_store = false;
-	for(std::map<uint16_t, StaticAnalyser::MOS6502::Instruction>::value_type &entry : high_location_disassembly.instructions_by_address) {
-		if(entry.second.operation == StaticAnalyser::MOS6502::Instruction::STA) {
-			has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::Indirect;
-			has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::IndexedIndirectX;
-			has_wide_area_store |= entry.second.addressing_mode == StaticAnalyser::MOS6502::Instruction::IndirectIndexedY;
+	for(std::map<uint16_t, Analyser::Static::MOS6502::Instruction>::value_type &entry : high_location_disassembly.instructions_by_address) {
+		if(entry.second.operation == Analyser::Static::MOS6502::Instruction::STA) {
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::Indirect;
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndexedIndirectX;
+			has_wide_area_store |= entry.second.addressing_mode == Analyser::Static::MOS6502::Instruction::IndirectIndexedY;
 
 			if(has_wide_area_store) break;
 		}
@@ -46,10 +48,10 @@ static void DeterminePagingFor2kCartridge(StaticAnalyser::Target &target, const
 	// caveat: false positives aren't likely to be problematic; a false positive is a 2KB ROM that always addresses
 	// itself so as to land in ROM even if mapped as a CommaVid and this code is on the fence as to whether it
 	// attempts to modify itself but it probably doesn't
-	if(has_wide_area_store) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::CommaVid;
+	if(has_wide_area_store) target.paging_model = Analyser::Static::Atari::Target::PagingModel::CommaVid;
 }
 
-static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) {
+static void DeterminePagingFor8kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	// Activision stack titles have their vectors at the top of the low 4k, not the top, and
 	// always list 0xf000 as both vectors; they do not repeat them, and, inexplicably, they all
 	// issue an SEI as their first instruction (maybe some sort of relic of the development environment?)
@@ -58,12 +60,12 @@ static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const
 		(segment.data[8191] != 0xf0 || segment.data[8189] != 0xf0 || segment.data[8190] != 0x00 || segment.data[8188] != 0x00) &&
 		segment.data[0] == 0x78
 	) {
-		target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::ActivisionStack;
+		target.paging_model = Analyser::Static::Atari::Target::PagingModel::ActivisionStack;
 		return;
 	}
 
 	// make an assumption that this is the Atari paging model
-	target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari8k;
+	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari8k;
 
 	std::set<uint16_t> internal_accesses;
 	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
@@ -83,13 +85,13 @@ static void DeterminePagingFor8kCartridge(StaticAnalyser::Target &target, const
 		tigervision_access_count += masked_address == 0x3f;
 	}
 
-	if(parker_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::ParkerBros;
-	else if(tigervision_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Tigervision;
+	if(parker_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::ParkerBros;
+	else if(tigervision_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
 }
 
-static void DeterminePagingFor16kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) {
+static void DeterminePagingFor16kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	// make an assumption that this is the Atari paging model
-	target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari16k;
+	target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari16k;
 
 	std::set<uint16_t> internal_accesses;
 	internal_accesses.insert(disassembly.internal_stores.begin(), disassembly.internal_stores.end());
@@ -104,17 +106,17 @@ static void DeterminePagingFor16kCartridge(StaticAnalyser::Target &target, const
 		mnetwork_access_count += masked_address >= 0x1fe0 && masked_address < 0x1ffb;
 	}
 
-	if(mnetwork_access_count > atari_access_count) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::MNetwork;
+	if(mnetwork_access_count > atari_access_count) target.paging_model = Analyser::Static::Atari::Target::PagingModel::MNetwork;
 }
 
-static void DeterminePagingFor64kCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const StaticAnalyser::MOS6502::Disassembly &disassembly) {
+static void DeterminePagingFor64kCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment, const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	// make an assumption that this is a Tigervision if there is a write to 3F
-	target.atari.paging_model =
+	target.paging_model =
 		(disassembly.external_stores.find(0x3f) != disassembly.external_stores.end()) ?
-			StaticAnalyser::Atari2600PagingModel::Tigervision : StaticAnalyser::Atari2600PagingModel::MegaBoy;
+			Analyser::Static::Atari::Target::PagingModel::Tigervision : Analyser::Static::Atari::Target::PagingModel::MegaBoy;
 }
 
-static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
+static void DeterminePagingForCartridge(Analyser::Static::Atari::Target &target, const Storage::Cartridge::Cartridge::Segment &segment) {
 	if(segment.data.size() == 2048) {
 		DeterminePagingFor2kCartridge(target, segment);
 		return;
@@ -131,23 +133,23 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St
 	};
 
 	std::vector<uint8_t> final_4k(segment.data.end() - 4096, segment.data.end());
-	StaticAnalyser::MOS6502::Disassembly disassembly = StaticAnalyser::MOS6502::Disassemble(final_4k, address_mapper, {entry_address, break_address});
+	Analyser::Static::MOS6502::Disassembly disassembly = Analyser::Static::MOS6502::Disassemble(final_4k, address_mapper, {entry_address, break_address});
 
 	switch(segment.data.size()) {
 		case 8192:
 			DeterminePagingFor8kCartridge(target, segment, disassembly);
 		break;
 		case 10495:
-			target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Pitfall2;
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Pitfall2;
 		break;
 		case 12288:
-			target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::CBSRamPlus;
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::CBSRamPlus;
 		break;
 		case 16384:
 			DeterminePagingFor16kCartridge(target, segment, disassembly);
 		break;
 		case 32768:
-			target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Atari32k;
+			target.paging_model = Analyser::Static::Atari::Target::PagingModel::Atari32k;
 		break;
 		case 65536:
 			DeterminePagingFor64kCartridge(target, segment, disassembly);
@@ -159,8 +161,8 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St
 	// check for a Super Chip. Atari ROM images [almost] always have the same value stored over RAM
 	// regions; when they don't they at least seem to have the first 128 bytes be the same as the
 	// next 128 bytes. So check for that.
-	if(	target.atari.paging_model != StaticAnalyser::Atari2600PagingModel::CBSRamPlus &&
-		target.atari.paging_model != StaticAnalyser::Atari2600PagingModel::MNetwork) {
+	if(	target.paging_model != Analyser::Static::Atari::Target::PagingModel::CBSRamPlus &&
+		target.paging_model != Analyser::Static::Atari::Target::PagingModel::MNetwork) {
 		bool has_superchip = true;
 		for(std::size_t address = 0; address < 128; address++) {
 			if(segment.data[address] != segment.data[address+128]) {
@@ -168,24 +170,24 @@ static void DeterminePagingForCartridge(StaticAnalyser::Target &target, const St
 				break;
 			}
 		}
-		target.atari.uses_superchip = has_superchip;
+		target.uses_superchip = has_superchip;
 	}
 
 	// check for a Tigervision or Tigervision-esque scheme
-	if(target.atari.paging_model == StaticAnalyser::Atari2600PagingModel::None && segment.data.size() > 4096) {
+	if(target.paging_model == Analyser::Static::Atari::Target::PagingModel::None && segment.data.size() > 4096) {
 		bool looks_like_tigervision = disassembly.external_stores.find(0x3f) != disassembly.external_stores.end();
-		if(looks_like_tigervision) target.atari.paging_model = StaticAnalyser::Atari2600PagingModel::Tigervision;
+		if(looks_like_tigervision) target.paging_model = Analyser::Static::Atari::Target::PagingModel::Tigervision;
 	}
 }
 
-void StaticAnalyser::Atari::AddTargets(const Media &media, std::list<Target> &destination) {
-	// TODO: sanity checking; is this image really for an Atari 2600.
-	Target target;
-	target.machine = Target::Atari2600;
-	target.probability = 1.0;
-	target.media.cartridges = media.cartridges;
-	target.atari.paging_model = Atari2600PagingModel::None;
-	target.atari.uses_superchip = false;
+void Analyser::Static::Atari::AddTargets(const Media &media, std::vector<std::unique_ptr<Analyser::Static::Target>> &destination) {
+	// TODO: sanity checking; is this image really for an Atari 2600?
+	std::unique_ptr<Analyser::Static::Atari::Target> target(new Analyser::Static::Atari::Target);
+	target->machine = Machine::Atari2600;
+	target->confidence = 0.5;
+	target->media.cartridges = media.cartridges;
+	target->paging_model = Analyser::Static::Atari::Target::PagingModel::None;
+	target->uses_superchip = false;
 
 	// try to figure out the paging scheme
 	if(!media.cartridges.empty()) {
@@ -193,9 +195,9 @@ void StaticAnalyser::Atari::AddTargets(const Media &media, std::list<Target> &de
 
 		if(segments.size() == 1) {
 			const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
-			DeterminePagingForCartridge(target, segment);
+			DeterminePagingForCartridge(*target, segment);
 		}
 	}
 
-	destination.push_back(target);
+	destination.push_back(std::move(target));
 }

Analyser/Static/Atari/StaticAnalyser.hpp

@@ -11,11 +11,13 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Atari {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
 
+}
 }
 }
 

Analyser/Static/Atari/Target.hpp

@@ -0,0 +1,43 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Atari_Target_h
+#define Analyser_Static_Atari_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace Atari {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class PagingModel {
+		None,
+		CommaVid,
+		Atari8k,
+		Atari16k,
+		Atari32k,
+		ActivisionStack,
+		ParkerBros,
+		Tigervision,
+		CBSRamPlus,
+		MNetwork,
+		MegaBoy,
+		Pitfall2
+	};
+
+	// TODO: shouldn't these be properties of the cartridge?
+	PagingModel paging_model = PagingModel::None;
+	bool uses_superchip = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Atari_Target_h */

Analyser/Static/Coleco/StaticAnalyser.cpp

@@ -0,0 +1,62 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		ColecoCartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> coleco_cartridges;
+
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
+
+		// only one mapped item is allowed
+		if(segments.size() != 1) continue;
+
+		// which must be 8, 12, 16, 24 or 32 kb in size
+		const Storage::Cartridge::Cartridge::Segment &segment = segments.front();
+		const std::size_t data_size = segment.data.size();
+		const std::size_t overflow = data_size&8191;
+		if(overflow > 8 && overflow != 512 && (data_size != 12*1024)) continue;
+		if(data_size < 8192) continue;
+
+		// the two bytes that will be first must be 0xaa and 0x55, either way around
+		auto *start = &segment.data[0];
+		if((data_size & static_cast<std::size_t>(~8191)) > 32768) {
+			start = &segment.data[segment.data.size() - 16384];
+		}
+		if(start[0] != 0xaa && start[0] != 0x55 && start[1] != 0xaa && start[1] != 0x55) continue;
+		if(start[0] == start[1]) continue;
+
+		// probability of a random binary blob that isn't a Coleco ROM proceeding to here is 1 - 1/32768.
+		if(!overflow) {
+			coleco_cartridges.push_back(cartridge);
+		} else {
+			// Size down to a multiple of 8kb and apply the start address.
+			std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
+
+			std::vector<uint8_t> truncated_data;
+			std::vector<uint8_t>::difference_type truncated_size = static_cast<std::vector<uint8_t>::difference_type>(segment.data.size()) & ~8191;
+			truncated_data.insert(truncated_data.begin(), segment.data.begin(), segment.data.begin() + truncated_size);
+			output_segments.emplace_back(0x8000, truncated_data);
+
+			coleco_cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
+		}
+	}
+
+	return coleco_cartridges;
+}
+
+void Analyser::Static::Coleco::AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::ColecoVision;
+	target->confidence = 1.0f - 1.0f / 32768.0f;
+	target->media.cartridges = ColecoCartridgesFrom(media.cartridges);
+	if(!target->media.empty())
+		destination.push_back(std::move(target));
+}

Analyser/Static/Coleco/StaticAnalyser.hpp

@@ -0,0 +1,25 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_Coleco_StaticAnalyser_hpp
+#define StaticAnalyser_Coleco_StaticAnalyser_hpp
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace Coleco {
+
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
+
+}
+}
+}
+
+
+#endif /* StaticAnalyser_hpp */

Analyser/Static/Commodore/Disk.cpp

@@ -7,15 +7,15 @@
 //
 
 #include "Disk.hpp"
-#include "../../Storage/Disk/Controller/DiskController.hpp"
-#include "../../Storage/Disk/Encodings/CommodoreGCR.hpp"
-#include "../../Storage/Data/Commodore.hpp"
+#include "../../../Storage/Disk/Controller/DiskController.hpp"
+#include "../../../Storage/Disk/Encodings/CommodoreGCR.hpp"
+#include "../../../Storage/Data/Commodore.hpp"
 
 #include <limits>
 #include <vector>
 #include <array>
 
-using namespace StaticAnalyser::Commodore;
+using namespace Analyser::Static::Commodore;
 
 class CommodoreGCRParser: public Storage::Disk::Controller {
 	public:
@@ -71,19 +71,19 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 			bit_count_++;
 		}
 
-		unsigned int proceed_to_next_block() {
+		unsigned int proceed_to_next_block(int max_index_count) {
 			// find GCR lead-in
 			proceed_to_shift_value(0x3ff);
 			if(shift_register_ != 0x3ff) return 0xff;
 
 			// find end of lead-in
-			while(shift_register_ == 0x3ff && index_count_ < 2) {
+			while(shift_register_ == 0x3ff && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 
 			// continue for a further nine bits
 			bit_count_ = 0;
-			while(bit_count_ < 9 && index_count_ < 2) {
+			while(bit_count_ < 9 && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 
@@ -97,8 +97,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 
 		void proceed_to_shift_value(unsigned int shift_value) {
-			index_count_ = 0;
-			while(shift_register_ != shift_value && index_count_ < 2) {
+			const int max_index_count = index_count_ + 2;
+			while(shift_register_ != shift_value && index_count_ < max_index_count) {
 				run_for(Cycles(1));
 			}
 		}
@@ -124,13 +124,13 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 		std::shared_ptr<Sector> get_next_sector() {
 			std::shared_ptr<Sector> sector(new Sector);
-			index_count_ = 0;
+			const int max_index_count = index_count_ + 2;
 
-			while(index_count_ < 2) {
+			while(index_count_ < max_index_count) {
 				// look for a sector header
 				while(1) {
-					if(proceed_to_next_block() == 0x08) break;
-					if(index_count_ >= 2) return nullptr;
+					if(proceed_to_next_block(max_index_count) == 0x08) break;
+					if(index_count_ >= max_index_count) return nullptr;
 				}
 
 				// get sector details, skip if this looks malformed
@@ -144,8 +144,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 
 				// look for the following data
 				while(1) {
-					if(proceed_to_next_block() == 0x07) break;
-					if(index_count_ >= 2) return nullptr;
+					if(proceed_to_next_block(max_index_count) == 0x07) break;
+					if(index_count_ >= max_index_count) return nullptr;
 				}
 
 				checksum = 0;
@@ -165,8 +165,8 @@ class CommodoreGCRParser: public Storage::Disk::Controller {
 		}
 };
 
-std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
-	std::list<File> files;
+std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk) {
+	std::vector<File> files;
 	CommodoreGCRParser parser;
 	parser.drive->set_disk(disk);
 

Analyser/Static/Commodore/Disk.hpp

@@ -9,17 +9,19 @@
 #ifndef StaticAnalyser_Commodore_Disk_hpp
 #define StaticAnalyser_Commodore_Disk_hpp
 
-#include "../../Storage/Disk/Disk.hpp"
+#include "../../../Storage/Disk/Disk.hpp"
 #include "File.hpp"
-#include <list>
 
-namespace StaticAnalyser {
+#include <vector>
+
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Disk::Disk> &disk);
 
 }
 }
-
+}
 
 #endif /* Disk_hpp */

Analyser/Static/Commodore/File.cpp

@@ -8,7 +8,7 @@
 
 #include "File.hpp"
 
-bool StaticAnalyser::Commodore::File::is_basic() {
+bool Analyser::Static::Commodore::File::is_basic() {
 	// BASIC files are always relocatable (?)
 	if(type != File::RelocatableProgram) return false;
 

Analyser/Static/Commodore/File.hpp

@@ -12,7 +12,8 @@
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
 struct File {
@@ -34,6 +35,7 @@ struct File {
 	bool is_basic();
 };
 
+}
 }
 }
 

Analyser/Static/Commodore/StaticAnalyser.cpp

@@ -8,18 +8,20 @@
 
 #include "StaticAnalyser.hpp"
 
+#include "Disk.hpp"
 #include "File.hpp"
 #include "Tape.hpp"
-#include "Disk.hpp"
-#include "../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
+#include "Target.hpp"
+#include "../../../Storage/Cartridge/Encodings/CommodoreROM.hpp"
 
+#include <algorithm>
 #include <sstream>
 
-using namespace StaticAnalyser::Commodore;
+using namespace Analyser::Static::Commodore;
 
-static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
-		Vic20CartridgesFrom(const std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
-	std::list<std::shared_ptr<Storage::Cartridge::Cartridge>> vic20_cartridges;
+static std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>>
+		Vic20CartridgesFrom(const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> vic20_cartridges;
 
 	for(const auto &cartridge : cartridges) {
 		const auto &segments = cartridge->get_segments();
@@ -38,42 +40,42 @@ static std::list<std::shared_ptr<Storage::Cartridge::Cartridge>>
 	return vic20_cartridges;
 }
 
-void StaticAnalyser::Commodore::AddTargets(const Media &media, std::list<Target> &destination) {
-	Target target;
-	target.machine = Target::Vic20;	// TODO: machine estimation
-	target.probability = 1.0; // TODO: a proper estimation
+void Analyser::Static::Commodore::AddTargets(const Media &media, std::vector<std::unique_ptr<Analyser::Static::Target>> &destination, const std::string &file_name) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Vic20;	// TODO: machine estimation
+	target->confidence = 0.5; // TODO: a proper estimation
 
 	int device = 0;
-	std::list<File> files;
+	std::vector<File> files;
 	bool is_disk = false;
 
 	// strip out inappropriate cartridges
-	target.media.cartridges = Vic20CartridgesFrom(media.cartridges);
+	target->media.cartridges = Vic20CartridgesFrom(media.cartridges);
 
 	// check disks
 	for(auto &disk : media.disks) {
-		std::list<File> disk_files = GetFiles(disk);
+		std::vector<File> disk_files = GetFiles(disk);
 		if(!disk_files.empty()) {
 			is_disk = true;
-			files.splice(files.end(), disk_files);
-			target.media.disks.push_back(disk);
+			files.insert(files.end(), disk_files.begin(), disk_files.end());
+			target->media.disks.push_back(disk);
 			if(!device) device = 8;
 		}
 	}
 
 	// check tapes
 	for(auto &tape : media.tapes) {
-		std::list<File> tape_files = GetFiles(tape);
+		std::vector<File> tape_files = GetFiles(tape);
 		tape->reset();
 		if(!tape_files.empty()) {
-			files.splice(files.end(), tape_files);
-			target.media.tapes.push_back(tape);
+			files.insert(files.end(), tape_files.begin(), tape_files.end());
+			target->media.tapes.push_back(tape);
 			if(!device) device = 1;
 		}
 	}
 
 	if(!files.empty()) {
-		target.vic20.memory_model = Vic20MemoryModel::Unexpanded;
+		target->memory_model = Target::MemoryModel::Unexpanded;
 		std::ostringstream string_stream;
 		string_stream << "LOAD\"" << (is_disk ? "*" : "") << "\"," << device << ",";
   		if(files.front().is_basic()) {
@@ -82,23 +84,26 @@ void StaticAnalyser::Commodore::AddTargets(const Media &media, std::list<Target>
 			string_stream << "1";
 		}
 		string_stream << "\nRUN\n";
-		target.loading_command = string_stream.str();
+		target->loading_command = string_stream.str();
 
 		// make a first guess based on loading address
 		switch(files.front().starting_address) {
+			default:
+				printf("Starting address %04x?\n", files.front().starting_address);
 			case 0x1001:
-			default: break;
+				target->memory_model = Target::MemoryModel::Unexpanded;
+			break;
 			case 0x1201:
-				target.vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
+				target->memory_model = Target::MemoryModel::ThirtyTwoKB;
 			break;
 			case 0x0401:
-				target.vic20.memory_model = Vic20MemoryModel::EightKB;
+				target->memory_model = Target::MemoryModel::EightKB;
 			break;
 		}
 
 		// General approach: increase memory size conservatively such that the largest file found will fit.
-		for(File &file : files) {
-			std::size_t file_size = file.data.size();
+//		for(File &file : files) {
+//			std::size_t file_size = file.data.size();
 //			bool is_basic = file.is_basic();
 
 			/*if(is_basic)
@@ -108,9 +113,9 @@ void StaticAnalyser::Commodore::AddTargets(const Media &media, std::list<Target>
 				// An unexpanded machine has 3583 bytes free for BASIC;
 				// a 3kb expanded machine has 6655 bytes free.
 				if(file_size > 6655)
-					target.vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
-				else if(target.vic20.memory_model == Vic20MemoryModel::Unexpanded && file_size > 3583)
-					target.vic20.memory_model = Vic20MemoryModel::EightKB;
+					target->vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
+				else if(target->vic20.memory_model == Vic20MemoryModel::Unexpanded && file_size > 3583)
+					target->vic20.memory_model = Vic20MemoryModel::EightKB;
 			}
 			else
 			{*/
@@ -124,18 +129,26 @@ void StaticAnalyser::Commodore::AddTargets(const Media &media, std::list<Target>
 				// An unexpanded Vic has memory between 0x0000 and 0x0400; and between 0x1000 and 0x2000.
 				// A 3kb expanded Vic fills in the gap and has memory between 0x0000 and 0x2000.
 				// A 32kb expanded Vic has memory in the entire low 32kb.
-				uint16_t starting_address = file.starting_address;
+//				uint16_t starting_address = file.starting_address;
 
 				// If anything above the 8kb mark is touched, mark as a 32kb machine; otherwise if the
 				// region 0x0400 to 0x1000 is touched and this is an unexpanded machine, mark as 3kb.
-				if(starting_address + file_size > 0x2000)
-					target.vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
-				else if(target.vic20.memory_model == Vic20MemoryModel::Unexpanded && !(starting_address >= 0x1000 || starting_address+file_size < 0x0400))
-					target.vic20.memory_model = Vic20MemoryModel::ThirtyTwoKB;
+//				if(starting_address + file_size > 0x2000)
+//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
+//				else if(target->memory_model == Target::MemoryModel::Unexpanded && !(starting_address >= 0x1000 || starting_address+file_size < 0x0400))
+//					target->memory_model = Target::MemoryModel::ThirtyTwoKB;
 //			}
-		}
+//		}
 	}
 
-	if(!target.media.tapes.empty() || !target.media.cartridges.empty() || !target.media.disks.empty())
-		destination.push_back(target);
+	if(!target->media.empty()) {
+		// Inspect filename for a region hint.
+		std::string lowercase_name = file_name;
+		std::transform(lowercase_name.begin(), lowercase_name.end(), lowercase_name.begin(), ::tolower);
+		if(lowercase_name.find("ntsc") != std::string::npos) {
+			target->region = Analyser::Static::Commodore::Target::Region::American;
+		}
+
+		destination.push_back(std::move(target));
+	}
 }

Analyser/Static/Commodore/StaticAnalyser.hpp

@@ -10,12 +10,15 @@
 #define StaticAnalyser_Commodore_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
+#include <string>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination, const std::string &file_name);
 
+}
 }
 }
 

Analyser/Static/Commodore/Tape.cpp

@@ -8,13 +8,13 @@
 
 #include "Tape.hpp"
 
-#include "../../Storage/Tape/Parsers/Commodore.hpp"
+#include "../../../Storage/Tape/Parsers/Commodore.hpp"
 
-using namespace StaticAnalyser::Commodore;
+using namespace Analyser::Static::Commodore;
 
-std::list<File> StaticAnalyser::Commodore::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+std::vector<File> Analyser::Static::Commodore::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	Storage::Tape::Commodore::Parser parser;
-	std::list<File> file_list;
+	std::vector<File> file_list;
 
 	std::unique_ptr<Storage::Tape::Commodore::Header> header = parser.get_next_header(tape);
 

Analyser/Static/Commodore/Tape.hpp

@@ -9,15 +9,16 @@
 #ifndef StaticAnalyser_Commodore_Tape_hpp
 #define StaticAnalyser_Commodore_Tape_hpp
 
-#include "../../Storage/Tape/Tape.hpp"
+#include "../../../Storage/Tape/Tape.hpp"
 #include "File.hpp"
-#include <list>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Commodore {
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Commodore/Target.hpp

@@ -0,0 +1,42 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Commodore_Target_h
+#define Analyser_Static_Commodore_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace Commodore {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class MemoryModel {
+		Unexpanded,
+		EightKB,
+		ThirtyTwoKB
+	};
+
+	enum class Region {
+		American,
+		Danish,
+		Japanese,
+		European,
+		Swedish
+	};
+
+	MemoryModel memory_model = MemoryModel::Unexpanded;
+	Region region = Region::European;
+	bool has_c1540 = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Commodore_Target_h */

Analyser/Static/Disassembler/6502.cpp

@@ -10,10 +10,10 @@
 
 #include "Kernel.hpp"
 
-using namespace StaticAnalyser::MOS6502;
+using namespace Analyser::Static::MOS6502;
 namespace  {
 
-using PartialDisassembly = StaticAnalyser::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
+using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 
 struct MOS6502Disassembler {
 
@@ -312,9 +312,9 @@ static void AddToDisassembly(PartialDisassembly &disassembly, const std::vector<
 
 }	// end of anonymous namespace
 
-Disassembly StaticAnalyser::MOS6502::Disassemble(
+Disassembly Analyser::Static::MOS6502::Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(uint16_t)> &address_mapper,
 	std::vector<uint16_t> entry_points) {
-	return StaticAnalyser::Disassembly::Disassemble<Disassembly, uint16_t, MOS6502Disassembler>(memory, address_mapper, entry_points);
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, MOS6502Disassembler>(memory, address_mapper, entry_points);
 }

Analyser/Static/Disassembler/6502.hpp

@@ -16,7 +16,8 @@
 #include <set>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace MOS6502 {
 
 /*!
@@ -95,5 +96,6 @@ Disassembly Disassemble(
 
 }
 }
+}
 
 #endif /* Disassembler6502_hpp */

Analyser/Static/Disassembler/AddressMapper.hpp

@@ -11,7 +11,8 @@
 
 #include <functional>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Disassembler {
 
 /*!
@@ -24,6 +25,7 @@ template <typename T> std::function<std::size_t(T)> OffsetMapper(T start_address
 	};
 }
 
+}
 }
 }
 

Analyser/Static/Disassembler/Kernel.hpp

@@ -9,7 +9,8 @@
 #ifndef Kernel_hpp
 #define Kernel_hpp
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Disassembly {
 
 template <typename D, typename S> struct PartialDisassembly {
@@ -44,6 +45,7 @@ template <typename D, typename S, typename Disassembler> D Disassemble(
 	return partial_disassembly.disassembly;
 }
 
+}
 }
 }
 

Analyser/Static/Disassembler/Z80.cpp

@@ -10,10 +10,10 @@
 
 #include "Kernel.hpp"
 
-using namespace StaticAnalyser::Z80;
+using namespace Analyser::Static::Z80;
 namespace  {
 
-using PartialDisassembly = StaticAnalyser::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
+using PartialDisassembly = Analyser::Static::Disassembly::PartialDisassembly<Disassembly, uint16_t>;
 
 class Accessor {
 	public:
@@ -611,9 +611,9 @@ struct Z80Disassembler {
 
 }	// end of anonymous namespace
 
-Disassembly StaticAnalyser::Z80::Disassemble(
+Disassembly Analyser::Static::Z80::Disassemble(
 	const std::vector<uint8_t> &memory,
 	const std::function<std::size_t(uint16_t)> &address_mapper,
 	std::vector<uint16_t> entry_points) {
-	return StaticAnalyser::Disassembly::Disassemble<Disassembly, uint16_t, Z80Disassembler>(memory, address_mapper, entry_points);
+	return Analyser::Static::Disassembly::Disassemble<Disassembly, uint16_t, Z80Disassembler>(memory, address_mapper, entry_points);
 }

Analyser/Static/Disassembler/Z80.hpp

@@ -15,7 +15,8 @@
 #include <set>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Z80 {
 
 struct Instruction {
@@ -84,5 +85,6 @@ Disassembly Disassemble(
 
 }
 }
+}
 
 #endif /* StaticAnalyser_Disassembler_Z80_hpp */

Analyser/Static/MSX/Cartridge.hpp

@@ -0,0 +1,40 @@
+//
+//  Cartridge.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/01/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Cartridge_hpp
+#define Cartridge_hpp
+
+#include "../../../Storage/Cartridge/Cartridge.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+/*!
+	Extends the base cartridge class by adding a (guess at) the banking scheme.
+*/
+struct Cartridge: public ::Storage::Cartridge::Cartridge {
+	enum Type {
+		None,
+		Konami,
+		KonamiWithSCC,
+		ASCII8kb,
+		ASCII16kb,
+		FMPac
+	};
+	const Type type;
+
+	Cartridge(const std::vector<Segment> &segments, Type type) :
+		Storage::Cartridge::Cartridge(segments), type(type) {}
+};
+
+}
+}
+}
+
+#endif /* Cartridge_hpp */

Analyser/Static/MSX/StaticAnalyser.cpp

@@ -0,0 +1,295 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 25/11/2017.
+//  Copyright © 2017 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include "Cartridge.hpp"
+#include "Tape.hpp"
+#include "Target.hpp"
+
+#include "../Disassembler/Z80.hpp"
+#include "../Disassembler/AddressMapper.hpp"
+
+#include <algorithm>
+
+static std::unique_ptr<Analyser::Static::Target> CartridgeTarget(
+	const Storage::Cartridge::Cartridge::Segment &segment,
+	uint16_t start_address,
+	Analyser::Static::MSX::Cartridge::Type type,
+	float confidence) {
+
+	// Size down to a multiple of 8kb in size and apply the start address.
+	std::vector<Storage::Cartridge::Cartridge::Segment> output_segments;
+	if(segment.data.size() & 0x1fff) {
+		std::vector<uint8_t> truncated_data;
+		std::vector<uint8_t>::difference_type truncated_size = static_cast<std::vector<uint8_t>::difference_type>(segment.data.size()) & ~0x1fff;
+		truncated_data.insert(truncated_data.begin(), segment.data.begin(), segment.data.begin() + truncated_size);
+		output_segments.emplace_back(start_address, truncated_data);
+	} else {
+		output_segments.emplace_back(start_address, segment.data);
+	}
+
+	std::unique_ptr<Analyser::Static::MSX::Target> target(new Analyser::Static::MSX::Target);
+	target->machine = Analyser::Machine::MSX;
+	target->confidence = confidence;
+
+	if(type == Analyser::Static::MSX::Cartridge::Type::None) {
+		target->media.cartridges.emplace_back(new Storage::Cartridge::Cartridge(output_segments));
+	} else {
+		target->media.cartridges.emplace_back(new Analyser::Static::MSX::Cartridge(output_segments, type));
+	}
+
+	return target;
+}
+
+/*
+	Expected standard cartridge format:
+
+		DEFB "AB" ; expansion ROM header
+		DEFW initcode ; start of the init code, 0 if no initcode
+		DEFW callstat; pointer to CALL statement handler, 0 if no such handler
+		DEFW device; pointer to expansion device handler, 0 if no such handler
+		DEFW basic ; pointer to the start of a tokenized basicprogram, 0 if no basicprogram
+		DEFS 6,0 ; room reserved for future extensions
+
+	MSX cartridges often include banking hardware; those games were marketed as MegaROMs. The file
+	format that the MSX community has decided upon doesn't retain the type of hardware included, so
+	this analyser has to guess.
+
+	(additional audio hardware is also sometimes included, but it's implied by the banking hardware)
+*/
+static std::vector<std::unique_ptr<Analyser::Static::Target>> CartridgeTargetsFrom(
+	const std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> &cartridges) {
+	// No cartridges implies no targets.
+	if(cartridges.empty()) {
+		return {};
+	}
+
+	std::vector<std::unique_ptr<Analyser::Static::Target>> targets;
+	for(const auto &cartridge : cartridges) {
+		const auto &segments = cartridge->get_segments();
+
+		// Only one mapped item is allowed.
+		if(segments.size() != 1) continue;
+
+		// Which must be no more than 63 bytes larger than a multiple of 8 kb in size.
+		Storage::Cartridge::Cartridge::Segment segment = segments.front();
+		const size_t data_size = segment.data.size();
+		if(data_size < 0x2000 || (data_size & 0x1fff) > 64) continue;
+
+		// Check for a ROM header at address 0; if it's not found then try 0x4000
+		// and adjust the start address;
+		uint16_t start_address = 0;
+		bool found_start = false;
+		if(segment.data[0] == 0x41 && segment.data[1] == 0x42) {
+			start_address = 0x4000;
+			found_start = true;
+		} else if(segment.data.size() >= 0x8000 && segment.data[0x4000] == 0x41 && segment.data[0x4001] == 0x42) {
+			start_address = 0;
+			found_start = true;
+		}
+
+		// Reject cartridge if the ROM header wasn't found.
+		if(!found_start) continue;
+
+		uint16_t init_address = static_cast<uint16_t>(segment.data[2] | (segment.data[3] << 8));
+		// TODO: check for a rational init address?
+
+		// If this ROM is less than 48kb in size then it's an ordinary ROM. Just emplace it and move on.
+		if(data_size <= 0xc000) {
+			targets.emplace_back(CartridgeTarget(segment, start_address, Analyser::Static::MSX::Cartridge::Type::None, 1.0));
+			continue;
+		}
+
+		// If this ROM is greater than 48kb in size then some sort of MegaROM scheme must
+		// be at play; disassemble to try to figure it out.
+		std::vector<uint8_t> first_8k;
+		first_8k.insert(first_8k.begin(), segment.data.begin(), segment.data.begin() + 8192);
+		Analyser::Static::Z80::Disassembly disassembly =
+			Analyser::Static::Z80::Disassemble(
+				first_8k,
+				Analyser::Static::Disassembler::OffsetMapper(start_address),
+				{ init_address }
+			);
+
+//		// Look for a indirect store followed by an unconditional JP or CALL into another
+//		// segment, that's a fairly explicit sign where found.
+		using Instruction = Analyser::Static::Z80::Instruction;
+		std::map<uint16_t, Instruction> &instructions = disassembly.instructions_by_address;
+		bool is_ascii = false;
+//		auto iterator = instructions.begin();
+//		while(iterator != instructions.end()) {
+//			auto next_iterator = iterator;
+//			next_iterator++;
+//			if(next_iterator == instructions.end()) break;
+//
+//			if(	iterator->second.operation == Instruction::Operation::LD &&
+//				iterator->second.destination == Instruction::Location::Operand_Indirect &&
+//				(
+//					iterator->second.operand == 0x5000 ||
+//					iterator->second.operand == 0x6000 ||
+//					iterator->second.operand == 0x6800 ||
+//					iterator->second.operand == 0x7000 ||
+//					iterator->second.operand == 0x77ff ||
+//					iterator->second.operand == 0x7800 ||
+//					iterator->second.operand == 0x8000 ||
+//					iterator->second.operand == 0x9000 ||
+//					iterator->second.operand == 0xa000
+//				) &&
+//				(
+//					next_iterator->second.operation == Instruction::Operation::CALL ||
+//					next_iterator->second.operation == Instruction::Operation::JP
+//				) &&
+//				((next_iterator->second.operand >> 13) != (0x4000 >> 13))
+//			) {
+//				const uint16_t address = static_cast<uint16_t>(next_iterator->second.operand);
+//				switch(iterator->second.operand) {
+//					case 0x6000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x6800:
+//						if(address >= 0x6000 && address < 0x6800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x7000:
+//						if(address >= 0x6000 && address < 0x8000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//						if(address >= 0x7000 && address < 0x7800) {
+//							is_ascii = true;
+//						}
+//					break;
+//					case 0x77ff:
+//						if(address >= 0x7000 && address < 0x7800) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII16kb;
+//						}
+//					break;
+//					case 0x7800:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::ASCII8kb;
+//						}
+//					break;
+//					case 0x8000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0x9000:
+//						if(address >= 0x8000 && address < 0xa000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//					case 0xa000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::Konami;
+//						}
+//					break;
+//					case 0xb000:
+//						if(address >= 0xa000 && address < 0xc000) {
+//							target.msx.cartridge_type = Analyser::Static::MSXCartridgeType::KonamiWithSCC;
+//						}
+//					break;
+//				}
+//			}
+//
+//			iterator = next_iterator;
+
+		// Look for LD (nnnn), A instructions, and collate those addresses.
+		std::map<uint16_t, int> address_counts;
+		for(const auto &instruction_pair : instructions) {
+			if(	instruction_pair.second.operation == Instruction::Operation::LD &&
+				instruction_pair.second.destination == Instruction::Location::Operand_Indirect &&
+				instruction_pair.second.source == Instruction::Location::A) {
+				address_counts[static_cast<uint16_t>(instruction_pair.second.operand)]++;
+			}
+		}
+
+		// Weight confidences by number of observed hits.
+		float total_hits =
+			static_cast<float>(
+				address_counts[0x6000] + address_counts[0x6800] +
+				address_counts[0x7000] + address_counts[0x7800] +
+				address_counts[0x77ff] + address_counts[0x8000] +
+				address_counts[0xa000] + address_counts[0x5000] +
+				address_counts[0x9000] + address_counts[0xb000]
+			);
+
+		targets.push_back(CartridgeTarget(
+			segment,
+			start_address,
+			Analyser::Static::MSX::Cartridge::ASCII8kb,
+			static_cast<float>(	address_counts[0x6000] +
+								address_counts[0x6800] +
+								address_counts[0x7000] +
+								address_counts[0x7800]) / total_hits));
+		targets.push_back(CartridgeTarget(
+			segment,
+			start_address,
+			Analyser::Static::MSX::Cartridge::ASCII16kb,
+			static_cast<float>(	address_counts[0x6000] +
+								address_counts[0x7000] +
+								address_counts[0x77ff]) / total_hits));
+		if(!is_ascii) {
+			targets.push_back(CartridgeTarget(
+				segment,
+				start_address,
+				Analyser::Static::MSX::Cartridge::Konami,
+				static_cast<float>(	address_counts[0x6000] +
+									address_counts[0x8000] +
+									address_counts[0xa000]) / total_hits));
+		}
+		if(!is_ascii) {
+			targets.push_back(CartridgeTarget(
+				segment,
+				start_address,
+				Analyser::Static::MSX::Cartridge::KonamiWithSCC,
+				static_cast<float>(	address_counts[0x5000] +
+									address_counts[0x7000] +
+									address_counts[0x9000] +
+									address_counts[0xb000]) / total_hits));
+		}
+	}
+
+	return targets;
+}
+
+void Analyser::Static::MSX::AddTargets(const Media &media, std::vector<std::unique_ptr<::Analyser::Static::Target>> &destination) {
+	// Append targets for any cartridges that look correct.
+	auto cartridge_targets = CartridgeTargetsFrom(media.cartridges);
+	std::move(cartridge_targets.begin(), cartridge_targets.end(), std::back_inserter(destination));
+
+	// Consider building a target for disks and/or tapes.
+	std::unique_ptr<Target> target(new Target);
+
+	// Check tapes for loadable files.
+	for(const auto &tape : media.tapes) {
+		std::vector<File> files_on_tape = GetFiles(tape);
+		if(!files_on_tape.empty()) {
+			switch(files_on_tape.front().type) {
+				case File::Type::ASCII:				target->loading_command = "RUN\"CAS:\r";		break;
+				case File::Type::TokenisedBASIC:	target->loading_command = "CLOAD\rRUN\r";		break;
+				case File::Type::Binary:			target->loading_command = "BLOAD\"CAS:\",R\r";	break;
+				default: break;
+			}
+			target->media.tapes.push_back(tape);
+		}
+	}
+
+	// Blindly accept disks for now.
+	target->media.disks = media.disks;
+	target->has_disk_drive = !media.disks.empty();
+
+	if(!target->media.empty()) {
+		target->machine = Machine::MSX;
+		target->confidence = 0.5;
+		destination.push_back(std::move(target));
+	}
+}

Analyser/Static/MSX/StaticAnalyser.hpp

@@ -11,11 +11,13 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace MSX {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
 
+}
 }
 }
 

Analyser/Static/MSX/Tape.cpp

@@ -8,9 +8,9 @@
 
 #include "Tape.hpp"
 
-#include "../../Storage/Tape/Parsers/MSX.hpp"
+#include "../../../Storage/Tape/Parsers/MSX.hpp"
 
-using namespace StaticAnalyser::MSX;
+using namespace Analyser::Static::MSX;
 
 File::File(File &&rhs) :
 	name(std::move(rhs.name)),
@@ -24,7 +24,7 @@ File::File() :
 	starting_address(0),
 	entry_address(0) {}	// For the sake of initialising in a defined state.
 
-std::vector<File> StaticAnalyser::MSX::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+std::vector<File> Analyser::Static::MSX::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	std::vector<File> files;
 
 	Storage::Tape::BinaryTapePlayer tape_player(1000000);

Analyser/Static/MSX/Tape.hpp

@@ -9,12 +9,13 @@
 #ifndef StaticAnalyser_MSX_Tape_hpp
 #define StaticAnalyser_MSX_Tape_hpp
 
-#include "../../Storage/Tape/Tape.hpp"
+#include "../../../Storage/Tape/Tape.hpp"
 
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace MSX {
 
 struct File {
@@ -36,6 +37,7 @@ struct File {
 
 std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/MSX/Target.hpp

@@ -0,0 +1,26 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/04/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_MSX_Target_h
+#define Analyser_Static_MSX_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace MSX {
+
+struct Target: public ::Analyser::Static::Target {
+	bool has_disk_drive = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_MSX_Target_h */

Analyser/Static/Oric/StaticAnalyser.cpp

@@ -9,12 +9,18 @@
 #include "StaticAnalyser.hpp"
 
 #include "Tape.hpp"
+#include "Target.hpp"
+
 #include "../Disassembler/6502.hpp"
 #include "../Disassembler/AddressMapper.hpp"
 
-using namespace StaticAnalyser::Oric;
+#include "../../../Storage/Disk/Encodings/MFM/Parser.hpp"
 
-static int Score(const StaticAnalyser::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
+#include <cstring>
+
+using namespace Analyser::Static::Oric;
+
+static int Score(const Analyser::Static::MOS6502::Disassembly &disassembly, const std::set<uint16_t> &rom_functions, const std::set<uint16_t> &variable_locations) {
 	int score = 0;
 
 	for(auto address : disassembly.outward_calls)	score += (rom_functions.find(address) != rom_functions.end()) ? 1 : -1;
@@ -24,7 +30,7 @@ static int Score(const StaticAnalyser::MOS6502::Disassembly &disassembly, const
 	return score;
 }
 
-static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) {
+static int Basic10Score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	std::set<uint16_t> rom_functions = {
 		0x0228,	0x022b,
 		0xc3ca,	0xc3f8,	0xc448,	0xc47c,	0xc4b5,	0xc4e3,	0xc4e0,	0xc524,	0xc56f,	0xc5a2,	0xc5f8,	0xc60a,	0xc6a5,	0xc6de,	0xc719,	0xc738,
@@ -48,7 +54,7 @@ static int Basic10Score(const StaticAnalyser::MOS6502::Disassembly &disassembly)
 	return Score(disassembly, rom_functions, variable_locations);
 }
 
-static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly) {
+static int Basic11Score(const Analyser::Static::MOS6502::Disassembly &disassembly) {
 	std::set<uint16_t> rom_functions = {
 		0x0238,	0x023b,	0x023e,	0x0241,	0x0244,	0x0247,
 		0xc3c6,	0xc3f4,	0xc444,	0xc47c,	0xc4a8,	0xc4d3,	0xc4e0,	0xc524,	0xc55f,	0xc592,	0xc5e8,	0xc5fa,	0xc692,	0xc6b3,	0xc6ee,	0xc70d,
@@ -73,23 +79,44 @@ static int Basic11Score(const StaticAnalyser::MOS6502::Disassembly &disassembly)
 	return Score(disassembly, rom_functions, variable_locations);
 }
 
-void StaticAnalyser::Oric::AddTargets(const Media &media, std::list<Target> &destination) {
-	Target target;
-	target.machine = Target::Oric;
-	target.probability = 1.0;
+static bool IsMicrodisc(Storage::Encodings::MFM::Parser &parser) {
+	/*
+		The Microdisc boot sector is sector 2 of track 0 and contains a 23-byte signature.
+	*/
+	Storage::Encodings::MFM::Sector *sector = parser.get_sector(0, 0, 2);
+	if(!sector) return false;
+	if(sector->samples.empty()) return false;
+
+	const std::vector<uint8_t> &first_sample = sector->samples[0];
+	if(first_sample.size() != 256) return false;
+
+	const uint8_t signature[] = {
+		0x00, 0x00, 0xFF, 0x00, 0xD0, 0x9F, 0xD0,
+		0x9F, 0x02, 0xB9, 0x01, 0x00, 0xFF, 0x00,
+		0x00, 0xB9, 0xE4, 0xB9, 0x00, 0x00, 0xE6,
+		0x12, 0x00
+	};
+
+	return !std::memcmp(signature, first_sample.data(), sizeof(signature));
+}
+
+void Analyser::Static::Oric::AddTargets(const Media &media, std::vector<std::unique_ptr<Analyser::Static::Target>> &destination) {
+	std::unique_ptr<Target> target(new Target);
+	target->machine = Machine::Oric;
+	target->confidence = 0.5;
 
 	int basic10_votes = 0;
 	int basic11_votes = 0;
 
 	for(auto &tape : media.tapes) {
-		std::list<File> tape_files = GetFiles(tape);
+		std::vector<File> tape_files = GetFiles(tape);
 		tape->reset();
 		if(tape_files.size()) {
 			for(auto file : tape_files) {
 				if(file.data_type == File::MachineCode) {
 					std::vector<uint16_t> entry_points = {file.starting_address};
-					StaticAnalyser::MOS6502::Disassembly disassembly =
-						StaticAnalyser::MOS6502::Disassemble(file.data, StaticAnalyser::Disassembler::OffsetMapper(file.starting_address), entry_points);
+					Analyser::Static::MOS6502::Disassembly disassembly =
+						Analyser::Static::MOS6502::Disassemble(file.data, Analyser::Static::Disassembler::OffsetMapper(file.starting_address), entry_points);
 
 					int basic10_score = Basic10Score(disassembly);
 					int basic11_score = Basic11Score(disassembly);
@@ -97,23 +124,28 @@ void StaticAnalyser::Oric::AddTargets(const Media &media, std::list<Target> &des
 				}
 			}
 
-			target.media.tapes.push_back(tape);
-			target.loading_command = "CLOAD\"\"\n";
+			target->media.tapes.push_back(tape);
+			target->loading_command = "CLOAD\"\"\n";
 		}
 	}
 
-	// trust that any disk supplied can be handled by the Microdisc. TODO: check.
 	if(!media.disks.empty()) {
-		target.oric.has_microdisc = true;
-		target.media.disks = media.disks;
+		// Only the Microdisc is emulated right now, so accept only disks that it can boot from.
+		for(const auto &disk: media.disks) {
+			Storage::Encodings::MFM::Parser parser(true, disk);
+			if(IsMicrodisc(parser)) {
+				target->has_microdrive = true;
+				target->media.disks.push_back(disk);
+			}
+		}
 	} else {
-		target.oric.has_microdisc = false;
+		target->has_microdrive = false;
 	}
 
 	// TODO: really this should add two targets if not all votes agree
-	target.oric.use_atmos_rom = basic11_votes >= basic10_votes;
-	if(target.oric.has_microdisc) target.oric.use_atmos_rom = true;
+	target->use_atmos_rom = basic11_votes >= basic10_votes;
+	if(target->has_microdrive) target->use_atmos_rom = true;
 
-	if(target.media.tapes.size() || target.media.disks.size() || target.media.cartridges.size())
-		destination.push_back(target);
+	if(target->media.tapes.size() || target->media.disks.size() || target->media.cartridges.size())
+		destination.push_back(std::move(target));
 }

Analyser/Static/Oric/StaticAnalyser.hpp

@@ -11,13 +11,14 @@
 
 #include "../StaticAnalyser.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Oric {
 
-void AddTargets(const Media &media, std::list<Target> &destination);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination);
 
 }
 }
-
+}
 
 #endif /* StaticAnalyser_hpp */

Analyser/Static/Oric/Tape.cpp

@@ -7,12 +7,12 @@
 //
 
 #include "Tape.hpp"
-#include "../../Storage/Tape/Parsers/Oric.hpp"
+#include "../../../Storage/Tape/Parsers/Oric.hpp"
 
-using namespace StaticAnalyser::Oric;
+using namespace Analyser::Static::Oric;
 
-std::list<File> StaticAnalyser::Oric::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
-	std::list<File> files;
+std::vector<File> Analyser::Static::Oric::GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
+	std::vector<File> files;
 	Storage::Tape::Oric::Parser parser;
 
 	while(!tape->is_at_end()) {

Analyser/Static/Oric/Tape.hpp

@@ -9,12 +9,13 @@
 #ifndef StaticAnalyser_Oric_Tape_hpp
 #define StaticAnalyser_Oric_Tape_hpp
 
-#include "../../Storage/Tape/Tape.hpp"
-#include <list>
+#include "../../../Storage/Tape/Tape.hpp"
+
 #include <string>
 #include <vector>
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace Oric {
 
 struct File {
@@ -30,8 +31,9 @@ struct File {
 	std::vector<uint8_t> data;
 };
 
-std::list<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
+std::vector<File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape);
 
+}
 }
 }
 

Analyser/Static/Oric/Target.hpp

@@ -0,0 +1,25 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_Oric_Target_h
+#define Analyser_Static_Oric_Target_h
+
+namespace Analyser {
+namespace Static {
+namespace Oric {
+
+struct Target: public ::Analyser::Static::Target {
+	bool use_atmos_rom = false;
+	bool has_microdrive = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_Oric_Target_h */

Analyser/Static/StaticAnalyser.cpp

@@ -0,0 +1,175 @@
+//
+//  StaticAnalyser.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/08/2016.
+//  Copyright © 2016 Thomas Harte. All rights reserved.
+//
+
+#include "StaticAnalyser.hpp"
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+
+// Analysers
+#include "Acorn/StaticAnalyser.hpp"
+#include "AmstradCPC/StaticAnalyser.hpp"
+#include "Atari/StaticAnalyser.hpp"
+#include "Coleco/StaticAnalyser.hpp"
+#include "Commodore/StaticAnalyser.hpp"
+#include "MSX/StaticAnalyser.hpp"
+#include "Oric/StaticAnalyser.hpp"
+#include "ZX8081/StaticAnalyser.hpp"
+
+// Cartridges
+#include "../../Storage/Cartridge/Formats/BinaryDump.hpp"
+#include "../../Storage/Cartridge/Formats/PRG.hpp"
+
+// Disks
+#include "../../Storage/Disk/DiskImage/Formats/AcornADF.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/CPCDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/D64.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/G64.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/DMK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/HFE.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/MSXDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/OricMFMDSK.hpp"
+#include "../../Storage/Disk/DiskImage/Formats/SSD.hpp"
+
+// Tapes
+#include "../../Storage/Tape/Formats/CAS.hpp"
+#include "../../Storage/Tape/Formats/CommodoreTAP.hpp"
+#include "../../Storage/Tape/Formats/CSW.hpp"
+#include "../../Storage/Tape/Formats/OricTAP.hpp"
+#include "../../Storage/Tape/Formats/TapePRG.hpp"
+#include "../../Storage/Tape/Formats/TapeUEF.hpp"
+#include "../../Storage/Tape/Formats/TZX.hpp"
+#include "../../Storage/Tape/Formats/ZX80O81P.hpp"
+
+// Target Platform Types
+#include "../../Storage/TargetPlatforms.hpp"
+
+using namespace Analyser::Static;
+
+static Media GetMediaAndPlatforms(const std::string &file_name, TargetPlatform::IntType &potential_platforms) {
+	Media result;
+
+	// Get the extension, if any; it will be assumed that extensions are reliable, so an extension is a broad-phase
+	// test as to file format.
+	std::string::size_type final_dot = file_name.find_last_of(".");
+	if(final_dot == std::string::npos) return result;
+	std::string extension = file_name.substr(final_dot + 1);
+	std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
+
+#define Insert(list, class, platforms) \
+	list.emplace_back(new Storage::class(file_name));\
+	potential_platforms |= platforms;\
+	TargetPlatform::TypeDistinguisher *distinguisher = dynamic_cast<TargetPlatform::TypeDistinguisher *>(list.back().get());\
+	if(distinguisher) potential_platforms &= distinguisher->target_platform_type();
+
+#define TryInsert(list, class, platforms) \
+	try {\
+		Insert(list, class, platforms) \
+	} catch(...) {}
+
+#define Format(ext, list, class, platforms) \
+	if(extension == ext)	{		\
+		TryInsert(list, class, platforms)	\
+	}
+
+	Format("80", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// 80
+	Format("81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// 81
+	Format("a26", result.cartridges, Cartridge::BinaryDump, TargetPlatform::Atari2600)						// A26
+	Format("adf", result.disks, Disk::DiskImageHolder<Storage::Disk::AcornADF>, TargetPlatform::Acorn)		// ADF
+	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
+	Format("csw", result.tapes, Tape::CSW, TargetPlatform::AllTape)											// CSW
+	Format("d64", result.disks, Disk::DiskImageHolder<Storage::Disk::D64>, TargetPlatform::Commodore)		// D64
+	Format("dmk", result.disks, Disk::DiskImageHolder<Storage::Disk::DMK>, TargetPlatform::MSX)				// DMK
+	Format("dsd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)			// DSD
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::CPCDSK>, TargetPlatform::AmstradCPC)	// DSK (Amstrad CPC)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::MSXDSK>, TargetPlatform::MSX)			// DSK (MSX)
+	Format("dsk", result.disks, Disk::DiskImageHolder<Storage::Disk::OricMFMDSK>, TargetPlatform::Oric)		// DSK (Oric)
+	Format("g64", result.disks, Disk::DiskImageHolder<Storage::Disk::G64>, TargetPlatform::Commodore)		// G64
+	Format(	"hfe",
+			result.disks,
+			Disk::DiskImageHolder<Storage::Disk::HFE>,
+			TargetPlatform::Acorn | TargetPlatform::AmstradCPC | TargetPlatform::Commodore | TargetPlatform::Oric)
+			// HFE (TODO: switch to AllDisk once the MSX stops being so greedy)
+	Format("o", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// O
+	Format("p", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// P
+	Format("p81", result.tapes, Tape::ZX80O81P, TargetPlatform::ZX8081)										// P81
+
+	// PRG
+	if(extension == "prg") {
+		// try instantiating as a ROM; failing that accept as a tape
+		try {
+			Insert(result.cartridges, Cartridge::PRG, TargetPlatform::Commodore)
+		} catch(...) {
+			try {
+				Insert(result.tapes, Tape::PRG, TargetPlatform::Commodore)
+			} catch(...) {}
+		}
+	}
+
+	Format(	"rom",
+			result.cartridges,
+			Cartridge::BinaryDump,
+			TargetPlatform::AcornElectron | TargetPlatform::ColecoVision | TargetPlatform::MSX)				// ROM
+	Format("ssd", result.disks, Disk::DiskImageHolder<Storage::Disk::SSD>, TargetPlatform::Acorn)			// SSD
+	Format("tap", result.tapes, Tape::CommodoreTAP, TargetPlatform::Commodore)								// TAP (Commodore)
+	Format("tap", result.tapes, Tape::OricTAP, TargetPlatform::Oric)										// TAP (Oric)
+	Format("tsx", result.tapes, Tape::TZX, TargetPlatform::MSX)												// TSX
+	Format("tzx", result.tapes, Tape::TZX, TargetPlatform::ZX8081)											// TZX
+	Format("uef", result.tapes, Tape::UEF, TargetPlatform::Acorn)											// UEF (tape)
+
+#undef Format
+#undef Insert
+#undef TryInsert
+
+	return result;
+}
+
+Media Analyser::Static::GetMedia(const std::string &file_name) {
+	TargetPlatform::IntType throwaway;
+	return GetMediaAndPlatforms(file_name, throwaway);
+}
+
+std::vector<std::unique_ptr<Target>> Analyser::Static::GetTargets(const std::string &file_name) {
+	std::vector<std::unique_ptr<Target>> targets;
+
+	// Collect all disks, tapes and ROMs as can be extrapolated from this file, forming the
+	// union of all platforms this file might be a target for.
+	TargetPlatform::IntType potential_platforms = 0;
+	Media media = GetMediaAndPlatforms(file_name, potential_platforms);
+
+	// Hand off to platform-specific determination of whether these things are actually compatible and,
+	// if so, how to load them.
+	if(potential_platforms & TargetPlatform::Acorn)			Acorn::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::AmstradCPC)	AmstradCPC::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::Atari2600)		Atari::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::ColecoVision)	Coleco::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::Commodore)		Commodore::AddTargets(media, targets, file_name);
+	if(potential_platforms & TargetPlatform::MSX)			MSX::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::Oric)			Oric::AddTargets(media, targets);
+	if(potential_platforms & TargetPlatform::ZX8081)		ZX8081::AddTargets(media, targets, potential_platforms);
+
+	// Reset any tapes to their initial position
+	for(auto &target : targets) {
+		for(auto &tape : target->media.tapes) {
+			tape->reset();
+		}
+	}
+
+	// Sort by initial confidence. Use a stable sort in case any of the machine-specific analysers
+	// picked their insertion order carefully.
+	std::stable_sort(targets.begin(), targets.end(),
+        [] (const std::unique_ptr<Target> &a, const std::unique_ptr<Target> &b) {
+		    return a->confidence > b->confidence;
+	    });
+
+	return targets;
+}

Analyser/Static/StaticAnalyser.hpp

@@ -0,0 +1,66 @@
+//
+//  StaticAnalyser.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/08/2016.
+//  Copyright © 2016 Thomas Harte. All rights reserved.
+//
+
+#ifndef StaticAnalyser_hpp
+#define StaticAnalyser_hpp
+
+#include "../Machines.hpp"
+
+#include "../../Storage/Tape/Tape.hpp"
+#include "../../Storage/Disk/Disk.hpp"
+#include "../../Storage/Cartridge/Cartridge.hpp"
+
+#include <string>
+#include <vector>
+
+namespace Analyser {
+namespace Static {
+
+/*!
+	A list of disks, tapes and cartridges.
+*/
+struct Media {
+	std::vector<std::shared_ptr<Storage::Disk::Disk>> disks;
+	std::vector<std::shared_ptr<Storage::Tape::Tape>> tapes;
+	std::vector<std::shared_ptr<Storage::Cartridge::Cartridge>> cartridges;
+
+	bool empty() const {
+		return disks.empty() && tapes.empty() && cartridges.empty();
+	}
+};
+
+/*!
+	A list of disks, tapes and cartridges plus information about the machine to which to attach them and its configuration,
+	and instructions on how to launch the software attached, plus a measure of confidence in this target's correctness.
+*/
+struct Target {
+	virtual ~Target() {}
+
+	Machine machine;
+	Media media;
+
+	float confidence;
+	std::string loading_command;
+};
+
+/*!
+	Attempts, through any available means, to return a list of potential targets for the file with the given name.
+
+	@returns The list of potential targets, sorted from most to least probable.
+*/
+std::vector<std::unique_ptr<Target>> GetTargets(const std::string &file_name);
+
+/*!
+	Inspects the supplied file and determines the media included.
+*/
+Media GetMedia(const std::string &file_name);
+
+}
+}
+
+#endif /* StaticAnalyser_hpp */

Analyser/Static/ZX8081/StaticAnalyser.cpp

@@ -11,7 +11,8 @@
 #include <string>
 #include <vector>
 
-#include "../../Storage/Tape/Parsers/ZX8081.hpp"
+#include "Target.hpp"
+#include "../../../Storage/Tape/Parsers/ZX8081.hpp"
 
 static std::vector<Storage::Data::ZX8081::File> GetFiles(const std::shared_ptr<Storage::Tape::Tape> &tape) {
 	std::vector<Storage::Data::ZX8081::File> files;
@@ -27,41 +28,41 @@ static std::vector<Storage::Data::ZX8081::File> GetFiles(const std::shared_ptr<S
 	return files;
 }
 
-void StaticAnalyser::ZX8081::AddTargets(const Media &media, std::list<Target> &destination, TargetPlatform::IntType potential_platforms) {
+void Analyser::Static::ZX8081::AddTargets(const Media &media, std::vector<std::unique_ptr<::Analyser::Static::Target>> &destination, TargetPlatform::IntType potential_platforms) {
 	if(!media.tapes.empty()) {
 		std::vector<Storage::Data::ZX8081::File> files = GetFiles(media.tapes.front());
 		media.tapes.front()->reset();
 		if(!files.empty()) {
-			StaticAnalyser::Target target;
-			target.machine = Target::ZX8081;
+			Target *target = new Target;
+			destination.push_back(std::unique_ptr<::Analyser::Static::Target>(target));
+			target->machine = Machine::ZX8081;
 
 			// Guess the machine type from the file only if it isn't already known.
 			switch(potential_platforms & (TargetPlatform::ZX80 | TargetPlatform::ZX81)) {
 				default:
-					target.zx8081.isZX81 = files.front().isZX81;
+					target->is_ZX81 = files.front().isZX81;
 				break;
 
-				case TargetPlatform::ZX80:	target.zx8081.isZX81 = false;	break;
-				case TargetPlatform::ZX81:	target.zx8081.isZX81 = true;	break;
+				case TargetPlatform::ZX80:	target->is_ZX81 = false;	break;
+				case TargetPlatform::ZX81:	target->is_ZX81 = true;		break;
 			}
 
 			/*if(files.front().data.size() > 16384) {
-				target.zx8081.memory_model = ZX8081MemoryModel::SixtyFourKB;
+				target->zx8081.memory_model = ZX8081MemoryModel::SixtyFourKB;
 			} else*/ if(files.front().data.size() > 1024) {
-				target.zx8081.memory_model = ZX8081MemoryModel::SixteenKB;
+				target->memory_model = Target::MemoryModel::SixteenKB;
 			} else {
-				target.zx8081.memory_model = ZX8081MemoryModel::Unexpanded;
+				target->memory_model = Target::MemoryModel::Unexpanded;
 			}
-			target.media.tapes = media.tapes;
+			target->media.tapes = media.tapes;
 
 			// TODO: how to run software once loaded? Might require a BASIC detokeniser.
-			if(target.zx8081.isZX81) {
-				target.loading_command = "J\"\"\n";
+			if(target->is_ZX81) {
+				target->loading_command = "J\"\"\n";
 			} else {
-				target.loading_command = "W\n";
+				target->loading_command = "W\n";
 			}
 
-			destination.push_back(target);
 		}
 	}
 }

Analyser/Static/ZX8081/StaticAnalyser.hpp

@@ -10,13 +10,15 @@
 #define StaticAnalyser_ZX8081_StaticAnalyser_hpp
 
 #include "../StaticAnalyser.hpp"
-#include "../../Storage/TargetPlatforms.hpp"
+#include "../../../Storage/TargetPlatforms.hpp"
 
-namespace StaticAnalyser {
+namespace Analyser {
+namespace Static {
 namespace ZX8081 {
 
-void AddTargets(const Media &media, std::list<Target> &destination, TargetPlatform::IntType potential_platforms);
+void AddTargets(const Media &media, std::vector<std::unique_ptr<Target>> &destination, TargetPlatform::IntType potential_platforms);
 
+}
 }
 }
 

Analyser/Static/ZX8081/Target.hpp

@@ -0,0 +1,34 @@
+//
+//  Target.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 09/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef Analyser_Static_ZX8081_Target_h
+#define Analyser_Static_ZX8081_Target_h
+
+#include "../StaticAnalyser.hpp"
+
+namespace Analyser {
+namespace Static {
+namespace ZX8081 {
+
+struct Target: public ::Analyser::Static::Target {
+	enum class MemoryModel {
+		Unexpanded,
+		SixteenKB,
+		SixtyFourKB
+	};
+
+	MemoryModel memory_model = MemoryModel::Unexpanded;
+	bool is_ZX81 = false;
+	bool ZX80_uses_ZX81_ROM = false;
+};
+
+}
+}
+}
+
+#endif /* Analyser_Static_ZX8081_Target_h */

ClockReceiver/TimeTypes.hpp

@@ -0,0 +1,18 @@
+//
+//  TimeTypes.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 21/03/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef TimeTypes_h
+#define TimeTypes_h
+
+namespace Time {
+
+typedef double Seconds;
+
+}
+
+#endif /* TimeTypes_h */

Components/6560/6560.cpp

@@ -18,7 +18,7 @@ AudioGenerator::AudioGenerator(Concurrency::DeferringAsyncTaskQueue &audio_queue
 
 void AudioGenerator::set_volume(uint8_t volume) {
 	audio_queue_.defer([=]() {
-		volume_ = volume;
+		volume_ = static_cast<int16_t>(volume) * range_multiplier_;
 	});
 }
 
@@ -114,12 +114,12 @@ void AudioGenerator::get_samples(std::size_t number_of_samples, int16_t *target)
 
 		// this sums the output of all three sounds channels plus a DC offset for volume;
 		// TODO: what's the real ratio of this stuff?
-		target[c] = (
+		target[c] = static_cast<int16_t>(
 			(shift_registers_[0]&1) +
 			(shift_registers_[1]&1) +
 			(shift_registers_[2]&1) +
 			((noise_pattern[shift_registers_[3] >> 3] >> (shift_registers_[3]&7))&(control_registers_[3] >> 7)&1)
-		) * volume_ * 700 + volume_ * 44;
+		) * volume_ + (volume_ >> 4);
 	}
 }
 
@@ -132,6 +132,10 @@ void AudioGenerator::skip_samples(std::size_t number_of_samples) {
 	}
 }
 
+void AudioGenerator::set_sample_volume_range(std::int16_t range) {
+	range_multiplier_ = static_cast<int16_t>(range / 64);
+}
+
 #undef shift
 #undef increment
 #undef update

Components/6560/6560.hpp

@@ -25,8 +25,10 @@ class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 		void set_volume(uint8_t volume);
 		void set_control(int channel, uint8_t value);
 
+		// For ::SampleSource.
 		void get_samples(std::size_t number_of_samples, int16_t *target);
 		void skip_samples(std::size_t number_of_samples);
+		void set_sample_volume_range(std::int16_t range);
 
 	private:
 		Concurrency::DeferringAsyncTaskQueue &audio_queue_;
@@ -34,7 +36,8 @@ class AudioGenerator: public ::Outputs::Speaker::SampleSource {
 		unsigned int counters_[4] = {2, 1, 0, 0}; 	// create a slight phase offset for the three channels
 		unsigned int shift_registers_[4] = {0, 0, 0, 0};
 		uint8_t control_registers_[4] = {0, 0, 0, 0};
-		uint8_t volume_ = 0;
+		int16_t volume_ = 0;
+		int16_t range_multiplier_ = 1;
 };
 
 /*!
@@ -52,20 +55,28 @@ template <class T> class MOS6560 {
 				audio_generator_(audio_queue_),
 				speaker_(audio_generator_)
 		{
-			crt_->set_composite_sampling_function(
-				"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
+			crt_->set_svideo_sampling_function(
+				"vec2 svideo_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase)"
 				"{"
 					"vec2 yc = texture(texID, coordinate).rg / vec2(255.0);"
-					"float phaseOffset = 6.283185308 * 2.0 * yc.y;"
 
-					"float chroma = cos(phase + phaseOffset);"
-					"return mix(yc.x, step(yc.y, 0.75) * chroma, amplitude);"
+					"float phaseOffset = 6.283185308 * 2.0 * yc.y;"
+					"float chroma = step(yc.y, 0.75) * cos(phase + phaseOffset);"
+
+					"return vec2(yc.x, chroma);"
 				"}");
 
+			// default to s-video output
+			crt_->set_video_signal(Outputs::CRT::VideoSignal::SVideo);
+
 			// default to NTSC
 			set_output_mode(OutputMode::NTSC);
 		}
 
+		~MOS6560() {
+			audio_queue_.flush();
+		}
+
 		void set_clock_rate(double clock_rate) {
 			speaker_.set_input_rate(static_cast<float>(clock_rate / 4.0));
 		}
@@ -87,28 +98,28 @@ template <class T> class MOS6560 {
 		void set_output_mode(OutputMode output_mode) {
 			output_mode_ = output_mode;
 
-			// Lumunances are encoded trivially: on a 0–255 scale.
+			// Luminances are encoded trivially: on a 0–255 scale.
 			const uint8_t luminances[16] = {
-				0,		255,	109,	189,
-				199,	144,	159,	161,
-				126,	227,	227,	207,
-				235,	173,	188,	196
+				0,		255,	60,		189,
+				80,		144,	40,		227,
+				90,		161,	207,	227,
+				200,	196,	160,	196
 			};
 
 			// Chrominances are encoded such that 0–128 is a complete revolution of phase;
 			// anything above 191 disables the colour subcarrier. Phase is relative to the
 			// colour burst, so 0 is green.
 			const uint8_t pal_chrominances[16] = {
-				255,	255,	40,		112,
-				8,		88,		120,	56,
-				40,		48,		40,		112,
-				8,		88,		120,	56,
+				255,	255,	37,		101,
+				19,		86,		123,	59,
+				46,		53,		37,		101,
+				19,		86,		123,	59,
 			};
 			const uint8_t ntsc_chrominances[16] = {
-				255,	255,	8,		72,
-				32,		88,		48,		112,
-				0,		0,		8,		72,
-				32,		88,		48,		112,
+				255,	255,	7,		71,
+				25,		86,		48,		112,
+				0,		119,	7,		71,
+				25,		86,		48,		112,
 			};
 			const uint8_t *chrominances;
 			Outputs::CRT::DisplayType display_type;
@@ -134,16 +145,15 @@ template <class T> class MOS6560 {
 			}
 
 			crt_->set_new_display_type(static_cast<unsigned int>(timing_.cycles_per_line*4), display_type);
-			crt_->set_visible_area(Outputs::CRT::Rect(0.05f, 0.05f, 0.9f, 0.9f));
 
-//			switch(output_mode) {
-//				case OutputMode::PAL:
-//					crt_->set_visible_area(crt_->get_rect_for_area(16, 237, 15*4, 55*4, 4.0f / 3.0f));
-//				break;
-//				case OutputMode::NTSC:
-//					crt_->set_visible_area(crt_->get_rect_for_area(16, 237, 11*4, 55*4, 4.0f / 3.0f));
-//				break;
-//			}
+			switch(output_mode) {
+				case OutputMode::PAL:
+					crt_->set_visible_area(Outputs::CRT::Rect(0.1f, 0.05f, 0.9f, 0.9f));
+				break;
+				case OutputMode::NTSC:
+					crt_->set_visible_area(Outputs::CRT::Rect(0.05f, 0.05f, 0.9f, 0.9f));
+				break;
+			}
 
 			for(int c = 0; c < 16; c++) {
 				uint8_t *colour = reinterpret_cast<uint8_t *>(&colours_[c]);

Components/9918/9918.cpp

@@ -53,6 +53,34 @@ const uint8_t StatusFifthSprite = 0x40;
 const int StatusSpriteCollisionShift = 5;
 const uint8_t StatusSpriteCollision = 0x20;
 
+struct ReverseTable {
+	std::uint8_t map[256];
+
+	ReverseTable() {
+		for(int c = 0; c < 256; ++c) {
+			map[c] = static_cast<uint8_t>(
+				((c & 0x80) >> 7) |
+				((c & 0x40) >> 5) |
+				((c & 0x20) >> 3) |
+				((c & 0x10) >> 1) |
+				((c & 0x08) << 1) |
+				((c & 0x04) << 3) |
+				((c & 0x02) << 5) |
+				((c & 0x01) << 7)
+			);
+		}
+	}
+} reverse_table;
+
+// Bits are reversed in the internal mode value; they're stored
+// in the order M1 M2 M3. Hence the definitions below.
+enum ScreenMode {
+	Text = 4,
+	MultiColour = 2,
+	ColouredText = 0,
+	Graphics = 1
+};
+
 }
 
 TMS9918Base::TMS9918Base() :
@@ -68,9 +96,15 @@ TMS9918::TMS9918(Personality p) {
 		"{"
 			"return texture(sampler, coordinate).rgb / vec3(255.0);"
 		"}");
-	crt_->set_output_device(Outputs::CRT::OutputDevice::Monitor);
+	crt_->set_video_signal(Outputs::CRT::VideoSignal::RGB);
 	crt_->set_visible_area(Outputs::CRT::Rect(0.055f, 0.025f, 0.9f, 0.9f));
 	crt_->set_input_gamma(2.8f);
+
+	// The TMS remains in-phase with the NTSC colour clock; this is an empirical measurement
+	// intended to produce the correct relationship between the hard edges between pixels and
+	// the colour clock. It was eyeballed rather than derived from any knowledge of the TMS
+	// colour burst generator because I've yet to find any.
+	crt_->set_immediate_default_phase(0.85f);
 }
 
 Outputs::CRT::CRT *TMS9918::get_crt() {
@@ -274,7 +308,8 @@ void TMS9918::run_for(const HalfCycles cycles) {
 						int row_base = pattern_name_address_;
 						int pattern_base = pattern_generator_table_address_;
 						int colour_base = colour_table_address_;
-						if(screen_mode_ == 1) {
+						if(screen_mode_ == ScreenMode::Graphics) {
+							// If this is high resolution mode, allow the row number to affect the pattern and colour addresses.
 							pattern_base &= 0x2000 | ((row_ & 0xc0) << 5);
 							colour_base &= 0x2000 | ((row_ & 0xc0) << 5);
 						}
@@ -285,7 +320,7 @@ void TMS9918::run_for(const HalfCycles cycles) {
 						const int pattern_names_end = (end - 27 + 3) >> 2;
 						std::memcpy(&pattern_names_[pattern_names_start], &ram_[row_base + pattern_names_start], static_cast<size_t>(pattern_names_end - pattern_names_start));
 
-						// Colours are collected ever fourth window starting from window 29.
+						// Colours are collected every fourth window starting from window 29.
 						const int colours_start = (access_pointer_ - 29 + 3) >> 2;
 						const int colours_end = (end - 29 + 3) >> 2;
 						if(screen_mode_ != 1) {
@@ -301,8 +336,11 @@ void TMS9918::run_for(const HalfCycles cycles) {
 						// Patterns are collected ever fourth window starting from window 30.
 						const int pattern_buffer_start = (access_pointer_ - 30 + 3) >> 2;
 						const int pattern_buffer_end = (end - 30 + 3) >> 2;
+
+						// Multicolour mode uss a different function of row to pick bytes
+						const int row = (screen_mode_ != 2) ? (row_ & 7) : ((row_ >> 2) & 7);
 						for(int column = pattern_buffer_start; column < pattern_buffer_end; ++column) {
-							pattern_buffer_[column] = ram_[pattern_base + (pattern_names_[column] << 3) + (row_ & 7)];
+							pattern_buffer_[column] = ram_[pattern_base + (pattern_names_[column] << 3) + row];
 						}
 
 						// Sprite slots occur in three quarters of ever fourth window starting from window 28.
@@ -380,21 +418,21 @@ void TMS9918::run_for(const HalfCycles cycles) {
 
 							const int shift = (output_column_ - first_pixel_column_) % 6;
 							int byte_column = (output_column_ - first_pixel_column_) / 6;
-							int pattern = pattern_buffer_[byte_column] << shift;
+							int pattern = reverse_table.map[pattern_buffer_[byte_column]] >> shift;
 							int pixels_left = pixels_end - output_column_;
 							int length = std::min(pixels_left, 6 - shift);
 							while(true) {
 								pixels_left -= length;
-								while(length--) {
-									*pixel_target_ = colours[(pattern >> 7)&0x01];
-									pixel_target_++;
-									pattern <<= 1;
+								for(int c = 0; c < length; ++c) {
+									pixel_target_[c] = colours[pattern&0x01];
+									pattern >>= 1;
 								}
+								pixel_target_ += length;
 
 								if(!pixels_left) break;
 								length = std::min(6, pixels_left);
 								byte_column++;
-								pattern = pattern_buffer_[byte_column];
+								pattern = reverse_table.map[pattern_buffer_[byte_column]];
 							}
 							output_column_ = pixels_end;
 						} break;
@@ -402,7 +440,7 @@ void TMS9918::run_for(const HalfCycles cycles) {
 						case LineMode::Character: {
 							// If this is the start of the visible area, seed sprite shifter positions.
 							SpriteSet &sprite_set = sprite_sets_[active_sprite_set_ ^ 1];
-							if(line_mode_ == LineMode::Character && output_column_ == first_pixel_column_) {
+							if(output_column_ == first_pixel_column_) {
 								int c = sprite_set.active_sprite_slot;
 								while(c--) {
 									SpriteSet::ActiveSprite &sprite = sprite_set.active_sprites[c];
@@ -416,36 +454,46 @@ void TMS9918::run_for(const HalfCycles cycles) {
 							}
 
 							// Paint the background tiles.
-							const int shift = (output_column_ - first_pixel_column_) & 7;
-							int byte_column = (output_column_ - first_pixel_column_) >> 3;
-
 							const int pixels_left = pixels_end - output_column_;
-							int length = std::min(pixels_left, 8 - shift);
-
-							int pattern = pattern_buffer_[byte_column] << shift;
-							uint8_t colour = colour_buffer_[byte_column];
-							uint32_t colours[2] = {
-								palette[(colour & 15) ? (colour & 15) : background_colour_],
-								palette[(colour >> 4) ? (colour >> 4) : background_colour_]
-							};
-
-							int background_pixels_left = pixels_left;
-							while(true) {
-								background_pixels_left -= length;
-								while(length--) {
-									*pixel_target_ = colours[(pattern >> 7)&0x01];
-									pixel_target_++;
-									pattern <<= 1;
+							if(screen_mode_ == ScreenMode::MultiColour) {
+								int pixel_location = output_column_ - first_pixel_column_;
+								for(int c = 0; c < pixels_left; ++c) {
+									pixel_target_[c] = palette[
+										(pattern_buffer_[(pixel_location + c) >> 3] >> (((pixel_location + c) & 4)^4)) & 15
+									];
 								}
+								pixel_target_ += pixels_left;
+							} else {
+								const int shift = (output_column_ - first_pixel_column_) & 7;
+								int byte_column = (output_column_ - first_pixel_column_) >> 3;
 
-								if(!background_pixels_left) break;
-								length = std::min(8, background_pixels_left);
-								byte_column++;
+								int length = std::min(pixels_left, 8 - shift);
 
-								pattern = pattern_buffer_[byte_column];
-								colour = colour_buffer_[byte_column];
-								colours[0] = palette[(colour & 15) ? (colour & 15) : background_colour_];
-								colours[1] = palette[(colour >> 4) ? (colour >> 4) : background_colour_];
+								int pattern = reverse_table.map[pattern_buffer_[byte_column]] >> shift;
+								uint8_t colour = colour_buffer_[byte_column];
+								uint32_t colours[2] = {
+									palette[(colour & 15) ? (colour & 15) : background_colour_],
+									palette[(colour >> 4) ? (colour >> 4) : background_colour_]
+								};
+
+								int background_pixels_left = pixels_left;
+								while(true) {
+									background_pixels_left -= length;
+									for(int c = 0; c < length; ++c) {
+										pixel_target_[c] = colours[pattern&0x01];
+										pattern >>= 1;
+									}
+									pixel_target_ += length;
+
+									if(!background_pixels_left) break;
+									length = std::min(8, background_pixels_left);
+									byte_column++;
+
+									pattern = reverse_table.map[pattern_buffer_[byte_column]];
+									colour = colour_buffer_[byte_column];
+									colours[0] = palette[(colour & 15) ? (colour & 15) : background_colour_];
+									colours[1] = palette[(colour >> 4) ? (colour >> 4) : background_colour_];
+								}
 							}
 
 							// Paint sprites and check for collisions.
@@ -535,7 +583,7 @@ void TMS9918::run_for(const HalfCycles cycles) {
 			screen_mode_ = next_screen_mode_;
 			blank_screen_ = next_blank_screen_;
 			switch(screen_mode_) {
-				case 2:
+				case ScreenMode::Text:
 					line_mode_ = LineMode::Text;
 					first_pixel_column_ = 69;
 					first_right_border_column_ = 309;
@@ -589,7 +637,7 @@ void TMS9918::set_register(int address, uint8_t value) {
 			case 1:
 				next_blank_screen_ = !(low_write_ & 0x40);
 				generate_interrupts_ = !!(low_write_ & 0x20);
-				next_screen_mode_ = (next_screen_mode_ & 1) | ((low_write_ & 0x18) >> 3);
+				next_screen_mode_ = (next_screen_mode_ & 1) | ((low_write_ & 0x18) >> 2);
 				sprites_16x16_ = !!(low_write_ & 0x02);
 				sprites_magnified_ = !!(low_write_ & 0x01);
 

Components/AY38910/AY38910.cpp

@@ -56,13 +56,18 @@ AY38910::AY38910(Concurrency::DeferringAsyncTaskQueue &task_queue) : task_queue_
 		}
 	}
 
+	set_sample_volume_range(0);
+}
+
+void AY38910::set_sample_volume_range(std::int16_t range) {
 	// set up volume lookup table
-	float max_volume = 8192;
-	float root_two = sqrtf(2.0f);
+	const float max_volume = static_cast<float>(range) / 3.0f;	// As there are three channels.
+	const float root_two = sqrtf(2.0f);
 	for(int v = 0; v < 16; v++) {
 		volumes_[v] = static_cast<int>(max_volume / powf(root_two, static_cast<float>(v ^ 0xf)));
 	}
 	volumes_[0] = 0;
+	evaluate_output_volume();
 }
 
 void AY38910::get_samples(std::size_t number_of_samples, int16_t *target) {
@@ -156,6 +161,11 @@ void AY38910::evaluate_output_volume() {
 	);
 }
 
+bool AY38910::is_zero_level() {
+	// Confirm that the AY is trivially at the zero level if all three volume controls are set to fixed zero.
+	return output_registers_[0x8] == 0 && output_registers_[0x9] == 0 && output_registers_[0xa] == 0;
+}
+
 // MARK: - Register manipulation
 
 void AY38910::select_register(uint8_t r) {

Components/AY38910/AY38910.hpp

@@ -85,6 +85,8 @@ class AY38910: public ::Outputs::Speaker::SampleSource {
 
 		// to satisfy ::Outputs::Speaker (included via ::Outputs::Filter; not for public consumption
 		void get_samples(std::size_t number_of_samples, int16_t *target);
+		bool is_zero_level();
+		void set_sample_volume_range(std::int16_t range);
 
 	private:
 		Concurrency::DeferringAsyncTaskQueue &task_queue_;

Components/KonamiSCC/KonamiSCC.cpp

@@ -15,19 +15,19 @@ using namespace Konami;
 SCC::SCC(Concurrency::DeferringAsyncTaskQueue &task_queue) :
 	task_queue_(task_queue) {}
 
-bool SCC::is_silent() {
+bool SCC::is_zero_level() {
 	return !(channel_enable_ & 0x1f);
 }
 
 void SCC::get_samples(std::size_t number_of_samples, std::int16_t *target) {
-	if(is_silent()) {
+	if(is_zero_level()) {
 		std::memset(target, 0, sizeof(std::int16_t) * number_of_samples);
 		return;
 	}
 
 	std::size_t c = 0;
 	while((master_divider_&7) && c < number_of_samples) {
-		target[c] = output_volume_;
+		target[c] = transient_output_level_;
 		master_divider_++;
 		c++;
 	}
@@ -44,7 +44,7 @@ void SCC::get_samples(std::size_t number_of_samples, std::int16_t *target) {
 		evaluate_output_volume();
 
 		for(int ic = 0; ic < 8 && c < number_of_samples; ++ic) {
-			target[c] = output_volume_;
+			target[c] = transient_output_level_;
 			c++;
 			master_divider_++;
 		}
@@ -86,18 +86,24 @@ void SCC::write(uint16_t address, uint8_t value) {
 }
 
 void SCC::evaluate_output_volume() {
-	output_volume_ =
+	transient_output_level_ =
 		static_cast<int16_t>(
-			(
+			((
 				(channel_enable_ & 0x01) ? static_cast<int8_t>(waves_[0].samples[channels_[0].offset]) * channels_[0].amplitude : 0 +
 				(channel_enable_ & 0x02) ? static_cast<int8_t>(waves_[1].samples[channels_[1].offset]) * channels_[1].amplitude : 0 +
 				(channel_enable_ & 0x04) ? static_cast<int8_t>(waves_[2].samples[channels_[2].offset]) * channels_[2].amplitude : 0 +
 				(channel_enable_ & 0x08) ? static_cast<int8_t>(waves_[3].samples[channels_[3].offset]) * channels_[3].amplitude : 0 +
 				(channel_enable_ & 0x10) ? static_cast<int8_t>(waves_[3].samples[channels_[4].offset]) * channels_[4].amplitude : 0
-			)
+			) * master_volume_) / (255*15*5)
+			// Five channels, each with 8-bit samples and 4-bit volumes implies a natural range of 0 to 255*15*5.
 		);
 }
 
+void SCC::set_sample_volume_range(std::int16_t range) {
+	master_volume_ = range;
+	evaluate_output_volume();
+}
+
 uint8_t SCC::read(uint16_t address) {
 	address &= 0xff;
 	if(address < 0x80) {
@@ -105,3 +111,5 @@ uint8_t SCC::read(uint16_t address) {
 	}
 	return 0xff;
 }
+
+

Components/KonamiSCC/KonamiSCC.hpp

@@ -27,10 +27,11 @@ class SCC: public ::Outputs::Speaker::SampleSource {
 		SCC(Concurrency::DeferringAsyncTaskQueue &task_queue);
 
 		/// As per ::SampleSource; provides a broadphase test for silence.
-		bool is_silent();
+		bool is_zero_level();
 
 		/// As per ::SampleSource; provides audio output.
 		void get_samples(std::size_t number_of_samples, std::int16_t *target);
+		void set_sample_volume_range(std::int16_t range);
 
 		/// Writes to the SCC.
 		void write(uint16_t address, uint8_t value);
@@ -43,7 +44,8 @@ class SCC: public ::Outputs::Speaker::SampleSource {
 
 		// State from here on down is accessed ony from the audio thread.
 		int master_divider_ = 0;
-		int16_t output_volume_ = 0;
+		std::int16_t master_volume_ = 0;
+		int16_t transient_output_level_ = 0;
 
 		struct Channel {
 			int period = 0;

Components/SN76489/SN76489.cpp

@@ -0,0 +1,161 @@
+//
+//  SN76489.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 26/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "SN76489.hpp"
+
+#include <cassert>
+#include <cmath>
+
+using namespace TI;
+
+SN76489::SN76489(Personality personality, Concurrency::DeferringAsyncTaskQueue &task_queue, int additional_divider) : task_queue_(task_queue) {
+	set_sample_volume_range(0);
+
+	switch(personality) {
+		case Personality::SN76494:
+			master_divider_period_ = 2;
+			shifter_is_16bit_ = false;
+		break;
+		case Personality::SN76489:
+			master_divider_period_ = 16;
+			shifter_is_16bit_ = false;
+		break;
+		case Personality::SMS:
+			master_divider_period_ = 16;
+			shifter_is_16bit_ = true;
+		break;
+	}
+
+	assert((master_divider_period_ % additional_divider) == 0);
+	assert(additional_divider < master_divider_period_);
+	master_divider_period_ /= additional_divider;
+}
+
+void SN76489::set_sample_volume_range(std::int16_t range) {
+	// Build a volume table.
+	double multiplier = pow(10.0, -0.1);
+	double volume = static_cast<float>(range) / 4.0f;	// As there are four channels.
+	for(int c = 0; c < 16; ++c) {
+		volumes_[c] = (int)round(volume);
+		volume *= multiplier;
+	}
+	volumes_[15] = 0;
+	evaluate_output_volume();
+}
+
+void SN76489::set_register(uint8_t value) {
+	task_queue_.defer([value, this] () {
+		if(value & 0x80) {
+			active_register_ = value;
+		}
+
+		const int channel = (active_register_ >> 5)&3;
+		if(active_register_ & 0x10) {
+			// latch for volume
+			channels_[channel].volume = value & 0xf;
+			evaluate_output_volume();
+		} else {
+			// latch for tone/data
+			if(channel < 3) {
+				if(value & 0x80) {
+					channels_[channel].divider = (channels_[channel].divider & ~0xf) | (value & 0xf);
+				} else {
+					channels_[channel].divider = static_cast<uint16_t>((channels_[channel].divider & 0xf) | ((value & 0x3f) << 4));
+				}
+			} else {
+				// writes to the noise register always reset the shifter
+				noise_shifter_ = shifter_is_16bit_ ? 0x8000 : 0x4000;
+
+				if(value & 4) {
+					noise_mode_ = shifter_is_16bit_ ? Noise16 : Noise15;
+				} else {
+					noise_mode_ = shifter_is_16bit_ ? Periodic16 : Periodic15;
+				}
+
+				channels_[3].divider = static_cast<uint16_t>(0x10 << (value & 3));
+				// Special case: if these bits are both set, the noise channel should track channel 2,
+				// which is marked with a divider of 0xffff.
+				if(channels_[3].divider == 0x80) channels_[3].divider = 0xffff;
+			}
+		}
+	});
+}
+
+bool SN76489::is_zero_level() {
+	return channels_[0].volume == 0xf && channels_[1].volume == 0xf && channels_[2].volume == 0xf && channels_[3].volume == 0xf;
+}
+
+void SN76489::evaluate_output_volume() {
+	output_volume_ = static_cast<int16_t>(
+		channels_[0].level * volumes_[channels_[0].volume] +
+		channels_[1].level * volumes_[channels_[1].volume] +
+		channels_[2].level * volumes_[channels_[2].volume] +
+		channels_[3].level * volumes_[channels_[3].volume]
+	);
+}
+
+void SN76489::get_samples(std::size_t number_of_samples, std::int16_t *target) {
+	std::size_t c = 0;
+	while((master_divider_& (master_divider_period_ - 1)) && c < number_of_samples) {
+		target[c] = output_volume_;
+		master_divider_++;
+		c++;
+	}
+
+	while(c < number_of_samples) {
+		bool did_flip = false;
+
+#define step_channel(x, s) \
+		if(channels_[x].counter) channels_[x].counter--;\
+		else {\
+			channels_[x].level ^= 1;\
+			channels_[x].counter = channels_[x].divider;\
+			s;\
+		}
+
+		step_channel(0, /**/);
+		step_channel(1, /**/);
+		step_channel(2, did_flip = true);
+
+#undef step_channel
+
+		if(channels_[3].divider != 0xffff) {
+			if(channels_[3].counter) channels_[3].counter--;
+			else {
+				did_flip = true;
+				channels_[3].counter = channels_[3].divider;
+			}
+		}
+
+		if(did_flip) {
+			channels_[3].level = noise_shifter_ & 1;
+			int new_bit = channels_[3].level;
+			switch(noise_mode_) {
+				default: break;
+				case Noise15:
+					new_bit ^= (noise_shifter_ >> 1);
+				break;
+				case Noise16:
+					new_bit ^= (noise_shifter_ >> 3);
+				break;
+			}
+			noise_shifter_ >>= 1;
+			noise_shifter_ |= (new_bit & 1) << (shifter_is_16bit_ ? 15 : 14);
+		}
+
+		evaluate_output_volume();
+
+		for(int ic = 0; ic < master_divider_period_ && c < number_of_samples; ++ic) {
+			target[c] = output_volume_;
+			c++;
+			master_divider_++;
+		}
+	}
+
+	master_divider_ &= (master_divider_period_ - 1);
+}

Components/SN76489/SN76489.hpp

@@ -0,0 +1,68 @@
+//
+//  SN76489.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 26/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef SN76489_hpp
+#define SN76489_hpp
+
+#include "../../Outputs/Speaker/Implementation/SampleSource.hpp"
+#include "../../Concurrency/AsyncTaskQueue.hpp"
+
+namespace TI {
+
+class SN76489: public Outputs::Speaker::SampleSource {
+	public:
+		enum class Personality {
+			SN76489,
+			SN76494,
+			SMS
+		};
+
+		/// Creates a new SN76489.
+		SN76489(Personality personality, Concurrency::DeferringAsyncTaskQueue &task_queue, int additional_divider = 1);
+
+		/// Writes a new value to the SN76489.
+		void set_register(uint8_t value);
+
+		// As per SampleSource.
+		void get_samples(std::size_t number_of_samples, std::int16_t *target);
+		bool is_zero_level();
+		void set_sample_volume_range(std::int16_t range);
+
+	private:
+		int master_divider_ = 0;
+		int master_divider_period_ = 16;
+		int16_t output_volume_ = 0;
+		void evaluate_output_volume();
+		int volumes_[16];
+
+		Concurrency::DeferringAsyncTaskQueue &task_queue_;
+
+		struct ToneChannel {
+			// Programmatically-set state; updated by the processor.
+			uint16_t divider = 0;
+			uint8_t volume = 0xf;
+
+			// Active state; self-evolving as a function of time.
+			uint16_t counter = 0;
+			int level = 0;
+		} channels_[4];
+		enum {
+			Periodic15,
+			Periodic16,
+			Noise15,
+			Noise16
+		} noise_mode_ = Periodic15;
+		uint16_t noise_shifter_ = 0;
+		int active_register_ = 0;
+
+		bool shifter_is_16bit_ = false;
+};
+
+}
+
+#endif /* SN76489_hpp */

Concurrency/AsyncTaskQueue.cpp

@@ -45,6 +45,7 @@ AsyncTaskQueue::AsyncTaskQueue()
 
 AsyncTaskQueue::~AsyncTaskQueue() {
 #ifdef __APPLE__
+	flush();
 	dispatch_release(serial_dispatch_queue_);
 	serial_dispatch_queue_ = nullptr;
 #else
@@ -80,6 +81,11 @@ void AsyncTaskQueue::flush() {
 #endif
 }
 
+DeferringAsyncTaskQueue::~DeferringAsyncTaskQueue() {
+	perform();
+	flush();
+}
+
 void DeferringAsyncTaskQueue::defer(std::function<void(void)> function) {
 	if(!deferred_tasks_) {
 		deferred_tasks_.reset(new std::list<std::function<void(void)>>);

Concurrency/AsyncTaskQueue.hpp

@@ -30,7 +30,7 @@ namespace Concurrency {
 class AsyncTaskQueue {
 	public:
 		AsyncTaskQueue();
-		~AsyncTaskQueue();
+		virtual ~AsyncTaskQueue();
 
 		/*!
 			Adds @c function to the queue.
@@ -69,6 +69,8 @@ class AsyncTaskQueue {
 */
 class DeferringAsyncTaskQueue: public AsyncTaskQueue {
 	public:
+		~DeferringAsyncTaskQueue();
+
 		/*!
 			Adds a function to the deferral list.
 

Concurrency/BestEffortUpdater.cpp

@@ -17,6 +17,11 @@ BestEffortUpdater::BestEffortUpdater() {
 	update_is_ongoing_.clear();
 }
 
+BestEffortUpdater::~BestEffortUpdater() {
+	// Don't allow further deconstruction until the task queue is stopped.
+	flush();
+}
+
 void BestEffortUpdater::update() {
 	// Perform an update only if one is not currently ongoing.
 	if(!update_is_ongoing_.test_and_set()) {
@@ -31,13 +36,11 @@ void BestEffortUpdater::update() {
 				// If the duration is valid, convert it to integer cycles, maintaining a rolling error and call the delegate
 				// if there is one. Proceed only if the number of cycles is positive, and cap it to the per-second maximum —
 				// it's possible this is an adjustable clock so be ready to swallow unexpected adjustments.
-				const int64_t duration = std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
-				if(duration > 0) {
-					double cycles = ((static_cast<double>(duration) * clock_rate_) / 1e9) + error_;
-					error_ = fmod(cycles, 1.0);
-
+				const int64_t integer_duration = std::chrono::duration_cast<std::chrono::nanoseconds>(elapsed).count();
+				if(integer_duration > 0) {
 					if(delegate_) {
-						delegate_->update(this, static_cast<int>(std::min(cycles, clock_rate_)), has_skipped_);
+						const double duration = static_cast<double>(integer_duration) / 1e9;
+						delegate_->update(this, duration, has_skipped_);
 					}
 					has_skipped_ = false;
 				}
@@ -65,8 +68,3 @@ void BestEffortUpdater::set_delegate(Delegate *const delegate) {
 	});
 }
 
-void BestEffortUpdater::set_clock_rate(const double clock_rate) {
-	async_task_queue_.enqueue([this, clock_rate]() {
-		this->clock_rate_ = clock_rate;
-	});
-}

Concurrency/BestEffortUpdater.hpp

@@ -13,6 +13,7 @@
 #include <chrono>
 
 #include "AsyncTaskQueue.hpp"
+#include "../ClockReceiver/TimeTypes.hpp"
 
 namespace Concurrency {
 
@@ -26,18 +27,16 @@ namespace Concurrency {
 class BestEffortUpdater {
 	public:
 		BestEffortUpdater();
+		~BestEffortUpdater();
 
 		/// A delegate receives timing cues.
 		struct Delegate {
-			virtual void update(BestEffortUpdater *updater, int cycles, bool did_skip_previous_update) = 0;
+			virtual void update(BestEffortUpdater *updater, Time::Seconds duration, bool did_skip_previous_update) = 0;
 		};
 
 		/// Sets the current delegate.
 		void set_delegate(Delegate *);
 
-		/// Sets the clock rate of the delegate.
-		void set_clock_rate(double clock_rate);
-
 		/*!
 			If the delegate is not currently in the process of an `update` call, calls it now to catch up to the current time.
 			The call is asynchronous; this method will return immediately.
@@ -53,11 +52,9 @@ class BestEffortUpdater {
 
 		std::chrono::time_point<std::chrono::high_resolution_clock> previous_time_point_;
 		bool has_previous_time_point_ = false;
-		double error_ = 0.0;
 		bool has_skipped_ = false;
 
 		Delegate *delegate_ = nullptr;
-		double clock_rate_ = 1.0;
 };
 
 }

Configurable/Configurable.hpp

@@ -26,6 +26,10 @@ struct Option {
 	virtual ~Option() {}
 
 	Option(const std::string &long_name, const std::string &short_name) : long_name(long_name), short_name(short_name) {}
+
+	virtual bool operator==(const Option &rhs) {
+		return long_name == rhs.long_name && short_name == rhs.short_name;
+	}
 };
 
 struct BooleanOption: public Option {
@@ -35,6 +39,12 @@ struct BooleanOption: public Option {
 struct ListOption: public Option {
 	std::vector<std::string> options;
 	ListOption(const std::string &long_name, const std::string &short_name, const std::vector<std::string> &options) : Option(long_name, short_name), options(options) {}
+
+	virtual bool operator==(const Option &rhs) {
+		const ListOption *list_rhs = dynamic_cast<const ListOption *>(&rhs);
+		if(!list_rhs) return false;
+		return long_name == rhs.long_name && short_name == rhs.short_name && options == list_rhs->options;
+	}
 };
 
 struct BooleanSelection;

Configurable/StandardOptions.cpp

@@ -33,7 +33,13 @@ bool get_bool(const Configurable::SelectionSet &selections_by_option, const std:
 std::vector<std::unique_ptr<Configurable::Option>> Configurable::standard_options(Configurable::StandardOptions mask) {
 	std::vector<std::unique_ptr<Configurable::Option>> options;
 	if(mask & QuickLoadTape)				options.emplace_back(new Configurable::BooleanOption("Load Tapes Quickly", "quickload"));
-	if(mask & DisplayRGBComposite)			options.emplace_back(new Configurable::ListOption("Display", "display", {"composite", "rgb"}));
+	if(mask & (DisplayRGB | DisplayComposite | DisplaySVideo)) {
+		std::vector<std::string> display_options;
+		if(mask & DisplayComposite)	display_options.emplace_back("composite");
+		if(mask & DisplaySVideo) 	display_options.emplace_back("svideo");
+		if(mask & DisplayRGB) 		display_options.emplace_back("rgb");
+		options.emplace_back(new Configurable::ListOption("Display", "display", display_options));
+	}
 	if(mask & AutomaticTapeMotorControl)	options.emplace_back(new Configurable::BooleanOption("Automatic Tape Motor Control", "autotapemotor"));
 	return options;
 }
@@ -48,7 +54,14 @@ void Configurable::append_automatic_tape_motor_control_selection(SelectionSet &s
 }
 
 void Configurable::append_display_selection(Configurable::SelectionSet &selection_set, Display selection) {
-	selection_set["display"] = std::unique_ptr<Configurable::Selection>(new Configurable::ListSelection((selection == Display::RGB) ? "rgb" : "composite"));
+	std::string string_selection;
+	switch(selection) {
+		default:
+		case Display::RGB:			string_selection = "rgb";		break;
+		case Display::SVideo:		string_selection = "svideo";	break;
+		case Display::Composite:	string_selection = "composite";	break;
+	}
+	selection_set["display"] = std::unique_ptr<Configurable::Selection>(new Configurable::ListSelection(string_selection));
 }
 
 // MARK: - Selection parsers
@@ -67,6 +80,10 @@ bool Configurable::get_display(const Configurable::SelectionSet &selections_by_o
 			result = Configurable::Display::RGB;
 			return true;
 		}
+		if(display->value == "svideo") {
+			result = Configurable::Display::SVideo;
+			return true;
+		}
 		if(display->value == "composite") {
 			result = Configurable::Display::Composite;
 			return true;

Configurable/StandardOptions.hpp

@@ -14,13 +14,16 @@
 namespace Configurable {
 
 enum StandardOptions {
-	DisplayRGBComposite			= (1 << 0),
-	QuickLoadTape				= (1 << 1),
-	AutomaticTapeMotorControl	= (1 << 2)
+	DisplayRGB					= (1 << 0),
+	DisplaySVideo				= (1 << 1),
+	DisplayComposite			= (1 << 2),
+	QuickLoadTape				= (1 << 3),
+	AutomaticTapeMotorControl	= (1 << 4)
 };
 
 enum class Display {
 	RGB,
+	SVideo,
 	Composite
 };
 

Inputs/Joystick.hpp

@@ -21,18 +21,45 @@ class Joystick {
 	public:
 		virtual ~Joystick() {}
 
-		enum class DigitalInput {
-			Up, Down, Left, Right, Fire
+		struct DigitalInput {
+			enum Type {
+				Up, Down, Left, Right, Fire,
+				Key
+			} type;
+			union {
+				struct {
+					int index;
+				} control;
+				struct {
+					wchar_t symbol;
+				} key;
+			} info;
+
+			DigitalInput(Type type, int index = 0) : type(type) {
+				info.control.index = index;
+			}
+			DigitalInput(wchar_t symbol) : type(Key) {
+				info.key.symbol = symbol;
+			}
+
+			bool operator == (const DigitalInput &rhs) {
+				if(rhs.type != type) return false;
+				if(rhs.type == Key) {
+					return rhs.info.key.symbol == info.key.symbol;
+				} else {
+					return rhs.info.control.index == info.control.index;
+				}
+			}
 		};
 
+		virtual std::vector<DigitalInput> get_inputs() = 0;
+
 		// Host interface.
-		virtual void set_digital_input(DigitalInput digital_input, bool is_active) = 0;
+		virtual void set_digital_input(const DigitalInput &digital_input, bool is_active) = 0;
 		virtual void reset_all_inputs() {
-			set_digital_input(DigitalInput::Up, false);
-			set_digital_input(DigitalInput::Down, false);
-			set_digital_input(DigitalInput::Left, false);
-			set_digital_input(DigitalInput::Right, false);
-			set_digital_input(DigitalInput::Fire, false);
+			for(const auto &input: get_inputs()) {
+				set_digital_input(input, false);
+			}
 		}
 };
 

Machines/AmstradCPC/AmstradCPC.cpp

@@ -20,11 +20,17 @@
 #include "../Utility/MemoryFuzzer.hpp"
 #include "../Utility/Typer.hpp"
 
+#include "../ConfigurationTarget.hpp"
+#include "../CRTMachine.hpp"
+#include "../KeyboardMachine.hpp"
+
 #include "../../Storage/Tape/Tape.hpp"
 
 #include "../../ClockReceiver/ForceInline.hpp"
 #include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
 
+#include "../../Analyser/Static/AmstradCPC/Target.hpp"
+
 #include <cstdint>
 #include <vector>
 
@@ -120,6 +126,10 @@ class AYDeferrer {
 			speaker_.set_input_rate(1000000);
 		}
 
+		~AYDeferrer() {
+			audio_queue_.flush();
+		}
+
 		/// Adds @c half_cycles half cycles to the amount of time that has passed.
 		inline void run_for(HalfCycles half_cycles) {
 			cycles_since_update_ += half_cycles;
@@ -307,7 +317,7 @@ class CRTCBusHandler {
 					"return vec3(float((sample >> 4) & 3u), float((sample >> 2) & 3u), float(sample & 3u)) / 2.0;"
 				"}");
 			crt_->set_visible_area(Outputs::CRT::Rect(0.075f, 0.05f, 0.9f, 0.9f));
-			crt_->set_output_device(Outputs::CRT::OutputDevice::Monitor);
+			crt_->set_video_signal(Outputs::CRT::VideoSignal::RGB);
 		}
 
 		/// Destructs the CRT.
@@ -674,6 +684,9 @@ class i8255PortHandler : public Intel::i8255::PortHandler {
 	The actual Amstrad CPC implementation; tying the 8255, 6845 and AY to the Z80.
 */
 class ConcreteMachine:
+	public CRTMachine::Machine,
+	public ConfigurationTarget::Machine,
+	public KeyboardMachine::Machine,
 	public Utility::TypeRecipient,
 	public CPU::Z80::BusHandler,
 	public Sleeper::SleepObserver,
@@ -867,19 +880,21 @@ class ConcreteMachine:
 		}
 
 		/// The ConfigurationTarget entry point; should configure this meachine as described by @c target.
-		void configure_as_target(const StaticAnalyser::Target &target) override final  {
-			switch(target.amstradcpc.model) {
-				case StaticAnalyser::AmstradCPCModel::CPC464:
+		void configure_as_target(const Analyser::Static::Target *target) override final  {
+			auto *const cpc_target = dynamic_cast<const Analyser::Static::AmstradCPC::Target *>(target);
+
+			switch(cpc_target->model) {
+				case Analyser::Static::AmstradCPC::Target::Model::CPC464:
 					rom_model_ = ROMType::OS464;
 					has_128k_ = false;
 					has_fdc_ = false;
 				break;
-				case StaticAnalyser::AmstradCPCModel::CPC664:
+				case Analyser::Static::AmstradCPC::Target::Model::CPC664:
 					rom_model_ = ROMType::OS664;
 					has_128k_ = false;
 					has_fdc_ = true;
 				break;
-				case StaticAnalyser::AmstradCPCModel::CPC6128:
+				case Analyser::Static::AmstradCPC::Target::Model::CPC6128:
 					rom_model_ = ROMType::OS6128;
 					has_128k_ = true;
 					has_fdc_ = true;
@@ -901,14 +916,14 @@ class ConcreteMachine:
 			read_pointers_[3] = roms_[upper_rom_].data();
 
 			// Type whatever is required.
-			if(target.loading_command.length()) {
-				type_string(target.loading_command);
+			if(target->loading_command.length()) {
+				type_string(target->loading_command);
 			}
 
-			insert_media(target.media);
+			insert_media(target->media);
 		}
 
-		bool insert_media(const StaticAnalyser::Media &media) override final {
+		bool insert_media(const Analyser::Static::Media &media) override final {
 			// If there are any tapes supplied, use the first of them.
 			if(!media.tapes.empty()) {
 				tape_player_.set_tape(media.tapes.front());
@@ -976,8 +991,8 @@ class ConcreteMachine:
 			key_state_.clear_all_keys();
 		}
 
-		KeyboardMapper &get_keyboard_mapper() override {
-			return keyboard_mapper_;
+		KeyboardMapper *get_keyboard_mapper() override {
+			return &keyboard_mapper_;
 		}
 
 	private:

Machines/AmstradCPC/AmstradCPC.hpp

@@ -9,19 +9,12 @@
 #ifndef AmstradCPC_hpp
 #define AmstradCPC_hpp
 
-#include "../ConfigurationTarget.hpp"
-#include "../CRTMachine.hpp"
-#include "../KeyboardMachine.hpp"
-
 namespace AmstradCPC {
 
 /*!
 	Models an Amstrad CPC.
 */
-class Machine:
-	public CRTMachine::Machine,
-	public ConfigurationTarget::Machine,
-	public KeyboardMachine::Machine {
+class Machine {
 	public:
 		virtual ~Machine();
 

Machines/Atari2600/Atari2600.cpp

@@ -11,6 +11,12 @@
 #include <algorithm>
 #include <cstdio>
 
+#include "../ConfigurationTarget.hpp"
+#include "../CRTMachine.hpp"
+#include "../JoystickMachine.hpp"
+
+#include "../../Analyser/Static/Atari/Target.hpp"
+
 #include "Cartridges/Atari8k.hpp"
 #include "Cartridges/Atari16k.hpp"
 #include "Cartridges/Atari32k.hpp"
@@ -36,8 +42,18 @@ class Joystick: public Inputs::Joystick {
 		Joystick(Bus *bus, std::size_t shift, std::size_t fire_tia_input) :
 			bus_(bus), shift_(shift), fire_tia_input_(fire_tia_input) {}
 
-		void set_digital_input(DigitalInput digital_input, bool is_active) {
-			switch(digital_input) {
+		std::vector<DigitalInput> get_inputs() override {
+			return {
+				DigitalInput(DigitalInput::Up),
+				DigitalInput(DigitalInput::Down),
+				DigitalInput(DigitalInput::Left),
+				DigitalInput(DigitalInput::Right),
+				DigitalInput(DigitalInput::Fire)
+			};
+		}
+
+		void set_digital_input(const DigitalInput &digital_input, bool is_active) override {
+			switch(digital_input.type) {
 				case DigitalInput::Up:		bus_->mos6532_.update_port_input(0, 0x10 >> shift_, is_active);		break;
 				case DigitalInput::Down:	bus_->mos6532_.update_port_input(0, 0x20 >> shift_, is_active);		break;
 				case DigitalInput::Left:	bus_->mos6532_.update_port_input(0, 0x40 >> shift_, is_active);		break;
@@ -50,6 +66,8 @@ class Joystick: public Inputs::Joystick {
 					else
 						bus_->tia_input_value_[fire_tia_input_] |= 0x80;
 				break;
+
+				default: break;
 			}
 		}
 
@@ -60,11 +78,12 @@ class Joystick: public Inputs::Joystick {
 
 class ConcreteMachine:
 	public Machine,
+	public CRTMachine::Machine,
+	public ConfigurationTarget::Machine,
+	public JoystickMachine::Machine,
 	public Outputs::CRT::Delegate {
 	public:
-		ConcreteMachine() :
-			frame_record_pointer_(0),
-			is_ntsc_(true) {
+		ConcreteMachine() {
 			set_clock_rate(NTSC_clock_rate);
 		}
 
@@ -72,35 +91,38 @@ class ConcreteMachine:
 			close_output();
 		}
 
-		void configure_as_target(const StaticAnalyser::Target &target) override {
-			const std::vector<uint8_t> &rom = target.media.cartridges.front()->get_segments().front().data;
-			switch(target.atari.paging_model) {
-				case StaticAnalyser::Atari2600PagingModel::ActivisionStack:	bus_.reset(new Cartridge::Cartridge<Cartridge::ActivisionStack>(rom));	break;
-				case StaticAnalyser::Atari2600PagingModel::CBSRamPlus:		bus_.reset(new Cartridge::Cartridge<Cartridge::CBSRAMPlus>(rom));		break;
-				case StaticAnalyser::Atari2600PagingModel::CommaVid:		bus_.reset(new Cartridge::Cartridge<Cartridge::CommaVid>(rom));			break;
-				case StaticAnalyser::Atari2600PagingModel::MegaBoy:			bus_.reset(new Cartridge::Cartridge<Cartridge::MegaBoy>(rom));			break;
-				case StaticAnalyser::Atari2600PagingModel::MNetwork:		bus_.reset(new Cartridge::Cartridge<Cartridge::MNetwork>(rom));			break;
-				case StaticAnalyser::Atari2600PagingModel::None:			bus_.reset(new Cartridge::Cartridge<Cartridge::Unpaged>(rom));			break;
-				case StaticAnalyser::Atari2600PagingModel::ParkerBros:		bus_.reset(new Cartridge::Cartridge<Cartridge::ParkerBros>(rom));		break;
-				case StaticAnalyser::Atari2600PagingModel::Pitfall2:		bus_.reset(new Cartridge::Cartridge<Cartridge::Pitfall2>(rom));			break;
-				case StaticAnalyser::Atari2600PagingModel::Tigervision:		bus_.reset(new Cartridge::Cartridge<Cartridge::Tigervision>(rom));		break;
+		void configure_as_target(const Analyser::Static::Target *target) override {
+			auto *const atari_target = dynamic_cast<const Analyser::Static::Atari::Target *>(target);
+			const std::vector<uint8_t> &rom = target->media.cartridges.front()->get_segments().front().data;
 
-				case StaticAnalyser::Atari2600PagingModel::Atari8k:
-					if(target.atari.uses_superchip) {
+			using PagingModel = Analyser::Static::Atari::Target::PagingModel;
+			switch(atari_target->paging_model) {
+				case PagingModel::ActivisionStack:	bus_.reset(new Cartridge::Cartridge<Cartridge::ActivisionStack>(rom));	break;
+				case PagingModel::CBSRamPlus:		bus_.reset(new Cartridge::Cartridge<Cartridge::CBSRAMPlus>(rom));		break;
+				case PagingModel::CommaVid:			bus_.reset(new Cartridge::Cartridge<Cartridge::CommaVid>(rom));			break;
+				case PagingModel::MegaBoy:			bus_.reset(new Cartridge::Cartridge<Cartridge::MegaBoy>(rom));			break;
+				case PagingModel::MNetwork:			bus_.reset(new Cartridge::Cartridge<Cartridge::MNetwork>(rom));			break;
+				case PagingModel::None:				bus_.reset(new Cartridge::Cartridge<Cartridge::Unpaged>(rom));			break;
+				case PagingModel::ParkerBros:		bus_.reset(new Cartridge::Cartridge<Cartridge::ParkerBros>(rom));		break;
+				case PagingModel::Pitfall2:			bus_.reset(new Cartridge::Cartridge<Cartridge::Pitfall2>(rom));			break;
+				case PagingModel::Tigervision:		bus_.reset(new Cartridge::Cartridge<Cartridge::Tigervision>(rom));		break;
+
+				case PagingModel::Atari8k:
+					if(atari_target->uses_superchip) {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari8kSuperChip>(rom));
 					} else {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari8k>(rom));
 					}
 				break;
-				case StaticAnalyser::Atari2600PagingModel::Atari16k:
-					if(target.atari.uses_superchip) {
+				case PagingModel::Atari16k:
+					if(atari_target->uses_superchip) {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari16kSuperChip>(rom));
 					} else {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari16k>(rom));
 					}
 				break;
-				case StaticAnalyser::Atari2600PagingModel::Atari32k:
-					if(target.atari.uses_superchip) {
+				case PagingModel::Atari32k:
+					if(atari_target->uses_superchip) {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari32kSuperChip>(rom));
 					} else {
 						bus_.reset(new Cartridge::Cartridge<Cartridge::Atari32k>(rom));
@@ -112,7 +134,7 @@ class ConcreteMachine:
 			joysticks_.emplace_back(new Joystick(bus_.get(), 4, 1));
 		}
 
-		bool insert_media(const StaticAnalyser::Media &media) override {
+		bool insert_media(const Analyser::Static::Media &media) override {
 			return false;
 		}
 
@@ -130,6 +152,18 @@ class ConcreteMachine:
 			}
 		}
 
+		bool get_switch_is_enabled(Atari2600Switch input) override {
+			uint8_t port_input = bus_->mos6532_.get_port_input(1);
+			switch(input) {
+				case Atari2600SwitchReset:					return !!(port_input & 0x01);
+				case Atari2600SwitchSelect:					return !!(port_input & 0x02);
+				case Atari2600SwitchColour:					return !!(port_input & 0x08);
+				case Atari2600SwitchLeftPlayerDifficulty:	return !!(port_input & 0x40);
+				case Atari2600SwitchRightPlayerDifficulty:	return !!(port_input & 0x80);
+				default:									return false;
+			}
+		}
+
 		void set_reset_switch(bool state) override {
 			bus_->set_reset_line(state);
 		}
@@ -155,6 +189,7 @@ class ConcreteMachine:
 
 		void run_for(const Cycles cycles) override {
 			bus_->run_for(cycles);
+			bus_->apply_confidence(confidence_counter_);
 		}
 
 		// to satisfy Outputs::CRT::Delegate
@@ -195,6 +230,10 @@ class ConcreteMachine:
 			}
 		}
 
+		float get_confidence() override {
+			return confidence_counter_.get_confidence();
+		}
+
 	private:
 		// the bus
 		std::unique_ptr<Bus> bus_;
@@ -206,9 +245,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<std::unique_ptr<Inputs::Joystick>> joysticks_;
+
+		// a confidence counter
+		Analyser::Dynamic::ConfidenceCounter confidence_counter_;
 };
 
 }

Machines/Atari2600/Atari2600.hpp

@@ -9,10 +9,6 @@
 #ifndef Atari2600_cpp
 #define Atari2600_cpp
 
-#include "../ConfigurationTarget.hpp"
-#include "../CRTMachine.hpp"
-#include "../JoystickMachine.hpp"
-
 #include "Atari2600Inputs.h"
 
 namespace Atari2600 {
@@ -20,10 +16,7 @@ namespace Atari2600 {
 /*!
 	Models an Atari 2600.
 */
-class Machine:
-	public CRTMachine::Machine,
-	public ConfigurationTarget::Machine,
-	public JoystickMachine::Machine {
+class Machine {
 	public:
 		virtual ~Machine();
 
@@ -33,6 +26,9 @@ class Machine:
 		/// Sets the switch @c input to @c state.
 		virtual void set_switch_is_enabled(Atari2600Switch input, bool state) = 0;
 
+		/// Gets the state of switch @c input.
+		virtual bool get_switch_is_enabled(Atari2600Switch input) = 0;
+
 		// Presses or releases the reset button.
 		virtual void set_reset_switch(bool state) = 0;
 };

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,14 @@ 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 ~Bus() {
+			audio_queue_.flush();
+		}
 
 		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 +43,7 @@ class Bus {
 		Outputs::Speaker::LowpassSpeaker<TIASound> speaker_;
 
 		// joystick state
-		uint8_t tia_input_value_[2];
+		uint8_t tia_input_value_[2] = {0xff, 0xff};
 
 	protected:
 		// speaker backlog accumlation counter

Machines/Atari2600/Cartridges/Cartridge.hpp

@@ -39,7 +39,23 @@ template<class T> 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 T> 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 T> class Cartridge:
 
 	private:
 		T bus_extender_;
+		int horizontal_counter_resets_ = 0;
+		Cycles cycle_count_;
+
 };
 
 }

Machines/Atari2600/TIA.cpp

@@ -25,7 +25,7 @@ namespace {
 TIA::TIA(bool create_crt) {
 	if(create_crt) {
 		crt_.reset(new Outputs::CRT::CRT(cycles_per_line * 2 - 1, 1, Outputs::CRT::DisplayType::NTSC60, 1));
-		crt_->set_output_device(Outputs::CRT::OutputDevice::Television);
+		crt_->set_video_signal(Outputs::CRT::VideoSignal::Composite);
 		set_output_mode(OutputMode::NTSC);
 	}
 
@@ -123,20 +123,20 @@ void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) {
 	Outputs::CRT::DisplayType display_type;
 
 	if(output_mode == OutputMode::NTSC) {
-		crt_->set_composite_sampling_function(
-			"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
+		crt_->set_svideo_sampling_function(
+			"vec2 svideo_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase)"
 			"{"
 				"uint c = texture(texID, coordinate).r;"
 				"uint y = c & 14u;"
 				"uint iPhase = (c >> 4);"
 
 				"float phaseOffset = 6.283185308 * float(iPhase) / 13.0 + 5.074880441076923;"
-				"return mix(float(y) / 14.0, step(1, iPhase) * cos(phase + phaseOffset), amplitude);"
+				"return vec2(float(y) / 14.0, step(1, iPhase) * cos(phase + phaseOffset));"
 			"}");
 		display_type = Outputs::CRT::DisplayType::NTSC60;
 	} else {
-		crt_->set_composite_sampling_function(
-			"float composite_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase, float amplitude)"
+		crt_->set_svideo_sampling_function(
+			"vec2 svideo_sample(usampler2D texID, vec2 coordinate, vec2 iCoordinate, float phase)"
 			"{"
 				"uint c = texture(texID, coordinate).r;"
 				"uint y = c & 14u;"
@@ -145,10 +145,12 @@ void TIA::set_output_mode(Atari2600::TIA::OutputMode output_mode) {
 				"uint direction = iPhase & 1u;"
 				"float phaseOffset = float(7u - direction) + (float(direction) - 0.5) * 2.0 * float(iPhase >> 1);"
 				"phaseOffset *= 6.283185308 / 12.0;"
-				"return mix(float(y) / 14.0, step(4, (iPhase + 2u) & 15u) * cos(phase + phaseOffset), amplitude);"
+				"return vec2(float(y) / 14.0, step(4, (iPhase + 2u) & 15u) * cos(phase + phaseOffset));"
 			"}");
 		display_type = Outputs::CRT::DisplayType::PAL50;
 	}
+	crt_->set_video_signal(Outputs::CRT::VideoSignal::Composite);
+
 	// line number of cycles in a line of video is one less than twice the number of clock cycles per line; the Atari
 	// outputs 228 colour cycles of material per line when an NTSC line 227.5. Since all clock numbers will be doubled
 	// later, cycles_per_line * 2 - 1 is therefore the real length of an NTSC line, even though we're going to supply

Machines/Atari2600/TIASound.cpp

@@ -119,7 +119,11 @@ void Atari2600::TIASound::get_samples(std::size_t number_of_samples, int16_t *ta
 				break;
 			}
 
-			target[c] += volume_[channel] * 1024 * level;
+			target[c] += (volume_[channel] * per_channel_volume_ * level) >> 4;
 		}
 	}
 }
+
+void Atari2600::TIASound::set_sample_volume_range(std::int16_t range) {
+	per_channel_volume_ = range / 2;
+}

Machines/Atari2600/TIASound.hpp

@@ -26,7 +26,9 @@ class TIASound: public Outputs::Speaker::SampleSource {
 		void set_divider(int channel, uint8_t divider);
 		void set_control(int channel, uint8_t control);
 
+		// To satisfy ::SampleSource.
 		void get_samples(std::size_t number_of_samples, int16_t *target);
+		void set_sample_volume_range(std::int16_t range);
 
 	private:
 		Concurrency::DeferringAsyncTaskQueue &audio_queue_;
@@ -41,6 +43,7 @@ class TIASound: public Outputs::Speaker::SampleSource {
 		int output_state_[2];
 
 		int divider_counter_[2];
+		int16_t per_channel_volume_ = 0;
 };
 
 }

Machines/CRTMachine.hpp

@@ -12,8 +12,13 @@
 #include "../Outputs/CRT/CRT.hpp"
 #include "../Outputs/Speaker/Speaker.hpp"
 #include "../ClockReceiver/ClockReceiver.hpp"
+#include "../ClockReceiver/TimeTypes.hpp"
 #include "ROMMachine.hpp"
 
+#include "../Configurable/StandardOptions.hpp"
+
+#include <cmath>
+
 namespace CRTMachine {
 
 /*!
@@ -41,41 +46,58 @@ class Machine: public ROMMachine::Machine {
 		/// @returns The speaker that receives this machine's output, or @c nullptr if this machine is mute.
 		virtual Outputs::Speaker::Speaker *get_speaker() = 0;
 
+		/// @returns The confidence that this machine is running content it understands.
+		virtual float get_confidence() { return 0.5f; }
+		virtual void print_type() {}
+
+		/// Runs the machine for @c duration seconds.
+		virtual void run_for(Time::Seconds duration) {
+			const double cycles = (duration * clock_rate_) + clock_conversion_error_;
+			clock_conversion_error_ = std::fmod(cycles, 1.0);
+			run_for(Cycles(static_cast<int>(cycles)));
+		}
+
+	protected:
 		/// Runs the machine for @c cycles.
 		virtual void run_for(const Cycles cycles) = 0;
-
-		// TODO: sever the clock-rate stuff.
+		void set_clock_rate(double clock_rate) {
+			clock_rate_ = clock_rate;
+		}
 		double get_clock_rate() {
 			return clock_rate_;
 		}
-		bool get_clock_is_unlimited() {
-			return clock_is_unlimited_;
-		}
-		class Delegate {
-			public:
-				virtual void machine_did_change_clock_rate(Machine *machine) = 0;
-				virtual void machine_did_change_clock_is_unlimited(Machine *machine) = 0;
-		};
-		void set_delegate(Delegate *delegate) { delegate_ = delegate; }
 
-	protected:
-		void set_clock_rate(double clock_rate) {
-			if(clock_rate_ != clock_rate) {
-				clock_rate_ = clock_rate;
-				if(delegate_) delegate_->machine_did_change_clock_rate(this);
+		/*!
+			Maps from Configurable::Display to Outputs::CRT::VideoSignal and calls
+			@c set_video_signal with the result.
+		*/
+		void set_video_signal_configurable(Configurable::Display type) {
+			Outputs::CRT::VideoSignal signal;
+			switch(type) {
+				default:
+				case Configurable::Display::RGB:
+					signal = Outputs::CRT::VideoSignal::RGB;
+				break;
+				case Configurable::Display::SVideo:
+					signal = Outputs::CRT::VideoSignal::SVideo;
+				break;
+				case Configurable::Display::Composite:
+					signal = Outputs::CRT::VideoSignal::Composite;
+				break;
 			}
+			set_video_signal(signal);
 		}
-		void set_clock_is_unlimited(bool clock_is_unlimited) {
-			if(clock_is_unlimited != clock_is_unlimited_) {
-				clock_is_unlimited_ = clock_is_unlimited;
-				if(delegate_) delegate_->machine_did_change_clock_is_unlimited(this);
-			}
+
+		/*!
+			Forwards the video signal to the CRT returned by get_crt().
+		*/
+		virtual void set_video_signal(Outputs::CRT::VideoSignal video_signal) {
+			get_crt()->set_video_signal(video_signal);
 		}
 
 	private:
-		Delegate *delegate_ = nullptr;
 		double clock_rate_ = 1.0;
-		bool clock_is_unlimited_ = false;
+		double clock_conversion_error_ = 0.0;
 };
 
 }

Machines/ColecoVision/ColecoVision.cpp

@@ -0,0 +1,405 @@
+//
+//  ColecoVision.cpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#include "ColecoVision.hpp"
+
+#include "../../Processors/Z80/Z80.hpp"
+
+#include "../../Components/9918/9918.hpp"
+#include "../../Components/AY38910/AY38910.hpp"	// For the Super Game Module.
+#include "../../Components/SN76489/SN76489.hpp"
+
+#include "../ConfigurationTarget.hpp"
+#include "../CRTMachine.hpp"
+#include "../JoystickMachine.hpp"
+
+#include "../../ClockReceiver/ForceInline.hpp"
+
+#include "../../Outputs/Speaker/Implementation/CompoundSource.hpp"
+#include "../../Outputs/Speaker/Implementation/LowpassSpeaker.hpp"
+
+#include "../../Analyser/Dynamic/ConfidenceCounter.hpp"
+
+namespace {
+const int sn76489_divider = 2;
+}
+
+namespace Coleco {
+namespace Vision {
+
+class Joystick: public Inputs::Joystick {
+	public:
+		std::vector<DigitalInput> get_inputs() override {
+			return {
+				DigitalInput(DigitalInput::Up),
+				DigitalInput(DigitalInput::Down),
+				DigitalInput(DigitalInput::Left),
+				DigitalInput(DigitalInput::Right),
+
+				DigitalInput(DigitalInput::Fire, 0),
+				DigitalInput(DigitalInput::Fire, 1),
+
+				DigitalInput('0'),	DigitalInput('1'),	DigitalInput('2'),
+				DigitalInput('3'),	DigitalInput('4'),	DigitalInput('5'),
+				DigitalInput('6'),	DigitalInput('7'),	DigitalInput('8'),
+				DigitalInput('9'),	DigitalInput('*'),	DigitalInput('#'),
+			};
+		}
+
+		void set_digital_input(const DigitalInput &digital_input, bool is_active) override {
+			switch(digital_input.type) {
+				default: return;
+
+				case DigitalInput::Key:
+					if(!is_active) keypad_ |= 0xf;
+					else {
+						uint8_t mask = 0xf;
+						switch(digital_input.info.key.symbol) {
+							case '8':	mask = 0x1;		break;
+							case '4':	mask = 0x2;		break;
+							case '5':	mask = 0x3;		break;
+							case '7':	mask = 0x5;		break;
+							case '#':	mask = 0x6;		break;
+							case '2':	mask = 0x7;		break;
+							case '*':	mask = 0x9;		break;
+							case '0':	mask = 0xa;		break;
+							case '9':	mask = 0xb;		break;
+							case '3':	mask = 0xc;		break;
+							case '1':	mask = 0xd;		break;
+							case '6':	mask = 0xe;		break;
+							default: break;
+						}
+						keypad_ = (keypad_ & 0xf0) | mask;
+					}
+				break;
+
+				case DigitalInput::Up: 		if(is_active) direction_ &= ~0x01; else direction_ |= 0x01;	break;
+				case DigitalInput::Right:	if(is_active) direction_ &= ~0x02; else direction_ |= 0x02;	break;
+				case DigitalInput::Down:	if(is_active) direction_ &= ~0x04; else direction_ |= 0x04;	break;
+				case DigitalInput::Left:	if(is_active) direction_ &= ~0x08; else direction_ |= 0x08;	break;
+				case DigitalInput::Fire:
+					switch(digital_input.info.control.index) {
+						default: break;
+						case 0:	if(is_active) direction_ &= ~0x40; else direction_ |= 0x40;	break;
+						case 1:	if(is_active) keypad_ &= ~0x40; else keypad_ |= 0x40;		break;
+					}
+				break;
+			}
+		}
+
+		uint8_t get_direction_input() {
+			return direction_;
+		}
+
+		uint8_t get_keypad_input() {
+			return keypad_;
+		}
+
+	private:
+		uint8_t direction_ = 0xff;
+		uint8_t keypad_ = 0xff;
+};
+
+class ConcreteMachine:
+	public Machine,
+	public CPU::Z80::BusHandler,
+	public CRTMachine::Machine,
+	public ConfigurationTarget::Machine,
+	public JoystickMachine::Machine {
+
+	public:
+		ConcreteMachine() :
+			z80_(*this),
+			sn76489_(TI::SN76489::Personality::SN76489, audio_queue_, sn76489_divider),
+			ay_(audio_queue_),
+			mixer_(sn76489_, ay_),
+			speaker_(mixer_) {
+			speaker_.set_input_rate(3579545.0f / static_cast<float>(sn76489_divider));
+			set_clock_rate(3579545);
+			joysticks_.emplace_back(new Joystick);
+			joysticks_.emplace_back(new Joystick);
+		}
+
+		~ConcreteMachine() {
+			audio_queue_.flush();
+		}
+
+		std::vector<std::unique_ptr<Inputs::Joystick>> &get_joysticks() override {
+			return joysticks_;
+		}
+
+		void setup_output(float aspect_ratio) override {
+			vdp_.reset(new TI::TMS9918(TI::TMS9918::TMS9918A));
+			get_crt()->set_video_signal(Outputs::CRT::VideoSignal::Composite);
+		}
+
+		void close_output() override {
+			vdp_.reset();
+		}
+
+		Outputs::CRT::CRT *get_crt() override {
+			return vdp_->get_crt();
+		}
+
+		Outputs::Speaker::Speaker *get_speaker() override {
+			return &speaker_;
+		}
+
+		void run_for(const Cycles cycles) override {
+			z80_.run_for(cycles);
+		}
+
+		void configure_as_target(const Analyser::Static::Target *target) override {
+			// Insert the media.
+			insert_media(target->media);
+		}
+
+		bool insert_media(const Analyser::Static::Media &media) override {
+			if(!media.cartridges.empty()) {
+				const auto &segment = media.cartridges.front()->get_segments().front();
+				cartridge_ = segment.data;
+				if(cartridge_.size() >= 32768)
+					cartridge_address_limit_ = 0xffff;
+				else
+					cartridge_address_limit_ = static_cast<uint16_t>(0x8000 + cartridge_.size() - 1);
+
+				if(cartridge_.size() > 32768) {
+					cartridge_pages_[0] = &cartridge_[cartridge_.size() - 16384];
+					cartridge_pages_[1] = cartridge_.data();
+					is_megacart_ = true;
+				} else {
+					cartridge_pages_[0] = cartridge_.data();
+					cartridge_pages_[1] = cartridge_.data() + 16384;
+					is_megacart_ = false;
+				}
+			}
+
+			return true;
+		}
+
+		// Obtains the system ROMs.
+		bool set_rom_fetcher(const std::function<std::vector<std::unique_ptr<std::vector<uint8_t>>>(const std::string &machine, const std::vector<std::string> &names)> &roms_with_names) override {
+			auto roms = roms_with_names(
+				"ColecoVision",
+				{ "coleco.rom" });
+
+			if(!roms[0]) return false;
+
+			bios_ = *roms[0];
+			bios_.resize(8192);
+
+			return true;
+		}
+
+		// MARK: Z80::BusHandler
+		forceinline HalfCycles perform_machine_cycle(const CPU::Z80::PartialMachineCycle &cycle) {
+			time_since_vdp_update_ += cycle.length;
+			time_since_sn76489_update_ += cycle.length;
+
+			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) {
+							*cycle.value = super_game_module_.ram[address];
+						} else {
+							*cycle.value = bios_[address];
+						}
+					} else if(super_game_module_.replace_ram && address < 0x8000) {
+						*cycle.value = super_game_module_.ram[address];
+					} else if(address >= 0x6000 && address < 0x8000) {
+						*cycle.value = ram_[address & 1023];
+					} else if(address >= 0x8000 && address <= cartridge_address_limit_) {
+						if(is_megacart_ && address >= 0xffc0) {
+							page_megacart(address);
+						}
+						*cycle.value = cartridge_pages_[(address >> 14)&1][address&0x3fff];
+					} else {
+						*cycle.value = 0xff;
+					}
+				break;
+
+				case CPU::Z80::PartialMachineCycle::Write:
+					if(super_game_module_.replace_bios && address < 0x2000) {
+						super_game_module_.ram[address] = *cycle.value;
+					} else if(super_game_module_.replace_ram && address >= 0x2000 && address < 0x8000) {
+						super_game_module_.ram[address] = *cycle.value;
+					} else if(address >= 0x6000 && address < 0x8000) {
+						ram_[address & 1023] = *cycle.value;
+					} else if(is_megacart_ && address >= 0xffc0) {
+						page_megacart(address);
+					}
+				break;
+
+				case CPU::Z80::PartialMachineCycle::Input:
+					switch((address >> 5) & 7) {
+						case 5:
+							update_video();
+							*cycle.value = vdp_->get_register(address);
+							z80_.set_non_maskable_interrupt_line(vdp_->get_interrupt_line());
+							time_until_interrupt_ = vdp_->get_time_until_interrupt();
+						break;
+
+						case 7: {
+							const std::size_t joystick_id = (address&2) >> 1;
+							Joystick *joystick = static_cast<Joystick *>(joysticks_[joystick_id].get());
+							if(joysticks_in_keypad_mode_) {
+								*cycle.value = joystick->get_keypad_input();
+							} 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:
+							switch(address&0xff) {
+								default: *cycle.value = 0xff; break;
+								case 0x52:
+									// Read AY data.
+									update_audio();
+									ay_.set_control_lines(GI::AY38910::ControlLines(GI::AY38910::BC2 | GI::AY38910::BC1));
+									*cycle.value = ay_.get_data_output();
+									ay_.set_control_lines(GI::AY38910::ControlLines(0));
+								break;
+							}
+						break;
+					}
+				break;
+
+				case CPU::Z80::PartialMachineCycle::Output: {
+					const int eighth = (address >> 5) & 7;
+					switch(eighth) {
+						case 4: case 6:
+							joysticks_in_keypad_mode_ = eighth == 4;
+						break;
+
+						case 5:
+							update_video();
+							vdp_->set_register(address, *cycle.value);
+							z80_.set_non_maskable_interrupt_line(vdp_->get_interrupt_line());
+							time_until_interrupt_ = vdp_->get_time_until_interrupt();
+						break;
+
+						case 7:
+							update_audio();
+							sn76489_.set_register(*cycle.value);
+						break;
+
+						default:
+							// Catch Super Game Module accesses; it decodes more thoroughly.
+							switch(address&0xff) {
+								default: break;
+								case 0x7f:
+									super_game_module_.replace_bios = !((*cycle.value)&0x2);
+								break;
+								case 0x50:
+									// Set AY address.
+									update_audio();
+									ay_.set_control_lines(GI::AY38910::BC1);
+									ay_.set_data_input(*cycle.value);
+									ay_.set_control_lines(GI::AY38910::ControlLines(0));
+								break;
+								case 0x51:
+									// Set AY data.
+									update_audio();
+									ay_.set_control_lines(GI::AY38910::ControlLines(GI::AY38910::BC2 | GI::AY38910::BDIR));
+									ay_.set_data_input(*cycle.value);
+									ay_.set_control_lines(GI::AY38910::ControlLines(0));
+								break;
+								case 0x53:
+									super_game_module_.replace_ram = !!((*cycle.value)&0x1);
+								break;
+							}
+						break;
+					}
+				} break;
+
+				default: break;
+			}
+
+			if(time_until_interrupt_ > 0) {
+				time_until_interrupt_ -= cycle.length;
+				if(time_until_interrupt_ <= HalfCycles(0)) {
+					z80_.set_non_maskable_interrupt_line(true, time_until_interrupt_);
+				}
+			}
+
+			return HalfCycles(0);
+		}
+
+		void flush() {
+			update_video();
+			update_audio();
+			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<std::size_t>(address&63) << 14) % cartridge_.size();
+			cartridge_pages_[1] = &cartridge_[selected_start];
+		}
+		inline void update_audio() {
+			speaker_.run_for(audio_queue_, time_since_sn76489_update_.divide_cycles(Cycles(sn76489_divider)));
+		}
+		inline void update_video() {
+			vdp_->run_for(time_since_vdp_update_.flush());
+		}
+
+		CPU::Z80::Processor<ConcreteMachine, false, false> z80_;
+		std::unique_ptr<TI::TMS9918> vdp_;
+
+		Concurrency::DeferringAsyncTaskQueue audio_queue_;
+		TI::SN76489 sn76489_;
+		GI::AY38910::AY38910 ay_;
+		Outputs::Speaker::CompoundSource<TI::SN76489, GI::AY38910::AY38910> mixer_;
+		Outputs::Speaker::LowpassSpeaker<Outputs::Speaker::CompoundSource<TI::SN76489, GI::AY38910::AY38910>> speaker_;
+
+		std::vector<uint8_t> bios_;
+		std::vector<uint8_t> cartridge_;
+		uint8_t *cartridge_pages_[2];
+		uint8_t ram_[1024];
+		bool is_megacart_ = false;
+		uint16_t cartridge_address_limit_ = 0;
+		struct {
+			bool replace_bios = false;
+			bool replace_ram = false;
+			uint8_t ram[32768];
+		} super_game_module_;
+
+		std::vector<std::unique_ptr<Inputs::Joystick>> joysticks_;
+		bool joysticks_in_keypad_mode_ = false;
+
+		HalfCycles time_since_vdp_update_;
+		HalfCycles time_since_sn76489_update_;
+		HalfCycles time_until_interrupt_;
+
+		Analyser::Dynamic::ConfidenceCounter confidence_counter_;
+		int pc_zero_accesses_ = 0;
+};
+
+}
+}
+
+using namespace Coleco::Vision;
+
+Machine *Machine::ColecoVision() {
+	return new ConcreteMachine;
+}
+
+Machine::~Machine() {}

Machines/ColecoVision/ColecoVision.hpp

@@ -0,0 +1,24 @@
+//
+//  ColecoVision.hpp
+//  Clock Signal
+//
+//  Created by Thomas Harte on 23/02/2018.
+//  Copyright © 2018 Thomas Harte. All rights reserved.
+//
+
+#ifndef ColecoVision_hpp
+#define ColecoVision_hpp
+
+namespace Coleco {
+namespace Vision {
+
+class Machine {
+	public:
+		virtual ~Machine();
+		static Machine *ColecoVision();
+};
+
+}
+}
+
+#endif /* ColecoVision_hpp */

Machines/Commodore/1540/Implementation/C1540.cpp

@@ -165,14 +165,15 @@ void SerialPortVIA::set_port_output(MOS::MOS6522::Port port, uint8_t value, uint
 			attention_acknowledge_level_ = !(value&0x10);
 			data_level_output_ = (value&0x02);
 
-			serialPort->set_output(::Commodore::Serial::Line::Clock, (::Commodore::Serial::LineLevel)!(value&0x08));
+//			printf("[C1540] %s output is %s\n", StringForLine(::Commodore::Serial::Line::Clock), value ? "high" : "low");
+			serialPort->set_output(::Commodore::Serial::Line::Clock, static_cast<::Commodore::Serial::LineLevel>(!(value&0x08)));
 			update_data_line();
 		}
 	}
 }
 
 void SerialPortVIA::set_serial_line_state(::Commodore::Serial::Line line, bool value) {
-//	printf("[C1540] %s is %s\n", StringForLine(line), value ? "high" : "low");
+//	printf("[C1540] %s input is %s\n", StringForLine(line), value ? "high" : "low");
 
 	switch(line) {
 		default: break;
@@ -194,9 +195,10 @@ void SerialPortVIA::set_serial_port(const std::shared_ptr<::Commodore::Serial::P
 void SerialPortVIA::update_data_line() {
 	std::shared_ptr<::Commodore::Serial::Port> serialPort = serial_port_.lock();
 	if(serialPort) {
+//		printf("[C1540] %s output is %s\n", StringForLine(::Commodore::Serial::Line::Data), (!data_level_output_ && (attention_level_input_ != attention_acknowledge_level_)) ? "high" : "low");
 		// "ATN (Attention) is an input on pin 3 of P2 and P3 that is sensed at PB7 and CA1 of UC3 after being inverted by UA1"
 		serialPort->set_output(::Commodore::Serial::Line::Data,
-			(::Commodore::Serial::LineLevel)(!data_level_output_ && (attention_level_input_ != attention_acknowledge_level_)));
+			static_cast<::Commodore::Serial::LineLevel>(!data_level_output_ && (attention_level_input_ != attention_acknowledge_level_)));
 	}
 }