From e235a45abb24fd6b2b31ff073c1378feb980435c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 4 Aug 2020 18:22:14 -0400
Subject: [PATCH 001/131] Breaks all output.

... by switching out NSOpenGLView for MKLView with no drawing infrastructure yet in place.
---
 Machines/MasterSystem/MasterSystem.cpp        |  10 +-
 .../Clock Signal.xcodeproj/project.pbxproj    |  26 ++-
 .../xcschemes/Clock Signal.xcscheme           |   2 +-
 .../Base.lproj/MachineDocument.xib            |   8 +-
 .../ClockSignal-Bridging-Header.h             |   2 +-
 .../Documents/MachineDocument.swift           |  61 +++----
 .../Mac/Clock Signal/Machine/CSMachine.h      |   8 +-
 .../Mac/Clock Signal/Machine/CSMachine.mm     |  43 +++--
 .../Clock Signal/ScanTarget/CSScanTarget.h    |  18 ++
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  28 ++++
 .../{CSOpenGLView.h => CSScanTargetView.h}    | 120 +++++++-------
 .../{CSOpenGLView.m => CSScanTargetView.m}    | 156 +++++++++---------
 12 files changed, 272 insertions(+), 210 deletions(-)
 create mode 100644 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h
 create mode 100644 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
 rename OSBindings/Mac/Clock Signal/Views/{CSOpenGLView.h => CSScanTargetView.h} (72%)
 rename OSBindings/Mac/Clock Signal/Views/{CSOpenGLView.m => CSScanTargetView.m} (74%)

diff --git a/Machines/MasterSystem/MasterSystem.cpp b/Machines/MasterSystem/MasterSystem.cpp
index f43e999ea..9c0bf61e4 100644
--- a/Machines/MasterSystem/MasterSystem.cpp
+++ b/Machines/MasterSystem/MasterSystem.cpp
@@ -120,11 +120,11 @@ class ConcreteMachine:
 			if(!target.media.cartridges.empty()) {
 				cartridge_ = target.media.cartridges[0]->get_segments()[0].data;
 			}
-			if(cartridge_.size() < 48*1024) {
-				std::size_t new_space = 48*1024 - cartridge_.size();
-				cartridge_.resize(48*1024);
-				memset(&cartridge_[48*1024 - new_space], 0xff, new_space);
-			}
+//			if(cartridge_.size() < 48*1024) {
+//				std::size_t new_space = 48*1024 - cartridge_.size();
+//				cartridge_.resize(48*1024);
+//				memset(&cartridge_[48*1024 - new_space], 0xff, new_space);
+//			}
 
 			if(paging_scheme_ == Target::PagingScheme::Codemasters) {
 				// The Codemasters cartridges start with pages 0, 1 and 0 again initially visible.
diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 9f491a899..5b14a58d8 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -155,6 +155,8 @@
 		4B1D08061E0F7A1100763741 /* TimeTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B1D08051E0F7A1100763741 /* TimeTests.mm */; };
 		4B1E85811D176468001EF87D /* 6532Tests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B1E85801D176468001EF87D /* 6532Tests.swift */; };
 		4B1EDB451E39A0AC009D6819 /* chip.png in Resources */ = {isa = PBXBuildFile; fileRef = 4B1EDB431E39A0AC009D6819 /* chip.png */; };
+		4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B228CD424D773B30077EF25 /* CSScanTarget.mm */; };
+		4B228CD924DA12C60077EF25 /* CSScanTargetView.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B228CD824DA12C60077EF25 /* CSScanTargetView.m */; };
 		4B2530F4244E6774007980BF /* fm.json in Resources */ = {isa = PBXBuildFile; fileRef = 4B2530F3244E6773007980BF /* fm.json */; };
 		4B2A332D1DB86821002876E3 /* OricOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B2A332B1DB86821002876E3 /* OricOptions.xib */; };
 		4B2A539F1D117D36003C6002 /* CSAudioQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B2A53911D117D36003C6002 /* CSAudioQueue.m */; };
@@ -215,7 +217,6 @@
 		4B54C0C51F8D91D90050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0C41F8D91D90050900F /* Keyboard.cpp */; };
 		4B54C0C81F8D91E50050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0C61F8D91E50050900F /* Keyboard.cpp */; };
 		4B54C0CB1F8D92590050900F /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B54C0CA1F8D92580050900F /* Keyboard.cpp */; };
-		4B55CE5D1C3B7D6F0093A61B /* CSOpenGLView.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B55CE5C1C3B7D6F0093A61B /* CSOpenGLView.m */; };
 		4B55CE5F1C3B7D960093A61B /* MachineDocument.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B55CE5E1C3B7D960093A61B /* MachineDocument.swift */; };
 		4B55DD8320DF06680043F2E5 /* MachinePicker.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B55DD8020DF06680043F2E5 /* MachinePicker.swift */; };
 		4B55DD8420DF06680043F2E5 /* MachinePicker.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B55DD8120DF06680043F2E5 /* MachinePicker.xib */; };
@@ -1004,6 +1005,10 @@
 		4B1E857B1D174DEC001EF87D /* 6532.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = 6532.hpp; sourceTree = "<group>"; };
 		4B1E85801D176468001EF87D /* 6532Tests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = 6532Tests.swift; sourceTree = "<group>"; };
 		4B1EDB431E39A0AC009D6819 /* chip.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = chip.png; sourceTree = "<group>"; };
+		4B228CD424D773B30077EF25 /* CSScanTarget.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CSScanTarget.mm; sourceTree = "<group>"; };
+		4B228CD624D773CA0077EF25 /* CSScanTarget.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CSScanTarget.h; sourceTree = "<group>"; };
+		4B228CD724DA12C50077EF25 /* CSScanTargetView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSScanTargetView.h; sourceTree = "<group>"; };
+		4B228CD824DA12C60077EF25 /* CSScanTargetView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSScanTargetView.m; sourceTree = "<group>"; };
 		4B24095A1C45DF85004DA684 /* Stepper.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Stepper.hpp; sourceTree = "<group>"; };
 		4B2530F3244E6773007980BF /* fm.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = fm.json; sourceTree = "<group>"; };
 		4B2A332C1DB86821002876E3 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = "Clock Signal/Base.lproj/OricOptions.xib"; sourceTree = SOURCE_ROOT; };
@@ -1129,8 +1134,6 @@
 		4B54C0C71F8D91E50050900F /* Keyboard.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Keyboard.hpp; path = Electron/Keyboard.hpp; sourceTree = "<group>"; };
 		4B54C0C91F8D92580050900F /* Keyboard.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; name = Keyboard.hpp; path = ZX8081/Keyboard.hpp; sourceTree = "<group>"; };
 		4B54C0CA1F8D92580050900F /* Keyboard.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Keyboard.cpp; path = ZX8081/Keyboard.cpp; sourceTree = "<group>"; };
-		4B55CE5B1C3B7D6F0093A61B /* CSOpenGLView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSOpenGLView.h; sourceTree = "<group>"; };
-		4B55CE5C1C3B7D6F0093A61B /* CSOpenGLView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSOpenGLView.m; sourceTree = "<group>"; };
 		4B55CE5E1C3B7D960093A61B /* MachineDocument.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MachineDocument.swift; sourceTree = "<group>"; };
 		4B55DD8020DF06680043F2E5 /* MachinePicker.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = MachinePicker.swift; sourceTree = "<group>"; };
 		4B55DD8220DF06680043F2E5 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MachinePicker.xib; sourceTree = "<group>"; };
@@ -2060,6 +2063,15 @@
 			path = Icons;
 			sourceTree = "<group>";
 		};
+		4B228CD324D773B30077EF25 /* ScanTarget */ = {
+			isa = PBXGroup;
+			children = (
+				4B228CD424D773B30077EF25 /* CSScanTarget.mm */,
+				4B228CD624D773CA0077EF25 /* CSScanTarget.h */,
+			);
+			path = ScanTarget;
+			sourceTree = "<group>";
+		};
 		4B2409591C45DF85004DA684 /* SignalProcessing */ = {
 			isa = PBXGroup;
 			children = (
@@ -2471,8 +2483,8 @@
 		4B55CE5A1C3B7D6F0093A61B /* Views */ = {
 			isa = PBXGroup;
 			children = (
-				4B55CE5B1C3B7D6F0093A61B /* CSOpenGLView.h */,
-				4B55CE5C1C3B7D6F0093A61B /* CSOpenGLView.m */,
+				4B228CD724DA12C50077EF25 /* CSScanTargetView.h */,
+				4B228CD824DA12C60077EF25 /* CSScanTargetView.m */,
 			);
 			path = Views;
 			sourceTree = "<group>";
@@ -3371,6 +3383,7 @@
 				4BB73EAA1B587A5100552FC2 /* MainMenu.xib */,
 				4BE5F85A1C3E1C2500C43F01 /* Resources */,
 				4BDA00DB22E60EE900AC3CD0 /* ROMRequester */,
+				4B228CD324D773B30077EF25 /* ScanTarget */,
 				4B55CE5A1C3B7D6F0093A61B /* Views */,
 			);
 			path = "Clock Signal";
@@ -4574,6 +4587,7 @@
 				4B0E04EA1FC9E5DA00F43484 /* CAS.cpp in Sources */,
 				4B7A90ED20410A85008514A2 /* StaticAnalyser.cpp in Sources */,
 				4B58601E1F806AB200AEE2E3 /* MFMSectorDump.cpp in Sources */,
+				4B228CD924DA12C60077EF25 /* CSScanTargetView.m in Sources */,
 				4B6AAEAD230E40250078E864 /* Target.cpp in Sources */,
 				4B448E841F1C4C480009ABD6 /* PulseQueuedTape.cpp in Sources */,
 				4B0E61071FF34737002A9DBD /* MSX.cpp in Sources */,
@@ -4673,6 +4687,7 @@
 				4BA61EB01D91515900B3C876 /* NSData+StdVector.mm in Sources */,
 				4BDA00E022E644AF00AC3CD0 /* CSROMReceiverView.m in Sources */,
 				4BD191F42191180E0042E144 /* ScanTarget.cpp in Sources */,
+				4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */,
 				4BCD634922D6756400F567F1 /* MacintoshDoubleDensityDrive.cpp in Sources */,
 				4B0F94FE208C1A1600FE41D9 /* NIB.cpp in Sources */,
 				4B89452A201967B4007DE474 /* File.cpp in Sources */,
@@ -4699,7 +4714,6 @@
 				4B0E04FA1FC9FA3100F43484 /* 9918.cpp in Sources */,
 				4B69FB3D1C4D908A00B5F0AA /* Tape.cpp in Sources */,
 				4B4518841F75E91A00926311 /* UnformattedTrack.cpp in Sources */,
-				4B55CE5D1C3B7D6F0093A61B /* CSOpenGLView.m in Sources */,
 				4B65086022F4CF8D009C1100 /* Keyboard.cpp in Sources */,
 				4B894528201967B4007DE474 /* Disk.cpp in Sources */,
 				4BBB70A4202011C2002FE009 /* MultiMediaTarget.cpp in Sources */,
diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index a99eb0a5d..63be2c037 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
@@ -67,7 +67,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Release"
+      buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       enableASanStackUseAfterReturn = "YES"
diff --git a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib
index 8d955fcaf..b1eeadf5a 100644
--- a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
+++ b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
@@ -1,14 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="15705" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
+<document type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="3.0" toolsVersion="16097.2" targetRuntime="MacOSX.Cocoa" propertyAccessControl="none" useAutolayout="YES" customObjectInstantitationMethod="direct">
     <dependencies>
         <deployment identifier="macosx"/>
-        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="15705"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.CocoaPlugin" version="16097.2"/>
         <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
     </dependencies>
     <objects>
         <customObject id="-2" userLabel="File's Owner" customClass="MachineDocument" customModule="Clock_Signal" customModuleProvider="target">
             <connections>
-                <outlet property="openGLView" destination="DEG-fq-cjd" id="Gxs-2u-n7B"/>
+                <outlet property="scanTargetView" destination="DEG-fq-cjd" id="5aX-3R-eXQ"/>
                 <outlet property="volumeSlider" destination="zaz-lB-Iyt" id="flY-Th-oG4"/>
                 <outlet property="volumeView" destination="4ap-Gi-2AO" id="v4e-k6-Fqf"/>
                 <outlet property="window" destination="xOd-HO-29H" id="JIz-fz-R2o"/>
@@ -27,7 +27,7 @@
                 <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                 <autoresizingMask key="autoresizingMask"/>
                 <subviews>
-                    <openGLView hidden="YES" wantsLayer="YES" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSOpenGLView">
+                    <openGLView hidden="YES" wantsLayer="YES" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSScanTargetView">
                         <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                     </openGLView>
                     <box hidden="YES" boxType="custom" cornerRadius="4" title="Box" titlePosition="noTitle" translatesAutoresizingMaskIntoConstraints="NO" id="4ap-Gi-2AO">
diff --git a/OSBindings/Mac/Clock Signal/ClockSignal-Bridging-Header.h b/OSBindings/Mac/Clock Signal/ClockSignal-Bridging-Header.h
index ebbf066d9..dac72af09 100644
--- a/OSBindings/Mac/Clock Signal/ClockSignal-Bridging-Header.h	
+++ b/OSBindings/Mac/Clock Signal/ClockSignal-Bridging-Header.h	
@@ -10,7 +10,7 @@
 #import "CSStaticAnalyser.h"
 
 #import "CSAudioQueue.h"
-#import	"CSOpenGLView.h"
+#import	"CSScanTargetView.h"
 #import "CSROMReceiverView.h"
 
 #import "CSJoystickManager.h"
diff --git a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift
index f5912a427..480d3c1c6 100644
--- a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
+++ b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
@@ -14,8 +14,8 @@ class MachineDocument:
 	NSDocument,
 	NSWindowDelegate,
 	CSMachineDelegate,
-	CSOpenGLViewDelegate,
-	CSOpenGLViewResponderDelegate,
+//	CSOpenGLViewDelegate,
+	CSScanTargetViewResponderDelegate,
 	CSAudioQueueDelegate,
 	CSROMReciverViewDelegate
 {
@@ -45,7 +45,7 @@ class MachineDocument:
 	// MARK: - Main NIB connections.
 
 	/// The OpenGL view to receive this machine's display.
-	@IBOutlet weak var openGLView: CSOpenGLView!
+	@IBOutlet weak var scanTargetView: CSScanTargetView!
 
 	/// The options panel, if any.
 	@IBOutlet var optionsPanel: MachinePanel!
@@ -100,8 +100,9 @@ class MachineDocument:
 		actionLock.lock()
 		drawLock.lock()
 		machine = nil
-		openGLView.delegate = nil
-		openGLView.invalidate()
+//		openGLView.delegate = nil
+//		openGLView.invalidate()
+		scanTargetView.invalidate()
 		actionLock.unlock()
 		drawLock.unlock()
 
@@ -181,10 +182,10 @@ class MachineDocument:
 	// MARK: - Connections Between Machine and the Outside World
 
 	private func setupMachineOutput() {
-		if let machine = self.machine, let openGLView = self.openGLView, machine.view != openGLView {
+		if let machine = self.machine, let scanTargetView = self.scanTargetView, machine.view != scanTargetView {
 			// Establish the output aspect ratio and audio.
 			let aspectRatio = self.aspectRatio()
-			machine.setView(openGLView, aspectRatio: Float(aspectRatio.width / aspectRatio.height))
+			machine.setView(scanTargetView, aspectRatio: Float(aspectRatio.width / aspectRatio.height))
 
 			// Attach an options panel if one is available.
 			if let optionsPanelNibName = self.machineDescription?.optionsPanelNibName {
@@ -198,20 +199,20 @@ class MachineDocument:
 
 			// Callbacks from the OpenGL may come on a different thread, immediately following the .delegate set;
 			// hence the full setup of the best-effort updater prior to setting self as a delegate.
-			openGLView.delegate = self
-			openGLView.responderDelegate = self
+//			scanTargetView.delegate = self
+			scanTargetView.responderDelegate = self
 
 			// If this machine has a mouse, enable mouse capture; also indicate whether usurption
 			// of the command key is desired.
-			openGLView.shouldCaptureMouse = machine.hasMouse
-			openGLView.shouldUsurpCommand = machine.shouldUsurpCommand
+			scanTargetView.shouldCaptureMouse = machine.hasMouse
+			scanTargetView.shouldUsurpCommand = machine.shouldUsurpCommand
 
 			setupAudioQueueClockRate()
 
 			// Bring OpenGL view-holding window on top of the options panel and show the content.
-			openGLView.isHidden = false
-			openGLView.window!.makeKeyAndOrderFront(self)
-			openGLView.window!.makeFirstResponder(openGLView)
+			scanTargetView.isHidden = false
+			scanTargetView.window!.makeKeyAndOrderFront(self)
+			scanTargetView.window!.makeFirstResponder(scanTargetView)
 
 			// Start forwarding best-effort updates.
 			machine.start()
@@ -254,15 +255,15 @@ class MachineDocument:
 
 	/// Responds to the CSOpenGLViewDelegate redraw message by requesting a machine update if this is a timed
 	/// request, and ordering a redraw regardless of the motivation.
-	final func openGLViewRedraw(_ view: CSOpenGLView, event redrawEvent: CSOpenGLViewRedrawEvent) {
-		if drawLock.try() {
-			if redrawEvent == .timer {
-				machine.updateView(forPixelSize: view.backingSize)
-			}
-			machine.drawView(forPixelSize: view.backingSize)
-			drawLock.unlock()
-		}
-	}
+//	final func openGLViewRedraw(_ view: CSOpenGLView, event redrawEvent: CSOpenGLViewRedrawEvent) {
+//		if drawLock.try() {
+//			if redrawEvent == .timer {
+//				machine.updateView(forPixelSize: view.backingSize)
+//			}
+//			machine.drawView(forPixelSize: view.backingSize)
+//			drawLock.unlock()
+//		}
+//	}
 
 	// MARK: - Pasteboard Forwarding.
 
@@ -277,7 +278,7 @@ class MachineDocument:
 	// MARK: - Runtime Media Insertion.
 
 	/// Delegate message to receive drag and drop files.
-	final func openGLView(_ view: CSOpenGLView, didReceiveFileAt URL: URL) {
+	final func openGLView(_ view: CSScanTargetView, didReceiveFileAt URL: URL) {
 		let mediaSet = CSMediaSet(fileAt: URL)
 		if let mediaSet = mediaSet {
 			mediaSet.apply(to: self.machine)
@@ -310,7 +311,7 @@ class MachineDocument:
 			machine.clearAllKeys()
 			machine.joystickManager = nil
 		}
-		self.openGLView.releaseMouse()
+		self.scanTargetView.releaseMouse()
 	}
 
 	/// Upon becoming key, attaches joystick input to the machine.
@@ -609,7 +610,7 @@ class MachineDocument:
 
 		// Obtain the machine's current display.
 		var imageRepresentation: NSBitmapImageRep? = nil
-		self.openGLView.perform {
+		self.scanTargetView.perform {
 			imageRepresentation = self.machine.imageRepresentation
 		}
 
@@ -620,11 +621,11 @@ class MachineDocument:
 
 	// MARK: - Window Title Updates.
 	private var unadornedWindowTitle = ""
-	func openGLViewDidCaptureMouse(_ view: CSOpenGLView) {
+	internal func openGLViewDidCaptureMouse(_ view: CSScanTargetView) {
 		self.windowControllers[0].window?.title = self.unadornedWindowTitle + " (press ⌘+control to release mouse)"
 	}
 
-	func openGLViewDidReleaseMouse(_ view: CSOpenGLView) {
+	internal func openGLViewDidReleaseMouse(_ view: CSScanTargetView) {
 		self.windowControllers[0].window?.title = self.unadornedWindowTitle
 	}
 
@@ -750,7 +751,7 @@ class MachineDocument:
 	}
 	fileprivate var animationFader: ViewFader? = nil
 
-	func openGLViewDidShowOSMouseCursor(_ view: CSOpenGLView) {
+	internal func openGLViewDidShowOSMouseCursor(_ view: CSScanTargetView) {
 		// The OS mouse cursor became visible, so show the volume controls.
 		animationFader = nil
 		volumeView.layer?.removeAllAnimations()
@@ -758,7 +759,7 @@ class MachineDocument:
 		volumeView.layer?.opacity = 1.0
 	}
 
-	func openGLViewWillHideOSMouseCursor(_ view: CSOpenGLView) {
+	internal func openGLViewWillHideOSMouseCursor(_ view: CSScanTargetView) {
 		// The OS mouse cursor will be hidden, so hide the volume controls.
 		if !volumeView.isHidden && volumeView.layer?.animation(forKey: "opacity") == nil {
 			let fadeAnimation = CABasicAnimation(keyPath: "opacity")
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.h b/OSBindings/Mac/Clock Signal/Machine/CSMachine.h
index d8595e06c..09cd4b295 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.h	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.h	
@@ -9,9 +9,9 @@
 #import <Foundation/Foundation.h>
 
 #import "CSAudioQueue.h"
-#import "CSOpenGLView.h"
-#import "CSStaticAnalyser.h"
 #import "CSJoystickManager.h"
+#import "CSScanTargetView.h"
+#import "CSStaticAnalyser.h"
 
 @class CSMachine;
 @protocol CSMachineDelegate
@@ -62,7 +62,7 @@ typedef NS_ENUM(NSInteger, CSMachineKeyboardInputMode) {
 - (BOOL)isStereo;
 - (void)setAudioSamplingRate:(float)samplingRate bufferSize:(NSUInteger)bufferSize stereo:(BOOL)stereo;
 
-- (void)setView:(nullable CSOpenGLView *)view aspectRatio:(float)aspectRatio;
+- (void)setView:(nullable CSScanTargetView *)view aspectRatio:(float)aspectRatio;
 
 - (void)start;
 - (void)stop;
@@ -77,7 +77,7 @@ typedef NS_ENUM(NSInteger, CSMachineKeyboardInputMode) {
 - (void)addMouseMotionX:(CGFloat)deltaX y:(CGFloat)deltaY;
 
 @property (atomic, strong, nullable) CSAudioQueue *audioQueue;
-@property (nonatomic, readonly, nonnull) CSOpenGLView *view;
+@property (nonatomic, readonly, nonnull) CSScanTargetView *view;
 @property (nonatomic, weak, nullable) id<CSMachineDelegate> delegate;
 
 @property (nonatomic, readonly, nonnull) NSString *userDefaultsPrefix;
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index cd5d8ba25..b3c2f4bf5 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -9,8 +9,9 @@
 #import "CSMachine.h"
 #import "CSMachine+Target.h"
 
-#include "CSROMFetcher.hpp"
 #import "CSHighPrecisionTimer.h"
+#include "CSROMFetcher.hpp"
+#import "CSScanTarget.h"
 
 #include "MediaTarget.hpp"
 #include "JoystickMachine.hpp"
@@ -37,7 +38,7 @@
 #include "../../../../Outputs/OpenGL/ScanTarget.hpp"
 #include "../../../../Outputs/OpenGL/Screenshot.hpp"
 
-@interface CSMachine() <CSOpenGLViewDisplayLinkDelegate>
+@interface CSMachine() <CSScanTargetViewDisplayLinkDelegate>
 - (void)speaker:(Outputs::Speaker::Speaker *)speaker didCompleteSamples:(const int16_t *)samples length:(int)length;
 - (void)speakerDidChangeInputClock:(Outputs::Speaker::Speaker *)speaker;
 - (void)addLED:(NSString *)led;
@@ -164,8 +165,6 @@ struct ActivityObserver: public Activity::Observer {
 	Time::ScanSynchroniser _scanSynchroniser;
 
 	NSTimer *_joystickTimer;
-
-	std::unique_ptr<Outputs::Display::OpenGL::ScanTarget> _scanTarget;
 }
 
 - (instancetype)initWithAnalyser:(CSStaticAnalyser *)result missingROMs:(inout NSMutableArray<CSMissingROM *> *)missingROMs {
@@ -245,11 +244,11 @@ struct ActivityObserver: public Activity::Observer {
 	_speakerDelegate.machine = nil;
 	[_delegateMachineAccessLock unlock];
 
-	[_view performWithGLContext:^{
-		@synchronized(self) {
-			self->_scanTarget.reset();
-		}
-	}];
+//	[_view performWithGLContext:^{
+//		@synchronized(self) {
+//			self->_scanTarget.reset();
+//		}
+//	}];
 }
 
 - (float)idealSamplingRateFromRange:(NSRange)range {
@@ -351,17 +350,17 @@ struct ActivityObserver: public Activity::Observer {
 	}
 }
 
-- (void)setView:(CSOpenGLView *)view aspectRatio:(float)aspectRatio {
+- (void)setView:(CSScanTargetView *)view aspectRatio:(float)aspectRatio {
 	_view = view;
 	_view.displayLinkDelegate = self;
-	[view performWithGLContext:^{
-		[self setupOutputWithAspectRatio:aspectRatio];
-	} flushDrawable:NO];
+//	[view performWithGLContext:^{
+//		[self setupOutputWithAspectRatio:aspectRatio];
+//	} flushDrawable:NO];
 }
 
 - (void)setupOutputWithAspectRatio:(float)aspectRatio {
-	_scanTarget = std::make_unique<Outputs::Display::OpenGL::ScanTarget>();
-	_machine->scan_producer()->set_scan_target(_scanTarget.get());
+//	_scanTarget = std::make_unique<Outputs::Display::OpenGL::ScanTarget>();
+//	_machine->scan_producer()->set_scan_target(_scanTarget.get());
 }
 
 - (void)updateViewForPixelSize:(CGSize)pixelSize {
@@ -374,7 +373,7 @@ struct ActivityObserver: public Activity::Observer {
 }
 
 - (void)drawViewForPixelSize:(CGSize)pixelSize {
-	_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
+//	_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
 }
 
 - (void)paste:(NSString *)paste {
@@ -737,7 +736,7 @@ struct ActivityObserver: public Activity::Observer {
 
 #pragma mark - Timer
 
-- (void)openGLViewDisplayLinkDidFire:(CSOpenGLView *)view now:(const CVTimeStamp *)now outputTime:(const CVTimeStamp *)outputTime {
+- (void)openGLViewDisplayLinkDidFire:(CSScanTargetView *)view now:(const CVTimeStamp *)now outputTime:(const CVTimeStamp *)outputTime {
 	// First order of business: grab a timestamp.
 	const auto timeNow = Time::nanos_now();
 
@@ -765,9 +764,9 @@ struct ActivityObserver: public Activity::Observer {
 
 	// Draw the current output. (TODO: do this within the timer if either raster racing or, at least, sync matching).
 	if(!isSyncLocking) {
-		[self.view performWithGLContext:^{
-			self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
-		} flushDrawable:YES];
+//		[self.view performWithGLContext:^{
+//			self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
+//		} flushDrawable:YES];
 	}
 }
 
@@ -823,10 +822,10 @@ struct ActivityObserver: public Activity::Observer {
 		if(!wasUpdating) {
 			dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
 				[self.view performWithGLContext:^{
-					self->_scanTarget->update((int)pixelSize.width, (int)pixelSize.height);
+//					self->_scanTarget->update((int)pixelSize.width, (int)pixelSize.height);
 
 					if(splitAndSync) {
-						self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
+//						self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
 					}
 				} flushDrawable:splitAndSync];
 				self->_isUpdating.clear();
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h
new file mode 100644
index 000000000..7140a3ea5
--- /dev/null
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
@@ -0,0 +1,18 @@
+//
+//  ScanTarget.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/08/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+/*!
+	Provides a ScanTarget that uses Metal as its back-end.
+*/
+@interface CSScanTarget : NSObject
+
+- (nonnull instancetype)init;
+
+@end
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
new file mode 100644
index 000000000..f16fcd631
--- /dev/null
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -0,0 +1,28 @@
+//
+//  ScanTarget.m
+//  Clock Signal
+//
+//  Created by Thomas Harte on 02/08/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#import "CSScanTarget.h"
+
+#import <Metal/Metal.h>
+
+@implementation CSScanTarget {
+	id<MTLDevice> _device;
+	id<MTLCommandQueue> _commandQueue;
+}
+
+- (nonnull instancetype)init {
+	self = [super init];
+	if(self) {
+		_device = MTLCreateSystemDefaultDevice();
+		_commandQueue = [_device newCommandQueue];
+		NSLog(@"%@; %@", _device, _commandQueue);
+	}
+	return self;
+}
+
+@end
diff --git a/OSBindings/Mac/Clock Signal/Views/CSOpenGLView.h b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
similarity index 72%
rename from OSBindings/Mac/Clock Signal/Views/CSOpenGLView.h
rename to OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
index f4090fd7a..eac99397c 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSOpenGLView.h	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
@@ -1,5 +1,5 @@
 //
-//  CSOpenGLView.h
+//  CSScanTargetView.h
 //  Clock Signal
 //
 //  Created by Thomas Harte on 16/07/2015.
@@ -8,63 +8,33 @@
 
 #import <Foundation/Foundation.h>
 #import <AppKit/AppKit.h>
+#import <MetalKit/MetalKit.h>
 
-@class CSOpenGLView;
+@class CSScanTargetView;
 
-typedef NS_ENUM(NSInteger, CSOpenGLViewRedrawEvent) {
+typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 	/// Indicates that AppKit requested a redraw for some reason (mostly likely, the window is being resized). So,
 	/// if the delegate doesn't redraw the view, the user is likely to see a graphical flaw.
-	CSOpenGLViewRedrawEventAppKit,
+	CSScanTargetViewRedrawEventAppKit,
 	/// Indicates that the view's display-linked timer has triggered a redraw request. So, if the delegate doesn't
 	/// redraw the view, the user will just see the previous drawing without interruption.
-	CSOpenGLViewRedrawEventTimer
+	CSScanTargetViewRedrawEventTimer
 };
 
-@protocol CSOpenGLViewDelegate
-/*!
-	Requests that the delegate produce an image of its current output state. May be called on
-	any queue or thread.
-	@param view The view making the request.
-	@param redrawEvent If @c YES then the delegate may decline to redraw if its output would be
-	identical to the previous frame. If @c NO then the delegate must draw.
-*/
-- (void)openGLViewRedraw:(nonnull CSOpenGLView *)view event:(CSOpenGLViewRedrawEvent)redrawEvent;
+//@protocol CSScanTargetViewDelegate
+///*!
+//	Requests that the delegate produce an image of its current output state. May be called on
+//	any queue or thread.
+//	@param view The view making the request.
+//	@param redrawEvent If @c YES then the delegate may decline to redraw if its output would be
+//	identical to the previous frame. If @c NO then the delegate must draw.
+//*/
+//- (void)openGLViewRedraw:(nonnull CSScanTargetView *)view event:(CSScanTargetViewRedrawEvent)redrawEvent;
+//
+//
+//@end
 
-/*!
-	Announces receipt of a file by drag and drop to the delegate.
-	@param view The view making the request.
-	@param URL The file URL of the received file.
-*/
-- (void)openGLView:(nonnull CSOpenGLView *)view didReceiveFileAtURL:(nonnull NSURL *)URL;
-
-/*!
-	Announces 'capture' of the mouse — i.e. that the view is now preventing the mouse from exiting
-	the window, in order to forward continuous mouse motion.
-	@param view The view making the announcement.
-*/
-- (void)openGLViewDidCaptureMouse:(nonnull CSOpenGLView *)view;
-
-/*!
-	Announces that the mouse is no longer captured.
-	@param view The view making the announcement.
-*/
-- (void)openGLViewDidReleaseMouse:(nonnull CSOpenGLView *)view;
-
-/*!
-	Announces that the OS mouse cursor is now being displayed again, after having been invisible.
-	@param view The view making the announcement.
-*/
-- (void)openGLViewDidShowOSMouseCursor:(nonnull CSOpenGLView *)view;
-
-/*!
-	Announces that the OS mouse cursor will now be hidden.
-	@param view The view making the announcement.
-*/
-- (void)openGLViewWillHideOSMouseCursor:(nonnull CSOpenGLView *)view;
-
-@end
-
-@protocol CSOpenGLViewResponderDelegate <NSObject>
+@protocol CSScanTargetViewResponderDelegate <NSObject>
 /*!
 	Supplies a keyDown event to the delegate.
 	@param event The @c NSEvent describing the keyDown.
@@ -111,22 +81,54 @@ typedef NS_ENUM(NSInteger, CSOpenGLViewRedrawEvent) {
 */
 - (void)mouseUp:(nonnull NSEvent *)event;
 
+/*!
+	Announces 'capture' of the mouse — i.e. that the view is now preventing the mouse from exiting
+	the window, in order to forward continuous mouse motion.
+	@param view The view making the announcement.
+*/
+- (void)openGLViewDidCaptureMouse:(nonnull CSScanTargetView *)view;
+
+/*!
+	Announces that the mouse is no longer captured.
+	@param view The view making the announcement.
+*/
+- (void)openGLViewDidReleaseMouse:(nonnull CSScanTargetView *)view;
+
+/*!
+	Announces that the OS mouse cursor is now being displayed again, after having been invisible.
+	@param view The view making the announcement.
+*/
+- (void)openGLViewDidShowOSMouseCursor:(nonnull CSScanTargetView *)view;
+
+/*!
+	Announces that the OS mouse cursor will now be hidden.
+	@param view The view making the announcement.
+*/
+- (void)openGLViewWillHideOSMouseCursor:(nonnull CSScanTargetView *)view;
+
+/*!
+	Announces receipt of a file by drag and drop to the delegate.
+	@param view The view making the request.
+	@param URL The file URL of the received file.
+*/
+- (void)openGLView:(nonnull CSScanTargetView *)view didReceiveFileAtURL:(nonnull NSURL *)URL;
+
 @end
 
 /*!
-	Although I'm still on the fence about this as a design decision, CSOpenGLView  is itself responsible
+	Although I'm still on the fence about this as a design decision, CSScanTargetView  is itself responsible
 	for creating and destroying a CVDisplayLink. There's a practical reason for this: you'll get real synchronisation
-	only if a link is explicitly tied to a particular display, and the CSOpenGLView therefore owns the knowledge
+	only if a link is explicitly tied to a particular display, and the CSScanTargetView therefore owns the knowledge
 	necessary to decide when to create and modify them. It doesn't currently just propagate "did change screen"-type
 	messages because I haven't yet found a way to track that other than polling, in which case I might as well put
 	that into the display link callback.
 */
-@protocol CSOpenGLViewDisplayLinkDelegate
+@protocol CSScanTargetViewDisplayLinkDelegate
 
 /*!
 	Informs the delegate that the display link has fired.
 */
-- (void)openGLViewDisplayLinkDidFire:(nonnull CSOpenGLView *)view now:(nonnull const CVTimeStamp *)now outputTime:(nonnull const CVTimeStamp *)outputTime;
+- (void)openGLViewDisplayLinkDidFire:(nonnull CSScanTargetView *)view now:(nonnull const CVTimeStamp *)now outputTime:(nonnull const CVTimeStamp *)outputTime;
 
 @end
 
@@ -134,18 +136,18 @@ typedef NS_ENUM(NSInteger, CSOpenGLViewRedrawEvent) {
 	Provides an OpenGL canvas with a refresh-linked update timer that can forward a subset
 	of typical first-responder actions.
 */
-@interface CSOpenGLView : NSOpenGLView
+@interface CSScanTargetView : MTKView
 
-@property (atomic, weak, nullable) id <CSOpenGLViewDelegate> delegate;
-@property (nonatomic, weak, nullable) id <CSOpenGLViewResponderDelegate> responderDelegate;
-@property (atomic, weak, nullable) id <CSOpenGLViewDisplayLinkDelegate> displayLinkDelegate;
+//@property (atomic, weak, nullable) id <CSOpenGLViewDelegate> delegate;
+@property (nonatomic, weak, nullable) id <CSScanTargetViewResponderDelegate> responderDelegate;
+@property (atomic, weak, nullable) id <CSScanTargetViewDisplayLinkDelegate> displayLinkDelegate;
 
 /// Determines whether the view offers mouse capturing — i.e. if the user clicks on the view then
-/// then the system cursor is disabled and the mouse events defined by CSOpenGLViewResponderDelegate
+/// then the system cursor is disabled and the mouse events defined by CSScanTargetViewResponderDelegate
 /// are forwarded, unless and until the user releases the mouse using the control+command shortcut.
 @property (nonatomic, assign) BOOL shouldCaptureMouse;
 
-/// Determines whether the CSOpenGLViewResponderDelegate of this window expects to use the command
+/// Determines whether the CSScanTargetViewResponderDelegate of this window expects to use the command
 /// key as though it were any other key — i.e. all command combinations should be forwarded to the delegate,
 /// not being allowed to trigger regular application shortcuts such as command+q or command+h.
 ///
diff --git a/OSBindings/Mac/Clock Signal/Views/CSOpenGLView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
similarity index 74%
rename from OSBindings/Mac/Clock Signal/Views/CSOpenGLView.m
rename to OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index 2b6759170..c67270a5a 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSOpenGLView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -1,22 +1,22 @@
 //
-//  CSOpenGLView
+//  CSScanTargetView
 //  CLK
 //
 //  Created by Thomas Harte on 16/07/2015.
 //  Copyright 2015 Thomas Harte. All rights reserved.
 //
 
-#import "CSOpenGLView.h"
+#import "CSScanTargetView.h"
 #import "CSApplication.h"
 @import CoreVideo;
 @import GLKit;
 
 #include <stdatomic.h>
 
-@interface CSOpenGLView () <NSDraggingDestination, CSApplicationEventDelegate>
+@interface CSScanTargetView () <NSDraggingDestination, CSApplicationEventDelegate>
 @end
 
-@implementation CSOpenGLView {
+@implementation CSScanTargetView {
 	CVDisplayLinkRef _displayLink;
 	CGSize _backingSize;
 	NSNumber *_currentScreenNumber;
@@ -29,19 +29,19 @@
 	BOOL _isInvalid;
 }
 
-- (void)prepareOpenGL {
-	[super prepareOpenGL];
-
-	// Prepare the atomic int.
-	atomic_init(&_isDrawingFlag, 0);
-
-	// Set the clear colour.
-	[self.openGLContext makeCurrentContext];
-	glClearColor(0.0, 0.0, 0.0, 1.0);
-
-	// Setup the [initial] display link.
-	[self setupDisplayLink];
-}
+//- (void)prepareOpenGL {
+//	[super prepareOpenGL];
+//
+//	// Prepare the atomic int.
+//	atomic_init(&_isDrawingFlag, 0);
+//
+//	// Set the clear colour.
+//	[self.openGLContext makeCurrentContext];
+//	glClearColor(0.0, 0.0, 0.0, 1.0);
+//
+//	// Setup the [initial] display link.
+//	[self setupDisplayLink];
+//}
 
 - (void)setupDisplayLink {
 	// Kill the existing link if there is one.
@@ -59,16 +59,16 @@
 	CVDisplayLinkSetOutputCallback(_displayLink, DisplayLinkCallback, (__bridge void * __nullable)(self));
 
 	// Set the display link for the current renderer.
-	CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
-	CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
-	CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(_displayLink, cglContext, cglPixelFormat);
+//	CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
+//	CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
+//	CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(_displayLink, cglContext, cglPixelFormat);
 
 	// Activate the display link.
 	CVDisplayLinkStart(_displayLink);
 }
 
 static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const CVTimeStamp *now, const CVTimeStamp *outputTime, __unused CVOptionFlags flagsIn, __unused CVOptionFlags *flagsOut, void *displayLinkContext) {
-	CSOpenGLView *const view = (__bridge CSOpenGLView *)displayLinkContext;
+	CSScanTargetView *const view = (__bridge CSScanTargetView *)displayLinkContext;
 
 	// Schedule an opportunity to check that the display link is still linked to the correct display.
 	dispatch_async(dispatch_get_main_queue(), ^{
@@ -108,7 +108,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	if(![_currentScreenNumber isEqual:screenNumber]) {
 		// Issue a reshape, in case a switch to/from a Retina display has
 		// happened, changing the results of -convertSizeToBacking:, etc.
-		[self reshape];
+//		[self reshape];
 
 		// Also switch display links, to make sure synchronisation is with the display
 		// the window is actually on, and at its rate.
@@ -117,16 +117,16 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 }
 
 - (void)drawAtTime:(const CVTimeStamp *)now frequency:(double)frequency {
-	[self redrawWithEvent:CSOpenGLViewRedrawEventTimer];
+	[self redrawWithEvent:CSScanTargetViewRedrawEventTimer];
 }
 
 - (void)drawRect:(NSRect)dirtyRect {
-	[self redrawWithEvent:CSOpenGLViewRedrawEventAppKit];
+	[self redrawWithEvent:CSScanTargetViewRedrawEventAppKit];
 }
 
-- (void)redrawWithEvent:(CSOpenGLViewRedrawEvent)event  {
+- (void)redrawWithEvent:(CSScanTargetViewRedrawEvent)event  {
 	[self performWithGLContext:^{
-		[self.delegate openGLViewRedraw:self event:event];
+//		[self.delegate openGLViewRedraw:self event:event];
 	} flushDrawable:YES];
 }
 
@@ -166,59 +166,59 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	}
 }
 
-- (void)reshape {
-	[super reshape];
-	@synchronized(self) {
-		_backingSize = [self convertSizeToBacking:self.bounds.size];
-	}
-
-	[self performWithGLContext:^{
-		CGSize viewSize = [self backingSize];
-		glViewport(0, 0, (GLsizei)viewSize.width, (GLsizei)viewSize.height);
-	} flushDrawable:NO];
-}
+//- (void)reshape {
+//	[super reshape];
+//	@synchronized(self) {
+//		_backingSize = [self convertSizeToBacking:self.bounds.size];
+//	}
+//
+//	[self performWithGLContext:^{
+//		CGSize viewSize = [self backingSize];
+//		glViewport(0, 0, (GLsizei)viewSize.width, (GLsizei)viewSize.height);
+//	} flushDrawable:NO];
+//}
 
 - (void)awakeFromNib {
-	NSOpenGLPixelFormatAttribute attributes[] = {
-		NSOpenGLPFADoubleBuffer,
-		NSOpenGLPFAOpenGLProfile,	NSOpenGLProfileVersion3_2Core,
-//		NSOpenGLPFAMultisample,
-//		NSOpenGLPFASampleBuffers,	1,
-//		NSOpenGLPFASamples,			2,
-		0
-	};
-
-	NSOpenGLPixelFormat *pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
-	NSOpenGLContext *context = [[NSOpenGLContext alloc] initWithFormat:pixelFormat shareContext:nil];
-
-#ifdef DEBUG
-	// When we're using a CoreProfile context, crash if we call a legacy OpenGL function
-	// This will make it much more obvious where and when such a function call is made so
-	// that we can remove such calls.
-	// Without this we'd simply get GL_INVALID_OPERATION error for calling legacy functions
-	// but it would be more difficult to see where that function was called.
-	CGLEnable([context CGLContextObj], kCGLCECrashOnRemovedFunctions);
-#endif
-
-	self.pixelFormat = pixelFormat;
-	self.openGLContext = context;
-	self.wantsBestResolutionOpenGLSurface = YES;
+//	NSOpenGLPixelFormatAttribute attributes[] = {
+//		NSOpenGLPFADoubleBuffer,
+//		NSOpenGLPFAOpenGLProfile,	NSOpenGLProfileVersion3_2Core,
+////		NSOpenGLPFAMultisample,
+////		NSOpenGLPFASampleBuffers,	1,
+////		NSOpenGLPFASamples,			2,
+//		0
+//	};
+//
+//	NSOpenGLPixelFormat *pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
+//	NSOpenGLContext *context = [[NSOpenGLContext alloc] initWithFormat:pixelFormat shareContext:nil];
+//
+//#ifdef DEBUG
+//	// When we're using a CoreProfile context, crash if we call a legacy OpenGL function
+//	// This will make it much more obvious where and when such a function call is made so
+//	// that we can remove such calls.
+//	// Without this we'd simply get GL_INVALID_OPERATION error for calling legacy functions
+//	// but it would be more difficult to see where that function was called.
+//	CGLEnable([context CGLContextObj], kCGLCECrashOnRemovedFunctions);
+//#endif
+//
+//	self.pixelFormat = pixelFormat;
+//	self.openGLContext = context;
+//	self.wantsBestResolutionOpenGLSurface = YES;
 
 	// Register to receive dragged and dropped file URLs.
 	[self registerForDraggedTypes:@[(__bridge NSString *)kUTTypeFileURL]];
 }
 
 - (void)performWithGLContext:(dispatch_block_t)action flushDrawable:(BOOL)flushDrawable {
-	CGLLockContext([[self openGLContext] CGLContextObj]);
-	[self.openGLContext makeCurrentContext];
-	action();
-	CGLUnlockContext([[self openGLContext] CGLContextObj]);
-
-	if(flushDrawable) CGLFlushDrawable([[self openGLContext] CGLContextObj]);
+//	CGLLockContext([[self openGLContext] CGLContextObj]);
+//	[self.openGLContext makeCurrentContext];
+//	action();
+//	CGLUnlockContext([[self openGLContext] CGLContextObj]);
+//
+//	if(flushDrawable) CGLFlushDrawable([[self openGLContext] CGLContextObj]);
 }
 
 - (void)performWithGLContext:(nonnull dispatch_block_t)action {
-	[self performWithGLContext:action flushDrawable:NO];
+//	[self performWithGLContext:action flushDrawable:NO];
 }
 
 #pragma mark - NSResponder
@@ -264,7 +264,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
 	for(NSPasteboardItem *item in [[sender draggingPasteboard] pasteboardItems]) {
 		NSURL *URL = [NSURL URLWithString:[item stringForType:(__bridge NSString *)kUTTypeFileURL]];
-		[self.delegate openGLView:self didReceiveFileAtURL:URL];
+		[self.responderDelegate openGLView:self didReceiveFileAtURL:URL];
 	}
 	return YES;
 }
@@ -300,13 +300,13 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 
 		_mouseHideTimer = [NSTimer scheduledTimerWithTimeInterval:3.0 repeats:NO block:^(__unused NSTimer * _Nonnull timer) {
 			[NSCursor setHiddenUntilMouseMoves:YES];
-			[self.delegate openGLViewWillHideOSMouseCursor:self];
+			[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
 		}];
 	}
 }
 
 - (void)mouseEntered:(NSEvent *)event {
-	[self.delegate openGLViewDidShowOSMouseCursor:self];
+	[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
 	[super mouseEntered:event];
 	[self scheduleMouseHide];
 }
@@ -315,7 +315,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	[super mouseExited:event];
 	[_mouseHideTimer invalidate];
 	_mouseHideTimer = nil;
-	[self.delegate openGLViewWillHideOSMouseCursor:self];
+	[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
 }
 
 - (void)releaseMouse {
@@ -323,8 +323,8 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		_mouseIsCaptured = NO;
 		CGAssociateMouseAndMouseCursorPosition(true);
 		[NSCursor unhide];
-		[self.delegate openGLViewDidReleaseMouse:self];
-		[self.delegate openGLViewDidShowOSMouseCursor:self];
+		[self.responderDelegate openGLViewDidReleaseMouse:self];
+		[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
 		((CSApplication *)[NSApplication sharedApplication]).eventDelegate = nil;
 	}
 }
@@ -336,7 +336,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		// Mouse capture is off, so don't play games with the cursor, just schedule it to
 		// hide in the near future.
 		[self scheduleMouseHide];
-		[self.delegate openGLViewDidShowOSMouseCursor:self];
+		[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
 	} else {
 		if(_mouseIsCaptured) {
 			// Mouse capture is on, so move the cursor back to the middle of the window, and
@@ -354,7 +354,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 
 			[self.responderDelegate mouseMoved:event];
 		} else {
-			[self.delegate openGLViewDidShowOSMouseCursor:self];
+			[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
 		}
 	}
 }
@@ -387,8 +387,8 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 			_mouseIsCaptured = YES;
 			[NSCursor hide];
 			CGAssociateMouseAndMouseCursorPosition(false);
-			[self.delegate openGLViewWillHideOSMouseCursor:self];
-			[self.delegate openGLViewDidCaptureMouse:self];
+			[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
+			[self.responderDelegate openGLViewDidCaptureMouse:self];
 			if(self.shouldUsurpCommand) {
 				((CSApplication *)[NSApplication sharedApplication]).eventDelegate = self;
 			}

From 72df6e52cd960d0280791e3f4c1fec62bec0be65 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 4 Aug 2020 19:44:56 -0400
Subject: [PATCH 002/131] This is possibly at least dispatching an empty
 command buffer correctly.

---
 .../Clock Signal/ScanTarget/CSScanTarget.h    |  5 ++-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 39 ++++++++++++++++---
 .../Mac/Clock Signal/Views/CSScanTargetView.m | 20 ++++++++--
 3 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h
index 7140a3ea5..93f9fb62c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
@@ -7,12 +7,13 @@
 //
 
 #import <Foundation/Foundation.h>
+#import <MetalKit/MetalKit.h>
 
 /*!
 	Provides a ScanTarget that uses Metal as its back-end.
 */
-@interface CSScanTarget : NSObject
+@interface CSScanTarget : NSObject <MTKViewDelegate>
 
-- (nonnull instancetype)init;
+- (nonnull instancetype)initWithView:(nonnull MTKView *)view;
 
 @end
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index f16fcd631..a423db496 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -11,18 +11,47 @@
 #import <Metal/Metal.h>
 
 @implementation CSScanTarget {
-	id<MTLDevice> _device;
 	id<MTLCommandQueue> _commandQueue;
 }
 
-- (nonnull instancetype)init {
+- (nonnull instancetype)initWithView:(nonnull MTKView *)view {
 	self = [super init];
 	if(self) {
-		_device = MTLCreateSystemDefaultDevice();
-		_commandQueue = [_device newCommandQueue];
-		NSLog(@"%@; %@", _device, _commandQueue);
+		_commandQueue = [view.device newCommandQueue];
 	}
 	return self;
 }
 
+/*!
+ @method mtkView:drawableSizeWillChange:
+ @abstract Called whenever the drawableSize of the view will change
+ @discussion Delegate can recompute view and projection matricies or regenerate any buffers to be compatible with the new view size or resolution
+ @param view MTKView which called this method
+ @param size New drawable size in pixels
+ */
+- (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
+	NSLog(@"New size: %@", NSStringFromSize(size));
+}
+
+/*!
+ @method drawInMTKView:
+ @abstract Called on the delegate when it is asked to render into the view
+ @discussion Called on the delegate when it is asked to render into the view
+ */
+- (void)drawInMTKView:(nonnull MTKView *)view {
+	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
+	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
+
+	// TODO: the drawing (!)
+
+	[encoder endEncoding];
+
+	// "Register the drawable's presentation".
+	[commandBuffer presentDrawable:view.currentDrawable];
+
+	// Finalise and commit.
+	[commandBuffer commit];
+}
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index c67270a5a..dd2907d3d 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -8,6 +8,7 @@
 
 #import "CSScanTargetView.h"
 #import "CSApplication.h"
+#import "CSScanTarget.h"
 @import CoreVideo;
 @import GLKit;
 
@@ -27,6 +28,8 @@
 
 	atomic_int _isDrawingFlag;
 	BOOL _isInvalid;
+
+	CSScanTarget *_scanTarget;
 }
 
 //- (void)prepareOpenGL {
@@ -120,9 +123,10 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	[self redrawWithEvent:CSScanTargetViewRedrawEventTimer];
 }
 
-- (void)drawRect:(NSRect)dirtyRect {
-	[self redrawWithEvent:CSScanTargetViewRedrawEventAppKit];
-}
+//- (void)drawRect:(NSRect)dirtyRect {
+//	[self redrawWithEvent:CSScanTargetViewRedrawEventAppKit];
+//	NSLog(@"...");
+//}
 
 - (void)redrawWithEvent:(CSScanTargetViewRedrawEvent)event  {
 	[self performWithGLContext:^{
@@ -179,6 +183,13 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 //}
 
 - (void)awakeFromNib {
+	// Use the preferred device if available.
+	if(@available(macOS 10.15, *)) {
+		self.device = self.preferredDevice;
+	} else {
+		self.device = MTLCreateSystemDefaultDevice();
+	}
+
 //	NSOpenGLPixelFormatAttribute attributes[] = {
 //		NSOpenGLPFADoubleBuffer,
 //		NSOpenGLPFAOpenGLProfile,	NSOpenGLProfileVersion3_2Core,
@@ -203,6 +214,9 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 //	self.pixelFormat = pixelFormat;
 //	self.openGLContext = context;
 //	self.wantsBestResolutionOpenGLSurface = YES;
+	// Create the scan target.
+	_scanTarget = [[CSScanTarget alloc] initWithView:self];
+	self.delegate = _scanTarget;
 
 	// Register to receive dragged and dropped file URLs.
 	[self registerForDraggedTypes:@[(__bridge NSString *)kUTTypeFileURL]];

From eff24a87266ef0f4f1195bf9c276b5a2b47d28a2 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 4 Aug 2020 21:49:01 -0400
Subject: [PATCH 003/131] My first baby steps in Metal continue; here's a
 triangle.

---
 .../Clock Signal.xcodeproj/project.pbxproj    |  4 ++
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 42 ++++++++++++++++++-
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 28 +++++++++++++
 3 files changed, 72 insertions(+), 2 deletions(-)
 create mode 100644 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 5b14a58d8..302b21d38 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -157,6 +157,7 @@
 		4B1EDB451E39A0AC009D6819 /* chip.png in Resources */ = {isa = PBXBuildFile; fileRef = 4B1EDB431E39A0AC009D6819 /* chip.png */; };
 		4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B228CD424D773B30077EF25 /* CSScanTarget.mm */; };
 		4B228CD924DA12C60077EF25 /* CSScanTargetView.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B228CD824DA12C60077EF25 /* CSScanTargetView.m */; };
+		4B228CDB24DA41890077EF25 /* ScanTarget.metal in Sources */ = {isa = PBXBuildFile; fileRef = 4B228CDA24DA41880077EF25 /* ScanTarget.metal */; };
 		4B2530F4244E6774007980BF /* fm.json in Resources */ = {isa = PBXBuildFile; fileRef = 4B2530F3244E6773007980BF /* fm.json */; };
 		4B2A332D1DB86821002876E3 /* OricOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4B2A332B1DB86821002876E3 /* OricOptions.xib */; };
 		4B2A539F1D117D36003C6002 /* CSAudioQueue.m in Sources */ = {isa = PBXBuildFile; fileRef = 4B2A53911D117D36003C6002 /* CSAudioQueue.m */; };
@@ -1009,6 +1010,7 @@
 		4B228CD624D773CA0077EF25 /* CSScanTarget.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CSScanTarget.h; sourceTree = "<group>"; };
 		4B228CD724DA12C50077EF25 /* CSScanTargetView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSScanTargetView.h; sourceTree = "<group>"; };
 		4B228CD824DA12C60077EF25 /* CSScanTargetView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSScanTargetView.m; sourceTree = "<group>"; };
+		4B228CDA24DA41880077EF25 /* ScanTarget.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; name = ScanTarget.metal; path = "Clock Signal/ScanTarget/ScanTarget.metal"; sourceTree = "<group>"; };
 		4B24095A1C45DF85004DA684 /* Stepper.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Stepper.hpp; sourceTree = "<group>"; };
 		4B2530F3244E6773007980BF /* fm.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = fm.json; sourceTree = "<group>"; };
 		4B2A332C1DB86821002876E3 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = "Clock Signal/Base.lproj/OricOptions.xib"; sourceTree = SOURCE_ROOT; };
@@ -3323,6 +3325,7 @@
 		4BB73E951B587A5100552FC2 = {
 			isa = PBXGroup;
 			children = (
+				4B228CDA24DA41880077EF25 /* ScanTarget.metal */,
 				4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */,
 				4BC3C67B24C9230F0027BF76 /* BufferingScanTarget.hpp */,
 				4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */,
@@ -4687,6 +4690,7 @@
 				4BA61EB01D91515900B3C876 /* NSData+StdVector.mm in Sources */,
 				4BDA00E022E644AF00AC3CD0 /* CSROMReceiverView.m in Sources */,
 				4BD191F42191180E0042E144 /* ScanTarget.cpp in Sources */,
+				4B228CDB24DA41890077EF25 /* ScanTarget.metal in Sources */,
 				4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */,
 				4BCD634922D6756400F567F1 /* MacintoshDoubleDensityDrive.cpp in Sources */,
 				4B0F94FE208C1A1600FE41D9 /* NIB.cpp in Sources */,
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a423db496..d378305ff 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -12,12 +12,43 @@
 
 @implementation CSScanTarget {
 	id<MTLCommandQueue> _commandQueue;
+
+	// TEST ONLY: to check that I'm drawing _something_, I'm heading towards ye standard
+	// Gouraud shading triangle. https://metalbyexample.com/up-and-running-2/ is providing
+	// much of the inspiration, albeit that I'm proceeding via MKLView.
+	id<MTLFunction> _vertexShader;
+	id<MTLFunction> _fragmentShader;
+	id<MTLBuffer> _positionBuffer;
+	id<MTLBuffer> _colourBuffer;
+	id<MTLRenderPipelineState> _gouraudPipeline;
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
 	self = [super init];
 	if(self) {
 		_commandQueue = [view.device newCommandQueue];
+
+		// Generate some static buffers. AS A TEST.
+		constexpr float positions[] = {
+			0.0f,	0.5f,	0.0f,	1.0f,
+			-0.5f,	-0.5f,	0.0f,	1.0f,
+			0.5f,	-0.5f,	0.0f,	1.0f,
+		};
+		constexpr float colours[] = {
+			1.0f, 0.0f, 0.0f, 1.0f,
+			0.0f, 1.0f, 0.0f, 1.0f,
+			0.0f, 0.0f, 1.0f, 1.0f,
+		};
+		_positionBuffer = [view.device newBufferWithBytes:positions length:sizeof(positions) options:MTLResourceOptionCPUCacheModeDefault];
+		_colourBuffer = [view.device newBufferWithBytes:colours length:sizeof(colours) options:MTLResourceOptionCPUCacheModeDefault];
+
+		// Generate TEST pipeline.
+		id<MTLLibrary> library = [view.device newDefaultLibrary];
+		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"vertex_main"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"fragment_main"];
+		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 	return self;
 }
@@ -30,7 +61,8 @@
  @param size New drawable size in pixels
  */
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
-	NSLog(@"New size: %@", NSStringFromSize(size));
+	// I think (?) I don't care about this; the MKLView has already handled resizing the backing,
+	// which will naturally change the viewport.
 }
 
 /*!
@@ -39,12 +71,18 @@
  @discussion Called on the delegate when it is asked to render into the view
  */
 - (void)drawInMTKView:(nonnull MTKView *)view {
+	// Generate a command encoder for the view.
 	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
 	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
 	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
 
-	// TODO: the drawing (!)
+	// Drawing. Just the test triangle, as described above.
+	[encoder setRenderPipelineState:_gouraudPipeline];
+	[encoder setVertexBuffer:_positionBuffer offset:0 atIndex:0];
+	[encoder setVertexBuffer:_colourBuffer offset:0 atIndex:1];
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3 instanceCount:1];
 
+	// Complete encoding.
 	[encoder endEncoding];
 
 	// "Register the drawable's presentation".
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
new file mode 100644
index 000000000..6e5e1bef3
--- /dev/null
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -0,0 +1,28 @@
+//
+//  ScanTarget.metal
+//  Clock Signal
+//
+//  Created by Thomas Harte on 04/08/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#include <metal_stdlib>
+using namespace metal;
+
+struct ColoredVertex {
+	float4 position [[position]];
+	float4 color;
+};
+
+vertex ColoredVertex vertex_main(	constant float4 *position [[buffer(0)]],
+									constant float4 *color [[buffer(1)]],
+									uint vid [[vertex_id]]) {
+	ColoredVertex vert;
+	vert.position = position[vid];
+	vert.color = color[vid];
+	return vert;
+}
+
+fragment float4 fragment_main(ColoredVertex vert [[stage_in]]) {
+	return vert.color;
+}

From 5c836604c0f07c1a8d3f408e5b6250c3abc9abfe Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 4 Aug 2020 21:50:54 -0400
Subject: [PATCH 004/131] Reenable MaserSystem code.

Accidental/poor branch management is evidenced here.
---
 Machines/MasterSystem/MasterSystem.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Machines/MasterSystem/MasterSystem.cpp b/Machines/MasterSystem/MasterSystem.cpp
index 9c0bf61e4..f43e999ea 100644
--- a/Machines/MasterSystem/MasterSystem.cpp
+++ b/Machines/MasterSystem/MasterSystem.cpp
@@ -120,11 +120,11 @@ class ConcreteMachine:
 			if(!target.media.cartridges.empty()) {
 				cartridge_ = target.media.cartridges[0]->get_segments()[0].data;
 			}
-//			if(cartridge_.size() < 48*1024) {
-//				std::size_t new_space = 48*1024 - cartridge_.size();
-//				cartridge_.resize(48*1024);
-//				memset(&cartridge_[48*1024 - new_space], 0xff, new_space);
-//			}
+			if(cartridge_.size() < 48*1024) {
+				std::size_t new_space = 48*1024 - cartridge_.size();
+				cartridge_.resize(48*1024);
+				memset(&cartridge_[48*1024 - new_space], 0xff, new_space);
+			}
 
 			if(paging_scheme_ == Target::PagingScheme::Codemasters) {
 				// The Codemasters cartridges start with pages 0, 1 and 0 again initially visible.

From 7551782a25ef8120f9f6fca8066acc0bf10d31d7 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 5 Aug 2020 17:27:43 -0400
Subject: [PATCH 005/131] Switches to interleaved vertex data.

This more closely relates to what I actually want to do.
---
 .../Clock Signal.xcodeproj/project.pbxproj    |  8 ++--
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 39 ++++++++++++-------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 29 ++++++++------
 3 files changed, 48 insertions(+), 28 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 302b21d38..1bf433bff 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -1010,7 +1010,7 @@
 		4B228CD624D773CA0077EF25 /* CSScanTarget.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CSScanTarget.h; sourceTree = "<group>"; };
 		4B228CD724DA12C50077EF25 /* CSScanTargetView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSScanTargetView.h; sourceTree = "<group>"; };
 		4B228CD824DA12C60077EF25 /* CSScanTargetView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSScanTargetView.m; sourceTree = "<group>"; };
-		4B228CDA24DA41880077EF25 /* ScanTarget.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; name = ScanTarget.metal; path = "Clock Signal/ScanTarget/ScanTarget.metal"; sourceTree = "<group>"; };
+		4B228CDA24DA41880077EF25 /* ScanTarget.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; name = ScanTarget.metal; path = "Clock Signal/ScanTarget/ScanTarget.metal"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.metal; };
 		4B24095A1C45DF85004DA684 /* Stepper.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Stepper.hpp; sourceTree = "<group>"; };
 		4B2530F3244E6773007980BF /* fm.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = fm.json; sourceTree = "<group>"; };
 		4B2A332C1DB86821002876E3 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = "Clock Signal/Base.lproj/OricOptions.xib"; sourceTree = SOURCE_ROOT; };
@@ -5167,8 +5167,8 @@
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.10;
-				MTL_ENABLE_DEBUG_INFO = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.11;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
@@ -5218,7 +5218,7 @@
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.10;
+				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index d378305ff..a291ffb79 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -18,8 +18,7 @@
 	// much of the inspiration, albeit that I'm proceeding via MKLView.
 	id<MTLFunction> _vertexShader;
 	id<MTLFunction> _fragmentShader;
-	id<MTLBuffer> _positionBuffer;
-	id<MTLBuffer> _colourBuffer;
+	id<MTLBuffer> _verticesBuffer;
 	id<MTLRenderPipelineState> _gouraudPipeline;
 }
 
@@ -29,18 +28,32 @@
 		_commandQueue = [view.device newCommandQueue];
 
 		// Generate some static buffers. AS A TEST.
-		constexpr float positions[] = {
-			0.0f,	0.5f,	0.0f,	1.0f,
+		constexpr float vertices[] = {
+			0.0f,	0.5f,	0.0f,	1.0f,	// Position.
+			1.0f, 	0.0f, 	0.0f, 	1.0f,	// Colour.
+
 			-0.5f,	-0.5f,	0.0f,	1.0f,
+			0.0f, 	1.0f, 	0.0f, 	1.0f,
+
 			0.5f,	-0.5f,	0.0f,	1.0f,
+			0.0f, 	0.0f, 	1.0f, 	1.0f,
 		};
-		constexpr float colours[] = {
-			1.0f, 0.0f, 0.0f, 1.0f,
-			0.0f, 1.0f, 0.0f, 1.0f,
-			0.0f, 0.0f, 1.0f, 1.0f,
-		};
-		_positionBuffer = [view.device newBufferWithBytes:positions length:sizeof(positions) options:MTLResourceOptionCPUCacheModeDefault];
-		_colourBuffer = [view.device newBufferWithBytes:colours length:sizeof(colours) options:MTLResourceOptionCPUCacheModeDefault];
+		_verticesBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceOptionCPUCacheModeDefault];
+
+		MTLVertexDescriptor *vertexDescriptor = [[MTLVertexDescriptor alloc] init];
+
+		// Position.
+		vertexDescriptor.attributes[0].bufferIndex = 0;
+		vertexDescriptor.attributes[0].offset = 0;
+		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat4;
+
+		// Colour.
+		vertexDescriptor.attributes[1].bufferIndex = 0;
+		vertexDescriptor.attributes[1].offset = sizeof(float)*4;
+		vertexDescriptor.attributes[1].format = MTLVertexFormatFloat4;
+
+		// Total vertex size.
+        vertexDescriptor.layouts[0].stride = sizeof(float) * 8;
 
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
@@ -48,6 +61,7 @@
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"vertex_main"];
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"fragment_main"];
 		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+		pipelineDescriptor.vertexDescriptor = vertexDescriptor;
 		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 	return self;
@@ -78,8 +92,7 @@
 
 	// Drawing. Just the test triangle, as described above.
 	[encoder setRenderPipelineState:_gouraudPipeline];
-	[encoder setVertexBuffer:_positionBuffer offset:0 atIndex:0];
-	[encoder setVertexBuffer:_colourBuffer offset:0 atIndex:1];
+	[encoder setVertexBuffer:_verticesBuffer offset:0 atIndex:0];
 	[encoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3 instanceCount:1];
 
 	// Complete encoding.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 6e5e1bef3..8384aec14 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -9,20 +9,27 @@
 #include <metal_stdlib>
 using namespace metal;
 
-struct ColoredVertex {
-	float4 position [[position]];
-	float4 color;
+// These two structs are the same, but defined separately as an artefact
+// of my learning process, and the fact that they soon won't be.
+
+struct InputVertex {
+	float4 position	[[attribute(0)]];
+	float4 colour	[[attribute(1)]];
 };
 
-vertex ColoredVertex vertex_main(	constant float4 *position [[buffer(0)]],
-									constant float4 *color [[buffer(1)]],
+struct ColouredVertex {
+	float4 position [[position]];
+	float4 colour;
+};
+
+vertex ColouredVertex vertex_main(	device const InputVertex *vertices [[buffer(0)]],
 									uint vid [[vertex_id]]) {
-	ColoredVertex vert;
-	vert.position = position[vid];
-	vert.color = color[vid];
-	return vert;
+	ColouredVertex output;
+	output.position = vertices[vid].position;
+	output.colour = vertices[vid].colour;
+	return output;
 }
 
-fragment float4 fragment_main(ColoredVertex vert [[stage_in]]) {
-	return vert.color;
+fragment float4 fragment_main(ColouredVertex vert [[stage_in]]) {
+	return vert.colour;
 }

From 219923bd636b6de757c8f14162ebe45225b67790 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 5 Aug 2020 21:33:25 -0400
Subject: [PATCH 006/131] Reduces vertex size, draws a quad.

---
 .../Clock Signal.xcodeproj/project.pbxproj    |  4 +--
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 25 +++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 11 ++++----
 3 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 1bf433bff..569160397 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -1010,7 +1010,7 @@
 		4B228CD624D773CA0077EF25 /* CSScanTarget.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = CSScanTarget.h; sourceTree = "<group>"; };
 		4B228CD724DA12C50077EF25 /* CSScanTargetView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CSScanTargetView.h; sourceTree = "<group>"; };
 		4B228CD824DA12C60077EF25 /* CSScanTargetView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CSScanTargetView.m; sourceTree = "<group>"; };
-		4B228CDA24DA41880077EF25 /* ScanTarget.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; name = ScanTarget.metal; path = "Clock Signal/ScanTarget/ScanTarget.metal"; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.metal; };
+		4B228CDA24DA41880077EF25 /* ScanTarget.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; path = ScanTarget.metal; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.metal; };
 		4B24095A1C45DF85004DA684 /* Stepper.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Stepper.hpp; sourceTree = "<group>"; };
 		4B2530F3244E6773007980BF /* fm.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = fm.json; sourceTree = "<group>"; };
 		4B2A332C1DB86821002876E3 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = "Clock Signal/Base.lproj/OricOptions.xib"; sourceTree = SOURCE_ROOT; };
@@ -2068,6 +2068,7 @@
 		4B228CD324D773B30077EF25 /* ScanTarget */ = {
 			isa = PBXGroup;
 			children = (
+				4B228CDA24DA41880077EF25 /* ScanTarget.metal */,
 				4B228CD424D773B30077EF25 /* CSScanTarget.mm */,
 				4B228CD624D773CA0077EF25 /* CSScanTarget.h */,
 			);
@@ -3325,7 +3326,6 @@
 		4BB73E951B587A5100552FC2 = {
 			isa = PBXGroup;
 			children = (
-				4B228CDA24DA41880077EF25 /* ScanTarget.metal */,
 				4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */,
 				4BC3C67B24C9230F0027BF76 /* BufferingScanTarget.hpp */,
 				4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */,
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a291ffb79..98e094260 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -29,14 +29,17 @@
 
 		// Generate some static buffers. AS A TEST.
 		constexpr float vertices[] = {
-			0.0f,	0.5f,	0.0f,	1.0f,	// Position.
-			1.0f, 	0.0f, 	0.0f, 	1.0f,	// Colour.
+			-0.9f,	-0.9f,			// Position.
+			1.0f, 	0.0f, 	0.0f,	// Colour.
 
-			-0.5f,	-0.5f,	0.0f,	1.0f,
-			0.0f, 	1.0f, 	0.0f, 	1.0f,
+			-0.9f,	0.9f,
+			0.0f, 	1.0f, 	0.0f,
 
-			0.5f,	-0.5f,	0.0f,	1.0f,
-			0.0f, 	0.0f, 	1.0f, 	1.0f,
+			0.9f,	-0.9f,
+			0.0f, 	0.0f, 	1.0f,
+
+			0.9f,	0.9f,
+			0.0f, 	1.0f, 	1.0f,
 		};
 		_verticesBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceOptionCPUCacheModeDefault];
 
@@ -45,15 +48,15 @@
 		// Position.
 		vertexDescriptor.attributes[0].bufferIndex = 0;
 		vertexDescriptor.attributes[0].offset = 0;
-		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat4;
+		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat2;
 
 		// Colour.
 		vertexDescriptor.attributes[1].bufferIndex = 0;
-		vertexDescriptor.attributes[1].offset = sizeof(float)*4;
-		vertexDescriptor.attributes[1].format = MTLVertexFormatFloat4;
+		vertexDescriptor.attributes[1].offset = sizeof(float)*2;
+		vertexDescriptor.attributes[1].format = MTLVertexFormatFloat3;
 
 		// Total vertex size.
-        vertexDescriptor.layouts[0].stride = sizeof(float) * 8;
+		vertexDescriptor.layouts[0].stride = sizeof(float)*5;
 
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
@@ -93,7 +96,7 @@
 	// Drawing. Just the test triangle, as described above.
 	[encoder setRenderPipelineState:_gouraudPipeline];
 	[encoder setVertexBuffer:_verticesBuffer offset:0 atIndex:0];
-	[encoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3 instanceCount:1];
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:1];
 
 	// Complete encoding.
 	[encoder endEncoding];
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 8384aec14..7e2a9822e 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -13,8 +13,8 @@ using namespace metal;
 // of my learning process, and the fact that they soon won't be.
 
 struct InputVertex {
-	float4 position	[[attribute(0)]];
-	float4 colour	[[attribute(1)]];
+	float2 position	[[attribute(0)]];
+	float3 colour	[[attribute(1)]];
 };
 
 struct ColouredVertex {
@@ -22,11 +22,10 @@ struct ColouredVertex {
 	float4 colour;
 };
 
-vertex ColouredVertex vertex_main(	device const InputVertex *vertices [[buffer(0)]],
-									uint vid [[vertex_id]]) {
+vertex ColouredVertex vertex_main(InputVertex vert [[stage_in]]) {
 	ColouredVertex output;
-	output.position = vertices[vid].position;
-	output.colour = vertices[vid].colour;
+	output.position = float4(vert.position, 0.0, 1.0);
+	output.colour = float4(vert.colour, 1.0);
 	return output;
 }
 

From 4c9418f59aea44fca4bc75732dd3cfcc41f35436 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 21:18:08 -0400
Subject: [PATCH 007/131] Guarantees alignof(4) on all GPU-bound structures.

Taken as given: Metal's requirement here is reasonable enough that it'll either be the same as other frameworks, or at least possibly help them down a fast path.
---
 Outputs/ScanTarget.hpp                      | 6 ++++--
 Outputs/ScanTargets/BufferingScanTarget.hpp | 7 ++++---
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index 63be212d1..0765eef46 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -210,9 +210,11 @@ struct ScanTarget {
 
 		/*!
 			Defines a scan in terms of its two endpoints.
+
+			Is guaranteed to be a multiple of four bytes in size.
 		*/
-		struct Scan {
-			struct EndPoint {
+		struct alignas(4) Scan {
+			struct alignas(4) EndPoint {
 				/// Provide the coordinate of this endpoint. These are fixed point, purely fractional
 				/// numbers, relative to the scale provided in the Modals.
 				uint16_t x, y;
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 1f6b40ae0..503681aa3 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -51,7 +51,7 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 
 		// Extends the definition of a Scan to include two extra fields,
 		// completing this scan's source data and destination locations.
-		struct Scan {
+		struct alignas(4) Scan {
 			Outputs::Display::ScanTarget::Scan scan;
 
 			/// Stores the y coordinate for this scan's data within the write area texture.
@@ -66,12 +66,13 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		/// Defines the boundaries of a complete line of video — a 2d start and end location,
 		/// composite phase and amplitude (if relevant), the source line in the intermediate buffer
 		/// plus the start and end offsets of the area that is visible from the intermediate buffer.
-		struct Line {
-			struct EndPoint {
+		struct alignas(4) Line {
+			struct alignas(4) EndPoint {
 				uint16_t x, y;
 				uint16_t cycles_since_end_of_horizontal_retrace;
 				int16_t composite_angle;
 			} end_points[2];
+
 			uint16_t line;
 			uint8_t composite_amplitude;
 		};

From 4421acef34d8acae159ee4a2b3dddc0a0f89718d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 21:19:17 -0400
Subject: [PATCH 008/131] Gets some uniforms in on the action.

With some effort towards scans, but incompletely so.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 65 +++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 45 ++++++++++---
 2 files changed, 75 insertions(+), 35 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 98e094260..533f58c0b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -10,16 +10,26 @@
 
 #import <Metal/Metal.h>
 
+namespace {
+
+struct Uniforms {
+	int32_t scale[2];
+	float lineWidth;
+};
+
+}
+
 @implementation CSScanTarget {
 	id<MTLCommandQueue> _commandQueue;
 
-	// TEST ONLY: to check that I'm drawing _something_, I'm heading towards ye standard
-	// Gouraud shading triangle. https://metalbyexample.com/up-and-running-2/ is providing
-	// much of the inspiration, albeit that I'm proceeding via MKLView.
 	id<MTLFunction> _vertexShader;
 	id<MTLFunction> _fragmentShader;
-	id<MTLBuffer> _verticesBuffer;
 	id<MTLRenderPipelineState> _gouraudPipeline;
+
+	// Buffers.
+	id<MTLBuffer> _quadBuffer;		// i.e. four vertices defining a quad.
+	id<MTLBuffer> _uniformsBuffer;
+	id<MTLBuffer> _scansBuffer;
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
@@ -27,42 +37,35 @@
 	if(self) {
 		_commandQueue = [view.device newCommandQueue];
 
-		// Generate some static buffers. AS A TEST.
+		// Install the standard quad.
 		constexpr float vertices[] = {
-			-0.9f,	-0.9f,			// Position.
-			1.0f, 	0.0f, 	0.0f,	// Colour.
-
+			-0.9f,	-0.9f,
 			-0.9f,	0.9f,
-			0.0f, 	1.0f, 	0.0f,
-
 			0.9f,	-0.9f,
-			0.0f, 	0.0f, 	1.0f,
-
 			0.9f,	0.9f,
-			0.0f, 	1.0f, 	1.0f,
 		};
-		_verticesBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceOptionCPUCacheModeDefault];
+		_quadBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceCPUCacheModeDefaultCache];
 
+		// Allocate space for uniforms.
+		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
+		Uniforms testUniforms = {
+			.scale = {0, 0},
+			.lineWidth = 0.1f
+		};
+		[self setUniforms:testUniforms];
+
+		// The quad buffer has only 2d positions.
 		MTLVertexDescriptor *vertexDescriptor = [[MTLVertexDescriptor alloc] init];
-
-		// Position.
 		vertexDescriptor.attributes[0].bufferIndex = 0;
 		vertexDescriptor.attributes[0].offset = 0;
 		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat2;
-
-		// Colour.
-		vertexDescriptor.attributes[1].bufferIndex = 0;
-		vertexDescriptor.attributes[1].offset = sizeof(float)*2;
-		vertexDescriptor.attributes[1].format = MTLVertexFormatFloat3;
-
-		// Total vertex size.
-		vertexDescriptor.layouts[0].stride = sizeof(float)*5;
+		vertexDescriptor.layouts[0].stride = sizeof(float)*2;
 
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"vertex_main"];
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"fragment_main"];
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMain"];
 		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
 		pipelineDescriptor.vertexDescriptor = vertexDescriptor;
 		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
@@ -70,6 +73,11 @@
 	return self;
 }
 
+- (void)setUniforms:(const Uniforms &)uniforms {
+	memcpy(_uniformsBuffer.contents, &uniforms, sizeof(Uniforms));
+//	[_uniformsBuffer didModifyRange:NSMakeRange(0, sizeof(Uniforms))];
+}
+
 /*!
  @method mtkView:drawableSizeWillChange:
  @abstract Called whenever the drawableSize of the view will change
@@ -95,7 +103,10 @@
 
 	// Drawing. Just the test triangle, as described above.
 	[encoder setRenderPipelineState:_gouraudPipeline];
-	[encoder setVertexBuffer:_verticesBuffer offset:0 atIndex:0];
+
+	[encoder setVertexBuffer:_quadBuffer offset:0 atIndex:0];
+	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+
 	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:1];
 
 	// Complete encoding.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 7e2a9822e..e95180d9c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -12,23 +12,52 @@ using namespace metal;
 // These two structs are the same, but defined separately as an artefact
 // of my learning process, and the fact that they soon won't be.
 
-struct InputVertex {
+struct Uniforms {
+	// This is used to scale scan positions, i.e. it provides the range
+	// for mapping from scan-style integer positions into eye space.
+	int2 scale						[[attribute(0)]];
+
+	// This provides the intended width of a scan, in eye-coordinate terms.
+	float lineWidth					[[attribute(1)]];
+};
+
+// This is intended to match `Scan` as defined by the BufferingScanTarget.
+// Fields have been combined as necessary to make them all at least four
+// bytes in size, since that is the required attribute alignment in Swift.
+struct Scan {
+	uint32_t startPosition			[[attribute(0)]];
+	uint32_t startOffsetAndAngle	[[attribute(1)]];
+	uint32_t startCycles			[[attribute(2)]];
+
+	uint32_t endPosition			[[attribute(3)]];
+	uint32_t endOffsetAndAngle		[[attribute(4)]];
+	uint32_t endCycles				[[attribute(5)]];
+
+	uint32_t compositeAmplitude		[[attribute(6)]];
+	uint32_t dataYAndLine			[[attribute(7)]];
+};
+
+// This is a custom thing defining one corner of a quad.
+struct QuadInputVertex {
 	float2 position	[[attribute(0)]];
-	float3 colour	[[attribute(1)]];
 };
 
 struct ColouredVertex {
 	float4 position [[position]];
-	float4 colour;
 };
 
-vertex ColouredVertex vertex_main(InputVertex vert [[stage_in]]) {
+
+// MARK: - Scan shaders; these do final output to the display.
+
+vertex ColouredVertex scanVertexMain(	QuadInputVertex vert [[stage_in]],
+										constant Uniforms &uniforms [[buffer(1)]],
+										constant Scan *scans [[buffer(2)]],
+										ushort instance [[instance_id]]) {
 	ColouredVertex output;
-	output.position = float4(vert.position, 0.0, 1.0);
-	output.colour = float4(vert.colour, 1.0);
+	output.position = float4(vert.position * uniforms.lineWidth, 0.0, 1.0);
 	return output;
 }
 
-fragment float4 fragment_main(ColouredVertex vert [[stage_in]]) {
-	return vert.colour;
+fragment float4 scanFragmentMain(ColouredVertex vert [[stage_in]]) {
+	return float4(1.0);
 }

From bb55ecc1015dc32bf6b50793260784145002c552 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 21:19:53 -0400
Subject: [PATCH 009/131] Disables --volume for kiosk mode testing.

---
 .../xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme        | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme
index 702ed8cf3..5a7adbb97 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme	
@@ -58,7 +58,7 @@
          </CommandLineArgument>
          <CommandLineArgument
             argument = "--volume=0.001"
-            isEnabled = "YES">
+            isEnabled = "NO">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "--new=amstradcpc"
@@ -94,7 +94,7 @@
          </CommandLineArgument>
          <CommandLineArgument
             argument = "--rompath=/Users/thomasharte/Projects/CLK/ROMImages"
-            isEnabled = "NO">
+            isEnabled = "YES">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "--help"

From 583f6b1ba21daf6fe8f18a32fbd382049fd8ba7e Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 22:03:27 -0400
Subject: [PATCH 010/131] Modifies BufferingScanTarget to allow has-a
 relationship.

I might switch fully to has-a. Further consideration required.
---
 Outputs/OpenGL/ScanTarget.hpp               | 2 +-
 Outputs/ScanTargets/BufferingScanTarget.hpp | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/Outputs/OpenGL/ScanTarget.hpp b/Outputs/OpenGL/ScanTarget.hpp
index 21e21962f..fb7a75db5 100644
--- a/Outputs/OpenGL/ScanTarget.hpp
+++ b/Outputs/OpenGL/ScanTarget.hpp
@@ -38,7 +38,7 @@ namespace OpenGL {
 	this uses various internal buffers so that the only geometry
 	drawn to the target framebuffer is a quad.
 */
-class ScanTarget: public Outputs::Display::BufferingScanTarget {
+class ScanTarget: public Outputs::Display::BufferingScanTarget {	// TODO: use private inheritance and expose only display_metrics() and a custom cast?
 	public:
 		ScanTarget(GLuint target_framebuffer = 0, float output_gamma = 2.2f);
 		~ScanTarget();
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 503681aa3..51a7fb6d3 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -39,7 +39,6 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		/*! @returns The DisplayMetrics object that this ScanTarget has been providing with announcements and draw overages. */
 		const Metrics &display_metrics();
 
-	protected:
 		static constexpr int WriteAreaWidth = 2048;
 		static constexpr int WriteAreaHeight = 2048;
 

From c575aa0640db9545194758a8055026dee983d47e Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 22:03:54 -0400
Subject: [PATCH 011/131] Adds a buffer for scans, and posts two test
 instances.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 37 ++++++++++++++++---
 1 file changed, 32 insertions(+), 5 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 533f58c0b..a806938c7 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -9,6 +9,7 @@
 #import "CSScanTarget.h"
 
 #import <Metal/Metal.h>
+#include "BufferingScanTarget.hpp"
 
 namespace {
 
@@ -17,6 +18,8 @@ struct Uniforms {
 	float lineWidth;
 };
 
+constexpr size_t NumBufferedScans = 2048;
+
 }
 
 @implementation CSScanTarget {
@@ -48,19 +51,27 @@ struct Uniforms {
 
 		// Allocate space for uniforms.
 		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
-		Uniforms testUniforms = {
-			.scale = {0, 0},
+		const Uniforms testUniforms = {
+			.scale = {1024, 1024},
 			.lineWidth = 0.1f
 		};
 		[self setUniforms:testUniforms];
 
-		// The quad buffer has only 2d positions.
+		// Allocate a large buffer for scans.
+		_scansBuffer = [view.device
+			newBufferWithLength:sizeof(Outputs::Display::BufferingScanTarget::Scan)*NumBufferedScans
+			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+		[self setTestScans];
+
+		// The quad buffer has only 2d positions; the scan buffer is a bit more complicated
 		MTLVertexDescriptor *vertexDescriptor = [[MTLVertexDescriptor alloc] init];
 		vertexDescriptor.attributes[0].bufferIndex = 0;
 		vertexDescriptor.attributes[0].offset = 0;
 		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat2;
 		vertexDescriptor.layouts[0].stride = sizeof(float)*2;
 
+		// Create a scans buffer, and for now just put two in there.
+
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
@@ -70,12 +81,27 @@ struct Uniforms {
 		pipelineDescriptor.vertexDescriptor = vertexDescriptor;
 		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
+
 	return self;
 }
 
 - (void)setUniforms:(const Uniforms &)uniforms {
 	memcpy(_uniformsBuffer.contents, &uniforms, sizeof(Uniforms));
-//	[_uniformsBuffer didModifyRange:NSMakeRange(0, sizeof(Uniforms))];
+}
+
+- (void)setTestScans {
+	Outputs::Display::BufferingScanTarget::Scan scans[2];
+	scans[0].scan.end_points[0].x = 0;
+	scans[0].scan.end_points[0].y = 0;
+	scans[0].scan.end_points[1].x = 1024;
+	scans[0].scan.end_points[1].y = 256;
+
+	scans[1].scan.end_points[0].x = 0;
+	scans[1].scan.end_points[0].y = 768;
+	scans[1].scan.end_points[1].x = 512;
+	scans[1].scan.end_points[1].y = 128;
+
+	memcpy(_scansBuffer.contents, scans, sizeof(scans));
 }
 
 /*!
@@ -106,8 +132,9 @@ struct Uniforms {
 
 	[encoder setVertexBuffer:_quadBuffer offset:0 atIndex:0];
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:2];
 
-	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:1];
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:2];
 
 	// Complete encoding.
 	[encoder endEncoding];

From fbda7aab230dfce5804c2d4bd3b27e7d146beefd Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 22:20:01 -0400
Subject: [PATCH 012/131] Does just enough to get the correct (aspect ratio
 aside) output of scan outlines.

So, up next, can I start streaming these things?
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 12 +++++------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 21 ++++++++++++++++++-
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a806938c7..76f774a6f 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -42,10 +42,10 @@ constexpr size_t NumBufferedScans = 2048;
 
 		// Install the standard quad.
 		constexpr float vertices[] = {
-			-0.9f,	-0.9f,
-			-0.9f,	0.9f,
-			0.9f,	-0.9f,
-			0.9f,	0.9f,
+			0.0f,	0.0f,
+			0.0f,	1.0f,
+			1.0f,	0.0f,
+			1.0f,	1.0f,
 		};
 		_quadBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceCPUCacheModeDefaultCache];
 
@@ -53,7 +53,7 @@ constexpr size_t NumBufferedScans = 2048;
 		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
 		const Uniforms testUniforms = {
 			.scale = {1024, 1024},
-			.lineWidth = 0.1f
+			.lineWidth = 1.0f / 312.0f
 		};
 		[self setUniforms:testUniforms];
 
@@ -99,7 +99,7 @@ constexpr size_t NumBufferedScans = 2048;
 	scans[1].scan.end_points[0].x = 0;
 	scans[1].scan.end_points[0].y = 768;
 	scans[1].scan.end_points[1].x = 512;
-	scans[1].scan.end_points[1].y = 128;
+	scans[1].scan.end_points[1].y = 512;
 
 	memcpy(_scansBuffer.contents, scans, sizeof(scans));
 }
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e95180d9c..e4610583e 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -53,8 +53,27 @@ vertex ColouredVertex scanVertexMain(	QuadInputVertex vert [[stage_in]],
 										constant Uniforms &uniforms [[buffer(1)]],
 										constant Scan *scans [[buffer(2)]],
 										ushort instance [[instance_id]]) {
+	// Unpack start and end vertices.
+	const float2 start = float2(
+		float(scans[instance].startPosition & 0xffff) / float(uniforms.scale.x),
+		float(scans[instance].startPosition >> 16) / float(uniforms.scale.y)
+	);
+	const float2 end = float2(
+		float(scans[instance].endPosition & 0xffff) / float(uniforms.scale.x),
+		float(scans[instance].endPosition >> 16) / float(uniforms.scale.y)
+	);
+
+	// Calculate the tangent and normal.
+	const float2 tangent = end - start;
+	const float2 normal = float2(-tangent.y, tangent.x) / length(tangent);
+
+	// Hence determine this quad's real shape.
 	ColouredVertex output;
-	output.position = float4(vert.position * uniforms.lineWidth, 0.0, 1.0);
+	output.position = float4(
+		(start + vert.position.x * tangent + vert.position.y * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0),
+		0.0,
+		1.0
+	);
 	return output;
 }
 

From 38960a08d62b1b45adb36705fc7296080fdb6d2c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 7 Aug 2020 22:29:24 -0400
Subject: [PATCH 013/131] Adds adjustment for display aspect ratio.

While also realising that I appear to be getting away without an MTLVertexDescriptor for Scans. Maybe OpenGL has prejudiced me, and they're actually optional for interleaved data?
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 24 +++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  9 ++++---
 2 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 76f774a6f..9ba322226 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -16,6 +16,7 @@ namespace {
 struct Uniforms {
 	int32_t scale[2];
 	float lineWidth;
+	float aspectRatioMultiplier;
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -33,6 +34,9 @@ constexpr size_t NumBufferedScans = 2048;
 	id<MTLBuffer> _quadBuffer;		// i.e. four vertices defining a quad.
 	id<MTLBuffer> _uniformsBuffer;
 	id<MTLBuffer> _scansBuffer;
+
+	// Current uniforms.
+	Uniforms _uniforms;
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
@@ -51,11 +55,11 @@ constexpr size_t NumBufferedScans = 2048;
 
 		// Allocate space for uniforms.
 		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
-		const Uniforms testUniforms = {
-			.scale = {1024, 1024},
-			.lineWidth = 1.0f / 312.0f
-		};
-		[self setUniforms:testUniforms];
+		_uniforms.scale[0] = 1024;
+		_uniforms.scale[1] = 1024;
+		_uniforms.lineWidth = 1.0f / 312.0f;
+		_uniforms.aspectRatioMultiplier = 1.0f;
+		[self setUniforms];
 
 		// Allocate a large buffer for scans.
 		_scansBuffer = [view.device
@@ -70,7 +74,7 @@ constexpr size_t NumBufferedScans = 2048;
 		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat2;
 		vertexDescriptor.layouts[0].stride = sizeof(float)*2;
 
-		// Create a scans buffer, and for now just put two in there.
+		// TODO: shouldn't I need to explain the Scan layout, too? Or do these things not need to be specified when compatible?
 
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
@@ -85,8 +89,8 @@ constexpr size_t NumBufferedScans = 2048;
 	return self;
 }
 
-- (void)setUniforms:(const Uniforms &)uniforms {
-	memcpy(_uniformsBuffer.contents, &uniforms, sizeof(Uniforms));
+- (void)setUniforms {
+	memcpy(_uniformsBuffer.contents, &_uniforms, sizeof(Uniforms));
 }
 
 - (void)setTestScans {
@@ -112,8 +116,8 @@ constexpr size_t NumBufferedScans = 2048;
  @param size New drawable size in pixels
  */
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
-	// I think (?) I don't care about this; the MKLView has already handled resizing the backing,
-	// which will naturally change the viewport.
+	_uniforms.aspectRatioMultiplier = float((4.0 / 3.0) / (size.width / size.height));
+	[self setUniforms];
 }
 
 /*!
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e4610583e..f64876228 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -17,8 +17,11 @@ struct Uniforms {
 	// for mapping from scan-style integer positions into eye space.
 	int2 scale						[[attribute(0)]];
 
-	// This provides the intended width of a scan, in eye-coordinate terms.
+	// This provides the intended height of a scan, in eye-coordinate terms.
 	float lineWidth					[[attribute(1)]];
+
+	// Provides a scaling factor in order to preserve 4:3 central content.
+	float aspectRatioMultiplier		[[attribute(2)]];
 };
 
 // This is intended to match `Scan` as defined by the BufferingScanTarget.
@@ -53,7 +56,7 @@ vertex ColouredVertex scanVertexMain(	QuadInputVertex vert [[stage_in]],
 										constant Uniforms &uniforms [[buffer(1)]],
 										constant Scan *scans [[buffer(2)]],
 										ushort instance [[instance_id]]) {
-	// Unpack start and end vertices.
+	// Unpack start and end vertices; little-endian numbers are assumed here.
 	const float2 start = float2(
 		float(scans[instance].startPosition & 0xffff) / float(uniforms.scale.x),
 		float(scans[instance].startPosition >> 16) / float(uniforms.scale.y)
@@ -70,7 +73,7 @@ vertex ColouredVertex scanVertexMain(	QuadInputVertex vert [[stage_in]],
 	// Hence determine this quad's real shape.
 	ColouredVertex output;
 	output.position = float4(
-		(start + vert.position.x * tangent + vert.position.y * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0),
+		((start + vert.position.x * tangent + vert.position.y * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
 		0.0,
 		1.0
 	);

From edf41b06fd9be57106b8a95e919daa6f2ed327c0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 8 Aug 2020 17:12:49 -0400
Subject: [PATCH 014/131] Eliminates the quad buffer.

Vertices can be adduced from vertex ID.
---
 .../Clock Signal.xcodeproj/project.pbxproj    |  2 ++
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 23 +--------------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 28 +++++++------------
 3 files changed, 13 insertions(+), 40 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 569160397..7d3950137 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -5169,6 +5169,7 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
@@ -5220,6 +5221,7 @@
 				GCC_WARN_UNUSED_VARIABLE = YES;
 				MACOSX_DEPLOYMENT_TARGET = 10.11;
 				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
 				SDKROOT = macosx;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
 				SWIFT_SWIFT3_OBJC_INFERENCE = Default;
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9ba322226..e0d43e632 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -31,7 +31,6 @@ constexpr size_t NumBufferedScans = 2048;
 	id<MTLRenderPipelineState> _gouraudPipeline;
 
 	// Buffers.
-	id<MTLBuffer> _quadBuffer;		// i.e. four vertices defining a quad.
 	id<MTLBuffer> _uniformsBuffer;
 	id<MTLBuffer> _scansBuffer;
 
@@ -44,15 +43,6 @@ constexpr size_t NumBufferedScans = 2048;
 	if(self) {
 		_commandQueue = [view.device newCommandQueue];
 
-		// Install the standard quad.
-		constexpr float vertices[] = {
-			0.0f,	0.0f,
-			0.0f,	1.0f,
-			1.0f,	0.0f,
-			1.0f,	1.0f,
-		};
-		_quadBuffer = [view.device newBufferWithBytes:vertices length:sizeof(vertices) options:MTLResourceCPUCacheModeDefaultCache];
-
 		// Allocate space for uniforms.
 		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
 		_uniforms.scale[0] = 1024;
@@ -67,22 +57,12 @@ constexpr size_t NumBufferedScans = 2048;
 			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
 		[self setTestScans];
 
-		// The quad buffer has only 2d positions; the scan buffer is a bit more complicated
-		MTLVertexDescriptor *vertexDescriptor = [[MTLVertexDescriptor alloc] init];
-		vertexDescriptor.attributes[0].bufferIndex = 0;
-		vertexDescriptor.attributes[0].offset = 0;
-		vertexDescriptor.attributes[0].format = MTLVertexFormatFloat2;
-		vertexDescriptor.layouts[0].stride = sizeof(float)*2;
-
-		// TODO: shouldn't I need to explain the Scan layout, too? Or do these things not need to be specified when compatible?
-
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMain"];
 		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
-		pipelineDescriptor.vertexDescriptor = vertexDescriptor;
 		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 
@@ -134,9 +114,8 @@ constexpr size_t NumBufferedScans = 2048;
 	// Drawing. Just the test triangle, as described above.
 	[encoder setRenderPipelineState:_gouraudPipeline];
 
-	[encoder setVertexBuffer:_quadBuffer offset:0 atIndex:0];
+	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
-	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:2];
 
 	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:2];
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index f64876228..dd839dbc5 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -9,9 +9,6 @@
 #include <metal_stdlib>
 using namespace metal;
 
-// These two structs are the same, but defined separately as an artefact
-// of my learning process, and the fact that they soon won't be.
-
 struct Uniforms {
 	// This is used to scale scan positions, i.e. it provides the range
 	// for mapping from scan-style integer positions into eye space.
@@ -40,11 +37,6 @@ struct Scan {
 	uint32_t dataYAndLine			[[attribute(7)]];
 };
 
-// This is a custom thing defining one corner of a quad.
-struct QuadInputVertex {
-	float2 position	[[attribute(0)]];
-};
-
 struct ColouredVertex {
 	float4 position [[position]];
 };
@@ -52,28 +44,28 @@ struct ColouredVertex {
 
 // MARK: - Scan shaders; these do final output to the display.
 
-vertex ColouredVertex scanVertexMain(	QuadInputVertex vert [[stage_in]],
-										constant Uniforms &uniforms [[buffer(1)]],
-										constant Scan *scans [[buffer(2)]],
-										ushort instance [[instance_id]]) {
+vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
+										constant Scan *scans [[buffer(0)]],
+										uint instanceID [[instance_id]],
+										uint vertexID [[vertex_id]]) {
 	// Unpack start and end vertices; little-endian numbers are assumed here.
 	const float2 start = float2(
-		float(scans[instance].startPosition & 0xffff) / float(uniforms.scale.x),
-		float(scans[instance].startPosition >> 16) / float(uniforms.scale.y)
+		float(scans[instanceID].startPosition & 0xffff) / float(uniforms.scale.x),
+		float(scans[instanceID].startPosition >> 16) / float(uniforms.scale.y)
 	);
 	const float2 end = float2(
-		float(scans[instance].endPosition & 0xffff) / float(uniforms.scale.x),
-		float(scans[instance].endPosition >> 16) / float(uniforms.scale.y)
+		float(scans[instanceID].endPosition & 0xffff) / float(uniforms.scale.x),
+		float(scans[instanceID].endPosition >> 16) / float(uniforms.scale.y)
 	);
 
 	// Calculate the tangent and normal.
-	const float2 tangent = end - start;
+	const float2 tangent = (end - start);
 	const float2 normal = float2(-tangent.y, tangent.x) / length(tangent);
 
 	// Hence determine this quad's real shape.
 	ColouredVertex output;
 	output.position = float4(
-		((start + vert.position.x * tangent + vert.position.y * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
+		((start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
 		0.0,
 		1.0
 	);

From bdcf266e45ba045218cd4796d3bade14c7537235 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 8 Aug 2020 17:27:32 -0400
Subject: [PATCH 015/131] Having learnt a bit more: eliminates Metal
 `attribute` tags, switches to more natural expression of structs.

Also thereby eliminates the need for a forced alignas(4) on various structs.
---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 58 +++++++++++--------
 Outputs/ScanTarget.hpp                        |  6 +-
 Outputs/ScanTargets/BufferingScanTarget.hpp   |  6 +-
 3 files changed, 40 insertions(+), 30 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index dd839dbc5..b75921fde 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -12,31 +12,43 @@ using namespace metal;
 struct Uniforms {
 	// This is used to scale scan positions, i.e. it provides the range
 	// for mapping from scan-style integer positions into eye space.
-	int2 scale						[[attribute(0)]];
+	int2 scale;
 
 	// This provides the intended height of a scan, in eye-coordinate terms.
-	float lineWidth					[[attribute(1)]];
+	float lineWidth;
 
 	// Provides a scaling factor in order to preserve 4:3 central content.
-	float aspectRatioMultiplier		[[attribute(2)]];
+	float aspectRatioMultiplier;
 };
 
-// This is intended to match `Scan` as defined by the BufferingScanTarget.
-// Fields have been combined as necessary to make them all at least four
-// bytes in size, since that is the required attribute alignment in Swift.
+// This is intended to match the net effect of `Scan` as defined by the BufferingScanTarget.
 struct Scan {
-	uint32_t startPosition			[[attribute(0)]];
-	uint32_t startOffsetAndAngle	[[attribute(1)]];
-	uint32_t startCycles			[[attribute(2)]];
+	struct EndPoint {
+		uint16_t position[2];
+		uint16_t dataOffset;
+		uint16_t compositeAngle;
+		uint16_t cyclesSinceRetrace;
+	} endPoints[2];
 
-	uint32_t endPosition			[[attribute(3)]];
-	uint32_t endOffsetAndAngle		[[attribute(4)]];
-	uint32_t endCycles				[[attribute(5)]];
-
-	uint32_t compositeAmplitude		[[attribute(6)]];
-	uint32_t dataYAndLine			[[attribute(7)]];
+	uint8_t compositeAmplitude;
+	uint16_t dataY;
+	uint16_t line;
 };
 
+// This matches the BufferingScanTarget's `Line`.
+struct Line {
+	struct EndPoint {
+		uint16_t position[2];
+		uint16_t cyclesSinceRetrace;
+		uint16_t compositeAngle;
+	} endPoints[2];
+
+	uint16_t line;
+	uint8_t compositeAmplitude;
+};
+
+
+// This is an intermediate struct, which is TEMPORARY.
 struct ColouredVertex {
 	float4 position [[position]];
 };
@@ -48,21 +60,21 @@ vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
 										constant Scan *scans [[buffer(0)]],
 										uint instanceID [[instance_id]],
 										uint vertexID [[vertex_id]]) {
-	// Unpack start and end vertices; little-endian numbers are assumed here.
+	// Get start and end vertices in regular float2 form.
 	const float2 start = float2(
-		float(scans[instanceID].startPosition & 0xffff) / float(uniforms.scale.x),
-		float(scans[instanceID].startPosition >> 16) / float(uniforms.scale.y)
+		float(scans[instanceID].endPoints[0].position[0]) / float(uniforms.scale.x),
+		float(scans[instanceID].endPoints[0].position[1]) / float(uniforms.scale.y)
 	);
 	const float2 end = float2(
-		float(scans[instanceID].endPosition & 0xffff) / float(uniforms.scale.x),
-		float(scans[instanceID].endPosition >> 16) / float(uniforms.scale.y)
+		float(scans[instanceID].endPoints[1].position[0]) / float(uniforms.scale.x),
+		float(scans[instanceID].endPoints[1].position[1]) / float(uniforms.scale.y)
 	);
 
 	// Calculate the tangent and normal.
 	const float2 tangent = (end - start);
 	const float2 normal = float2(-tangent.y, tangent.x) / length(tangent);
 
-	// Hence determine this quad's real shape.
+	// Hence determine this quad's real shape, using vertexID to pick a corner.
 	ColouredVertex output;
 	output.position = float4(
 		((start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
@@ -72,6 +84,6 @@ vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
 	return output;
 }
 
-fragment float4 scanFragmentMain(ColouredVertex vert [[stage_in]]) {
-	return float4(1.0);
+fragment half4 scanFragmentMain(ColouredVertex vert [[stage_in]]) {
+	return half4(1.0);
 }
diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index 0765eef46..63be212d1 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -210,11 +210,9 @@ struct ScanTarget {
 
 		/*!
 			Defines a scan in terms of its two endpoints.
-
-			Is guaranteed to be a multiple of four bytes in size.
 		*/
-		struct alignas(4) Scan {
-			struct alignas(4) EndPoint {
+		struct Scan {
+			struct EndPoint {
 				/// Provide the coordinate of this endpoint. These are fixed point, purely fractional
 				/// numbers, relative to the scale provided in the Modals.
 				uint16_t x, y;
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 51a7fb6d3..85d186c68 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -50,7 +50,7 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 
 		// Extends the definition of a Scan to include two extra fields,
 		// completing this scan's source data and destination locations.
-		struct alignas(4) Scan {
+		struct Scan {
 			Outputs::Display::ScanTarget::Scan scan;
 
 			/// Stores the y coordinate for this scan's data within the write area texture.
@@ -65,8 +65,8 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		/// Defines the boundaries of a complete line of video — a 2d start and end location,
 		/// composite phase and amplitude (if relevant), the source line in the intermediate buffer
 		/// plus the start and end offsets of the area that is visible from the intermediate buffer.
-		struct alignas(4) Line {
-			struct alignas(4) EndPoint {
+		struct Line {
+			struct EndPoint {
 				uint16_t x, y;
 				uint16_t cycles_since_end_of_horizontal_retrace;
 				int16_t composite_angle;

From df89a8771c7694208a376373bb9689e45faea810 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 8 Aug 2020 22:49:02 -0400
Subject: [PATCH 016/131] Makes an attempt to have the emulator fill the actual
 GPU buffers.

Not that they're drawn from correctly yet. I might first take a run at a new quick-path output route for emulated RGB displays, that just seeks to use the scans directly. No intermediate buffers. Besides probably being a good feature, it'll be a good way to ramp further up with Metal.
---
 .../Clock Signal.xcodeproj/project.pbxproj    |  2 ++
 .../Mac/Clock Signal/Machine/CSMachine.mm     | 11 ++-----
 .../ScanTarget/CSScanTarget+CppScanTarget.h   | 16 +++++++++
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 33 +++++++++++++++++--
 .../Mac/Clock Signal/Views/CSScanTargetView.h |  6 ++++
 .../Mac/Clock Signal/Views/CSScanTargetView.m |  4 +++
 6 files changed, 60 insertions(+), 12 deletions(-)
 create mode 100644 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget+CppScanTarget.h

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 7d3950137..89cbfcc01 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -1122,6 +1122,7 @@
 		4B4DC8271D2C2470003C5BF8 /* C1540.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = C1540.hpp; sourceTree = "<group>"; };
 		4B4DC8291D2C27A4003C5BF8 /* SerialBus.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SerialBus.cpp; sourceTree = "<group>"; };
 		4B4DC82A1D2C27A4003C5BF8 /* SerialBus.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = SerialBus.hpp; sourceTree = "<group>"; };
+		4B4F2B7024DF99D4000DA6B0 /* CSScanTarget+CppScanTarget.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "CSScanTarget+CppScanTarget.h"; sourceTree = "<group>"; };
 		4B50AF7F242817F40099BBD7 /* QuartzCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuartzCore.framework; path = System/Library/Frameworks/QuartzCore.framework; sourceTree = SDKROOT; };
 		4B51F70920A521D700AFA2C1 /* Source.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Source.hpp; sourceTree = "<group>"; };
 		4B51F70A20A521D700AFA2C1 /* Observer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = Observer.hpp; sourceTree = "<group>"; };
@@ -2071,6 +2072,7 @@
 				4B228CDA24DA41880077EF25 /* ScanTarget.metal */,
 				4B228CD424D773B30077EF25 /* CSScanTarget.mm */,
 				4B228CD624D773CA0077EF25 /* CSScanTarget.h */,
+				4B4F2B7024DF99D4000DA6B0 /* CSScanTarget+CppScanTarget.h */,
 			);
 			path = ScanTarget;
 			sourceTree = "<group>";
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index b3c2f4bf5..5f05d5c5c 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -11,7 +11,7 @@
 
 #import "CSHighPrecisionTimer.h"
 #include "CSROMFetcher.hpp"
-#import "CSScanTarget.h"
+#import "CSScanTarget+CppScanTarget.h"
 
 #include "MediaTarget.hpp"
 #include "JoystickMachine.hpp"
@@ -353,14 +353,7 @@ struct ActivityObserver: public Activity::Observer {
 - (void)setView:(CSScanTargetView *)view aspectRatio:(float)aspectRatio {
 	_view = view;
 	_view.displayLinkDelegate = self;
-//	[view performWithGLContext:^{
-//		[self setupOutputWithAspectRatio:aspectRatio];
-//	} flushDrawable:NO];
-}
-
-- (void)setupOutputWithAspectRatio:(float)aspectRatio {
-//	_scanTarget = std::make_unique<Outputs::Display::OpenGL::ScanTarget>();
-//	_machine->scan_producer()->set_scan_target(_scanTarget.get());
+	_machine->scan_producer()->set_scan_target(_view.scanTarget.scanTarget);
 }
 
 - (void)updateViewForPixelSize:(CGSize)pixelSize {
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget+CppScanTarget.h b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget+CppScanTarget.h
new file mode 100644
index 000000000..d0dbc0a69
--- /dev/null
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget+CppScanTarget.h	
@@ -0,0 +1,16 @@
+//
+//  CSScanTarget+C__ScanTarget.h
+//  Clock Signal
+//
+//  Created by Thomas Harte on 08/08/2020.
+//  Copyright © 2020 Thomas Harte. All rights reserved.
+//
+
+#import "CSScanTarget.h"
+#include "ScanTarget.hpp"
+
+@interface CSScanTarget (CppScanTarget)
+
+@property (nonatomic, readonly, nonnull) Outputs::Display::ScanTarget *scanTarget;
+
+@end
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index e0d43e632..e6fe5b31d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -20,9 +20,12 @@ struct Uniforms {
 };
 
 constexpr size_t NumBufferedScans = 2048;
+constexpr size_t NumBufferedLines = 2048;
 
 }
 
+using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
+
 @implementation CSScanTarget {
 	id<MTLCommandQueue> _commandQueue;
 
@@ -32,10 +35,17 @@ constexpr size_t NumBufferedScans = 2048;
 
 	// Buffers.
 	id<MTLBuffer> _uniformsBuffer;
+
 	id<MTLBuffer> _scansBuffer;
+	id<MTLBuffer> _linesBuffer;
+	id<MTLBuffer> _writeAreaBuffer;
 
 	// Current uniforms.
 	Uniforms _uniforms;
+
+	// The scan target in C++-world terms and the non-GPU storage for it.
+	BufferingScanTarget _scanTarget;
+	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
@@ -43,7 +53,7 @@ constexpr size_t NumBufferedScans = 2048;
 	if(self) {
 		_commandQueue = [view.device newCommandQueue];
 
-		// Allocate space for uniforms.
+		// Allocate space for uniforms and FOR TEST PURPOSES set some.
 		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
 		_uniforms.scale[0] = 1024;
 		_uniforms.scale[1] = 1024;
@@ -51,10 +61,23 @@ constexpr size_t NumBufferedScans = 2048;
 		_uniforms.aspectRatioMultiplier = 1.0f;
 		[self setUniforms];
 
-		// Allocate a large buffer for scans.
+		// Allocate buffers for scans and lines and for the write area texture.
 		_scansBuffer = [view.device
 			newBufferWithLength:sizeof(Outputs::Display::BufferingScanTarget::Scan)*NumBufferedScans
 			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+		_linesBuffer = [view.device
+			newBufferWithLength:sizeof(Outputs::Display::BufferingScanTarget::Line)*NumBufferedLines
+			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+		_writeAreaBuffer = [view.device
+			newBufferWithLength:BufferingScanTarget::WriteAreaWidth*BufferingScanTarget::WriteAreaHeight*4
+			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+
+		// Install all that storage in the buffering scan target.
+		_scanTarget.set_write_area(reinterpret_cast<uint8_t *>(_writeAreaBuffer.contents));
+		_scanTarget.set_line_buffer(reinterpret_cast<BufferingScanTarget::Line *>(_linesBuffer.contents), _lineMetadataBuffer, NumBufferedLines);
+		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
+
+		// TEST ONLY: set some test data.
 		[self setTestScans];
 
 		// Generate TEST pipeline.
@@ -74,7 +97,7 @@ constexpr size_t NumBufferedScans = 2048;
 }
 
 - (void)setTestScans {
-	Outputs::Display::BufferingScanTarget::Scan scans[2];
+	BufferingScanTarget::Scan scans[2];
 	scans[0].scan.end_points[0].x = 0;
 	scans[0].scan.end_points[0].y = 0;
 	scans[0].scan.end_points[1].x = 1024;
@@ -129,4 +152,8 @@ constexpr size_t NumBufferedScans = 2048;
 	[commandBuffer commit];
 }
 
+-  (Outputs::Display::ScanTarget *)scanTarget {
+	return &_scanTarget;
+}
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
index eac99397c..57e51b62f 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
@@ -11,6 +11,7 @@
 #import <MetalKit/MetalKit.h>
 
 @class CSScanTargetView;
+@class CSScanTarget;
 
 typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 	/// Indicates that AppKit requested a redraw for some reason (mostly likely, the window is being resized). So,
@@ -179,4 +180,9 @@ typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 */
 - (void)releaseMouse;
 
+/*!
+	@returns The CSScanTarget being used for this display.
+*/
+@property(nonatomic, readonly, nonnull) CSScanTarget *scanTarget;
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index dd2907d3d..eb6888f63 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -164,6 +164,10 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	CVDisplayLinkRelease(_displayLink);
 }
 
+- (CSScanTarget *)scanTarget {
+	return _scanTarget;
+}
+
 - (CGSize)backingSize {
 	@synchronized(self) {
 		return _backingSize;

From e340685a999fa3b9e59036c4cd6363b262524653 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 8 Aug 2020 23:11:44 -0400
Subject: [PATCH 017/131] Seemingly proves that proper geometry is reaching
 Metal by drawing scans.

No in-buffer accumulation yet, but this is progress. If I can add accumulation and stencil clearing, I'm not doing badly.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 66 +++++++++----------
 1 file changed, 31 insertions(+), 35 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index e6fe5b31d..a87839085 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -8,6 +8,7 @@
 
 #import "CSScanTarget.h"
 
+#include <atomic>
 #import <Metal/Metal.h>
 #include "BufferingScanTarget.hpp"
 
@@ -22,6 +23,8 @@ struct Uniforms {
 constexpr size_t NumBufferedScans = 2048;
 constexpr size_t NumBufferedLines = 2048;
 
+#define uniforms() reinterpret_cast<Uniforms *>(_uniformsBuffer.contents)
+
 }
 
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
@@ -40,12 +43,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLBuffer> _linesBuffer;
 	id<MTLBuffer> _writeAreaBuffer;
 
-	// Current uniforms.
-	Uniforms _uniforms;
-
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
+	std::atomic_bool _isDrawing;
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
@@ -53,13 +54,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	if(self) {
 		_commandQueue = [view.device newCommandQueue];
 
-		// Allocate space for uniforms and FOR TEST PURPOSES set some.
-		_uniformsBuffer = [view.device newBufferWithLength:16 options:MTLResourceCPUCacheModeWriteCombined];
-		_uniforms.scale[0] = 1024;
-		_uniforms.scale[1] = 1024;
-		_uniforms.lineWidth = 1.0f / 312.0f;
-		_uniforms.aspectRatioMultiplier = 1.0f;
-		[self setUniforms];
+		// Allocate space for uniforms.
+		_uniformsBuffer = [view.device
+			newBufferWithLength:sizeof(Uniforms)
+			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
 
 		// Allocate buffers for scans and lines and for the write area texture.
 		_scansBuffer = [view.device
@@ -77,9 +75,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_scanTarget.set_line_buffer(reinterpret_cast<BufferingScanTarget::Line *>(_linesBuffer.contents), _lineMetadataBuffer, NumBufferedLines);
 		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
 
-		// TEST ONLY: set some test data.
-		[self setTestScans];
-
 		// Generate TEST pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
@@ -92,25 +87,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	return self;
 }
 
-- (void)setUniforms {
-	memcpy(_uniformsBuffer.contents, &_uniforms, sizeof(Uniforms));
-}
-
-- (void)setTestScans {
-	BufferingScanTarget::Scan scans[2];
-	scans[0].scan.end_points[0].x = 0;
-	scans[0].scan.end_points[0].y = 0;
-	scans[0].scan.end_points[1].x = 1024;
-	scans[0].scan.end_points[1].y = 256;
-
-	scans[1].scan.end_points[0].x = 0;
-	scans[1].scan.end_points[0].y = 768;
-	scans[1].scan.end_points[1].x = 512;
-	scans[1].scan.end_points[1].y = 512;
-
-	memcpy(_scansBuffer.contents, scans, sizeof(scans));
-}
-
 /*!
  @method mtkView:drawableSizeWillChange:
  @abstract Called whenever the drawableSize of the view will change
@@ -119,8 +95,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @param size New drawable size in pixels
  */
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
-	_uniforms.aspectRatioMultiplier = float((4.0 / 3.0) / (size.width / size.height));
-	[self setUniforms];
+	uniforms()->aspectRatioMultiplier = float((4.0 / 3.0) / (size.width / size.height));
 }
 
 /*!
@@ -134,13 +109,34 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
 	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
 
+	const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
+	if(newModals) {
+		uniforms()->scale[0] = newModals->output_scale.x;
+		uniforms()->scale[1] = newModals->output_scale.y;
+		uniforms()->lineWidth = 1.0f / newModals->expected_vertical_lines;
+
+		// TODO: establish at least a texture. Obey the rest of the modals generally.
+	}
+
 	// Drawing. Just the test triangle, as described above.
 	[encoder setRenderPipelineState:_gouraudPipeline];
 
 	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
 
-	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:2];
+	_scanTarget.perform([=] (const BufferingScanTarget::OutputArea &outputArea) {
+		// TEMPORARY: just draw the scans.
+		if(outputArea.start.scan != outputArea.end.scan) {
+			if(outputArea.start.scan < outputArea.end.scan) {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
+			} else {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
+				if(outputArea.end.scan) {
+					[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
+				}
+			}
+		}
+	});
 
 	// Complete encoding.
 	[encoder endEncoding];

From f16ad8f71d8aafa6653fc90db19390171c8bdae8 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 17:59:52 -0400
Subject: [PATCH 018/131] Takes a shot at submitting texture changes.

---
 .../Clock Signal.xcodeproj/project.pbxproj    |  4 +-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 61 ++++++++++++++++---
 2 files changed, 56 insertions(+), 9 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 89cbfcc01..c84f1a594 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -5169,7 +5169,7 @@
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.11;
+				MACOSX_DEPLOYMENT_TARGET = 10.13;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -5221,7 +5221,7 @@
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_PARAMETER = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				MACOSX_DEPLOYMENT_TARGET = 10.11;
+				MACOSX_DEPLOYMENT_TARGET = 10.13;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				SDKROOT = macosx;
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a87839085..9d1097390 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -23,6 +23,12 @@ struct Uniforms {
 constexpr size_t NumBufferedScans = 2048;
 constexpr size_t NumBufferedLines = 2048;
 
+/// The shared resource options this app would most favour; applied as widely as possible.
+constexpr MTLResourceOptions SharedResourceOptionsStandard = MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared;
+
+/// The shared resource options used for the write-area texture; on macOS it can't be MTLResourceStorageModeShared so this is a carve-out.
+constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeManaged;
+
 #define uniforms() reinterpret_cast<Uniforms *>(_uniformsBuffer.contents)
 
 }
@@ -43,6 +49,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLBuffer> _linesBuffer;
 	id<MTLBuffer> _writeAreaBuffer;
 
+	// Textures.
+	id<MTLTexture> _writeAreaTexture;
+	size_t _bytesPerInputPixel;
+	size_t _totalTextureBytes;
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
@@ -62,13 +73,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Allocate buffers for scans and lines and for the write area texture.
 		_scansBuffer = [view.device
 			newBufferWithLength:sizeof(Outputs::Display::BufferingScanTarget::Scan)*NumBufferedScans
-			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+			options:SharedResourceOptionsStandard];
 		_linesBuffer = [view.device
 			newBufferWithLength:sizeof(Outputs::Display::BufferingScanTarget::Line)*NumBufferedLines
-			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+			options:SharedResourceOptionsStandard];
 		_writeAreaBuffer = [view.device
 			newBufferWithLength:BufferingScanTarget::WriteAreaWidth*BufferingScanTarget::WriteAreaHeight*4
-			options:MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared];
+			options:SharedResourceOptionsTexture];
 
 		// Install all that storage in the buffering scan target.
 		_scanTarget.set_write_area(reinterpret_cast<uint8_t *>(_writeAreaBuffer.contents));
@@ -115,7 +126,30 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		uniforms()->scale[1] = newModals->output_scale.y;
 		uniforms()->lineWidth = 1.0f / newModals->expected_vertical_lines;
 
-		// TODO: establish at least a texture. Obey the rest of the modals generally.
+		// TODO: obey the rest of the modals generally.
+
+		// Generate the appropriate input texture.
+		MTLPixelFormat pixelFormat;
+		_bytesPerInputPixel = size_for_data_type(newModals->input_data_type);
+		switch(_bytesPerInputPixel) {
+			default:
+			case 1: pixelFormat = MTLPixelFormatR8Unorm;	break;
+			case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
+			case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
+		}
+		MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor
+			texture2DDescriptorWithPixelFormat:pixelFormat
+			width:BufferingScanTarget::WriteAreaWidth
+			height:BufferingScanTarget::WriteAreaHeight
+			mipmapped:NO];
+		textureDescriptor.resourceOptions = SharedResourceOptionsTexture;
+
+		// TODO: the call below is the only reason why this project now requires macOS 10.13; is it all that helpful versus just uploading each frame?
+		_writeAreaTexture = [_writeAreaBuffer
+			newTextureWithDescriptor:textureDescriptor
+			offset:0
+			bytesPerRow:BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel];
+		_totalTextureBytes = BufferingScanTarget::WriteAreaWidth * BufferingScanTarget::WriteAreaHeight * _bytesPerInputPixel;
 	}
 
 	// Drawing. Just the test triangle, as described above.
@@ -125,6 +159,21 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
 
 	_scanTarget.perform([=] (const BufferingScanTarget::OutputArea &outputArea) {
+		// Ensure texture changes are noted.
+		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y) * _bytesPerInputPixel;
+		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y) * _bytesPerInputPixel;
+		if(writeAreaModificationStart != writeAreaModificationEnd) {
+			if(writeAreaModificationStart < writeAreaModificationEnd) {
+				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
+			} else {
+				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
+				if(writeAreaModificationEnd) {
+					[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
+				}
+			}
+
+		}
+
 		// TEMPORARY: just draw the scans.
 		if(outputArea.start.scan != outputArea.end.scan) {
 			if(outputArea.start.scan < outputArea.end.scan) {
@@ -141,10 +190,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// Complete encoding.
 	[encoder endEncoding];
 
-	// "Register the drawable's presentation".
+	// Register the drawable's presentation, finalise and commit.
 	[commandBuffer presentDrawable:view.currentDrawable];
-
-	// Finalise and commit.
 	[commandBuffer commit];
 }
 

From cd491bb6e0e10f1f4435a75206fb31b358bc8e21 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 18:27:57 -0400
Subject: [PATCH 019/131] Cleans up project file; macOS 10.13 is definitely the
 deployment target.

---
 OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj | 2 --
 1 file changed, 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index c84f1a594..88403b335 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -5262,7 +5262,6 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				INFOPLIST_FILE = "Clock Signal/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
-				MACOSX_DEPLOYMENT_TARGET = 10.12.2;
 				OTHER_CPLUSPLUSFLAGS = (
 					"$(OTHER_CFLAGS)",
 					"-Wreorder",
@@ -5310,7 +5309,6 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				INFOPLIST_FILE = "Clock Signal/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
-				MACOSX_DEPLOYMENT_TARGET = 10.12.2;
 				OTHER_CPLUSPLUSFLAGS = (
 					"$(OTHER_CFLAGS)",
 					"-Wreorder",

From 57fecdc09e1659db9ec17e9856448e7e77d21ffb Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 18:41:15 -0400
Subject: [PATCH 020/131] Ties everything together in an attempt to display RGB
 scans.

I'm actually just getting a mess of pixels, but it's something!
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 33 ++++++++++---------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 12 +++++--
 2 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9d1097390..8d8b2bc7b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -40,7 +40,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	id<MTLFunction> _vertexShader;
 	id<MTLFunction> _fragmentShader;
-	id<MTLRenderPipelineState> _gouraudPipeline;
+	id<MTLRenderPipelineState> _scanPipeline;
 
 	// Buffers.
 	id<MTLBuffer> _uniformsBuffer;
@@ -85,14 +85,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_scanTarget.set_write_area(reinterpret_cast<uint8_t *>(_writeAreaBuffer.contents));
 		_scanTarget.set_line_buffer(reinterpret_cast<BufferingScanTarget::Line *>(_linesBuffer.contents), _lineMetadataBuffer, NumBufferedLines);
 		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
-
-		// Generate TEST pipeline.
-		id<MTLLibrary> library = [view.device newDefaultLibrary];
-		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMain"];
-		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
-		_gouraudPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 
 	return self;
@@ -115,11 +107,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @discussion Called on the delegate when it is asked to render into the view
  */
 - (void)drawInMTKView:(nonnull MTKView *)view {
-	// Generate a command encoder for the view.
-	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
-	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
-
 	const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
 	if(newModals) {
 		uniforms()->scale[0] = newModals->output_scale.x;
@@ -150,11 +137,25 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			offset:0
 			bytesPerRow:BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel];
 		_totalTextureBytes = BufferingScanTarget::WriteAreaWidth * BufferingScanTarget::WriteAreaHeight * _bytesPerInputPixel;
+
+		// Generate pipeline.
+		id<MTLLibrary> library = [view.device newDefaultLibrary];
+		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMain"];
+		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+		_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 
-	// Drawing. Just the test triangle, as described above.
-	[encoder setRenderPipelineState:_gouraudPipeline];
+	// Generate a command encoder for the view.
+	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
+	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
 
+	// Drawing. Just scans.
+	[encoder setRenderPipelineState:_scanPipeline];
+
+	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
 	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index b75921fde..e54400af8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -51,6 +51,7 @@ struct Line {
 // This is an intermediate struct, which is TEMPORARY.
 struct ColouredVertex {
 	float4 position [[position]];
+	float2 textureCoordinates;
 };
 
 
@@ -81,9 +82,16 @@ vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
 		0.0,
 		1.0
 	);
+	output.textureCoordinates = float2(
+		mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float((vertexID&2) >> 1)),
+		scans[instanceID].dataY);
 	return output;
 }
 
-fragment half4 scanFragmentMain(ColouredVertex vert [[stage_in]]) {
-	return half4(1.0);
+fragment half4 scanFragmentMain(ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	constexpr sampler s(coord::pixel,
+						address::clamp_to_zero,	// This really makes no difference here; anything Metal will accept will do.
+						filter::nearest);
+
+	return half4(texture.sample(s, vert.textureCoordinates));
 }

From ced4a75a1a45fb17a3fc8916373b783814687477 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 20:44:46 -0400
Subject: [PATCH 021/131] Adds note on the buffering scan target's minor
 adaptation of data_offset.

---
 Outputs/ScanTargets/BufferingScanTarget.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 85d186c68..4809b3d74 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -48,13 +48,15 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		// It is the subclass's responsibility to post timings.
 		Metrics display_metrics_;
 
-		// Extends the definition of a Scan to include two extra fields,
-		// completing this scan's source data and destination locations.
+		/// Extends the definition of a Scan to include two extra fields,
+		/// completing this scan's source data and destination locations.
 		struct Scan {
 			Outputs::Display::ScanTarget::Scan scan;
 
 			/// Stores the y coordinate for this scan's data within the write area texture.
 			/// Use this plus the scan's endpoints' data_offsets to locate this data in 2d.
+			/// Note that the data_offsets will have been adjusted to be relative to the line
+			/// they fall within, not the data allocation.
 			uint16_t data_y;
 			/// Stores the y coordinate assigned to this scan within the intermediate buffers.
 			/// Use this plus this scan's endpoints' x locations to determine where to composite

From 93c6105442ae4b1598b9730d4384758c91695dbf Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 20:45:14 -0400
Subject: [PATCH 022/131] Corrects calculation of dirty texture area.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 8d8b2bc7b..d07d9e3f1 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -161,8 +161,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	_scanTarget.perform([=] (const BufferingScanTarget::OutputArea &outputArea) {
 		// Ensure texture changes are noted.
-		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y) * _bytesPerInputPixel;
-		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y) * _bytesPerInputPixel;
+		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
+		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
 		if(writeAreaModificationStart != writeAreaModificationEnd) {
 			if(writeAreaModificationStart < writeAreaModificationEnd) {
 				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];

From a118594c8b806d7028f76b193c9dbe5b9a383d11 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 20:45:51 -0400
Subject: [PATCH 023/131] Hacks to make RGB1 visible (in a fashion).

---
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e54400af8..17af486dd 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -93,5 +93,5 @@ fragment half4 scanFragmentMain(ColouredVertex vert [[stage_in]], texture2d<floa
 						address::clamp_to_zero,	// This really makes no difference here; anything Metal will accept will do.
 						filter::nearest);
 
-	return half4(texture.sample(s, vert.textureCoordinates));
+	return half4(texture.sample(s, vert.textureCoordinates) * 32.0f); // Multiply by 32 is _TEMPORARY TEST CODE_ [/ nonsense].
 }

From 6384ff3ee7cf4888df772e293d66a24bb0f415d7 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 21:17:51 -0400
Subject: [PATCH 024/131] Add fix for `data_type_size_` for owners that don't
 change texture pointer upon new modals.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 96b9f5bf1..b14f6f6e1 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -264,7 +264,6 @@ void BufferingScanTarget::set_write_area(uint8_t *base) {
 	std::lock_guard lock_guard(producer_mutex_);
 #endif
 	write_area_ = base;
-	data_type_size_ = Outputs::Display::size_for_data_type(modals_.input_data_type);
 	write_pointers_ = submit_pointers_ = read_pointers_ = PointerSet();
 	allocation_has_failed_ = true;
 	vended_scan_ = nullptr;
@@ -340,6 +339,12 @@ const Outputs::Display::ScanTarget::Modals *BufferingScanTarget::new_modals() {
 		return nullptr;
 	}
 	modals_are_dirty_ = false;
+
+	// MAJOR SHARP EDGE HERE: assume that because the new_modals have been fetched then the caller will
+	// now ensure their texture buffer is appropriate. They might provide a new pointer and might now.
+	// But either way it's now appropriate to start treating the data size as implied by the data type.
+	data_type_size_ = Outputs::Display::size_for_data_type(modals_.input_data_type);
+
 	return &modals_;
 }
 

From c1dc42a094b3841abd78c1205037970080f44970 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 21:18:23 -0400
Subject: [PATCH 025/131] Add comment on latent design aim.

In the hope that I don't forget why I did this.
---
 Outputs/ScanTarget.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index 63be212d1..3284f5e03 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -53,6 +53,9 @@ enum class DisplayType {
 
 /*!
 	Enumerates the potential formats of input data.
+
+	All types are designed to be 1, 2 or 4 bytes per pixel; this hopefully creates appropriate alignment
+	on all formats.
 */
 enum class InputDataType {
 

From 28d933d5d6861053a49780e3f528acf552bfbd03 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 21:19:07 -0400
Subject: [PATCH 026/131] Does just enough to get 8-bit RGB and 1-bit luminance
 machines to display.

Assuming an 'RGB' output.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 24 +++++++++++++++----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 20 ++++++++++++----
 2 files changed, 34 insertions(+), 10 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index d07d9e3f1..926bc9494 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -85,6 +85,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_scanTarget.set_write_area(reinterpret_cast<uint8_t *>(_writeAreaBuffer.contents));
 		_scanTarget.set_line_buffer(reinterpret_cast<BufferingScanTarget::Line *>(_linesBuffer.contents), _lineMetadataBuffer, NumBufferedLines);
 		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
+
+		// Set initial aspect-ratio multiplier.
+		[self mtkView:view drawableSizeWillChange:view.drawableSize];
 	}
 
 	return self;
@@ -124,7 +127,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
 			case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
 		}
-		MTLTextureDescriptor *textureDescriptor = [MTLTextureDescriptor
+		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
 			texture2DDescriptorWithPixelFormat:pixelFormat
 			width:BufferingScanTarget::WriteAreaWidth
 			height:BufferingScanTarget::WriteAreaHeight
@@ -132,18 +135,29 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		textureDescriptor.resourceOptions = SharedResourceOptionsTexture;
 
 		// TODO: the call below is the only reason why this project now requires macOS 10.13; is it all that helpful versus just uploading each frame?
+		const NSUInteger bytesPerRow = BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel;
 		_writeAreaTexture = [_writeAreaBuffer
 			newTextureWithDescriptor:textureDescriptor
 			offset:0
-			bytesPerRow:BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel];
-		_totalTextureBytes = BufferingScanTarget::WriteAreaWidth * BufferingScanTarget::WriteAreaHeight * _bytesPerInputPixel;
+			bytesPerRow:bytesPerRow];
+		_totalTextureBytes = bytesPerRow * BufferingScanTarget::WriteAreaHeight;
 
 		// Generate pipeline.
 		id<MTLLibrary> library = [view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMain"];
 		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+
+		// TODO: logic somewhat more complicated than this, probably
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
+		switch(newModals->input_data_type) {
+			default:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMainRGB"];
+			break;
+			case Outputs::Display::InputDataType::Luminance1:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMainL1"];
+			break;
+		}
+
 		_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 17af486dd..f2e81d258 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -88,10 +88,20 @@ vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
 	return output;
 }
 
-fragment half4 scanFragmentMain(ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	constexpr sampler s(coord::pixel,
-						address::clamp_to_zero,	// This really makes no difference here; anything Metal will accept will do.
-						filter::nearest);
+namespace {
+
+constexpr sampler standardSampler(	coord::pixel,
+									address::clamp_to_edge,	// Although arbitrary, stick with this address mode for compatibility all the way to MTLFeatureSet_iOS_GPUFamily1_v1.
+									filter::nearest);
 
-	return half4(texture.sample(s, vert.textureCoordinates) * 32.0f); // Multiply by 32 is _TEMPORARY TEST CODE_ [/ nonsense].
+}
+
+// MARK: - Input formst to RGB conversions.
+
+fragment half4 scanFragmentMainRGB (ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return half4(texture.sample(standardSampler, vert.textureCoordinates));
+}
+
+fragment half4 scanFragmentMainL1(ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return half4(half3(texture.sample(standardSampler, vert.textureCoordinates).r * 255.0), 1.0);
 }

From 3d6590af89dc4086fe98f1ac0b9a54aec197b7a4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 22:11:31 -0400
Subject: [PATCH 027/131] Throws out a little more OpenGL.

---
 .../Mac/Clock Signal/Views/CSScanTargetView.m | 24 -------------------
 1 file changed, 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index eb6888f63..8989fed90 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -194,30 +194,6 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		self.device = MTLCreateSystemDefaultDevice();
 	}
 
-//	NSOpenGLPixelFormatAttribute attributes[] = {
-//		NSOpenGLPFADoubleBuffer,
-//		NSOpenGLPFAOpenGLProfile,	NSOpenGLProfileVersion3_2Core,
-////		NSOpenGLPFAMultisample,
-////		NSOpenGLPFASampleBuffers,	1,
-////		NSOpenGLPFASamples,			2,
-//		0
-//	};
-//
-//	NSOpenGLPixelFormat *pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attributes];
-//	NSOpenGLContext *context = [[NSOpenGLContext alloc] initWithFormat:pixelFormat shareContext:nil];
-//
-//#ifdef DEBUG
-//	// When we're using a CoreProfile context, crash if we call a legacy OpenGL function
-//	// This will make it much more obvious where and when such a function call is made so
-//	// that we can remove such calls.
-//	// Without this we'd simply get GL_INVALID_OPERATION error for calling legacy functions
-//	// but it would be more difficult to see where that function was called.
-//	CGLEnable([context CGLContextObj], kCGLCECrashOnRemovedFunctions);
-//#endif
-//
-//	self.pixelFormat = pixelFormat;
-//	self.openGLContext = context;
-//	self.wantsBestResolutionOpenGLSurface = YES;
 	// Create the scan target.
 	_scanTarget = [[CSScanTarget alloc] initWithView:self];
 	self.delegate = _scanTarget;

From eadda6a96729b9d4fd6b2665d8d16897196a0b7d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 9 Aug 2020 22:17:27 -0400
Subject: [PATCH 028/131] Further strips OpenGL from the macOS target.

---
 OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj | 10 ----------
 OSBindings/Mac/Clock Signal/Machine/CSMachine.mm      | 11 +++--------
 .../Mac/Clock SignalTests/MasterSystemVDPTests.mm     |  1 -
 Outputs/OpenGL/OpenGL.hpp                             |  6 +++---
 4 files changed, 6 insertions(+), 22 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 88403b335..a1f6124d1 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -813,19 +813,14 @@
 		4BCE0060227D39AB000CA200 /* Video.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCE005E227D39AB000CA200 /* Video.cpp */; };
 		4BCF1FA41DADC3DD0039D2E7 /* Oric.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BCF1FA21DADC3DD0039D2E7 /* Oric.cpp */; };
 		4BD0FBC3233706A200148981 /* CSApplication.m in Sources */ = {isa = PBXBuildFile; fileRef = 4BD0FBC2233706A200148981 /* CSApplication.m */; };
-		4BD191F42191180E0042E144 /* ScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD191F22191180E0042E144 /* ScanTarget.cpp */; };
 		4BD191F52191180E0042E144 /* ScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD191F22191180E0042E144 /* ScanTarget.cpp */; };
 		4BD388882239E198002D14B5 /* 68000Tests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BD388872239E198002D14B5 /* 68000Tests.mm */; };
 		4BD3A30B1EE755C800B5B501 /* Video.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD3A3091EE755C800B5B501 /* Video.cpp */; };
-		4BD424DF2193B5340097291A /* TextureTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424DD2193B5340097291A /* TextureTarget.cpp */; };
 		4BD424E02193B5340097291A /* TextureTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424DD2193B5340097291A /* TextureTarget.cpp */; };
-		4BD424E52193B5830097291A /* Shader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424E12193B5820097291A /* Shader.cpp */; };
 		4BD424E62193B5830097291A /* Shader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424E12193B5820097291A /* Shader.cpp */; };
-		4BD424E72193B5830097291A /* Rectangle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424E22193B5820097291A /* Rectangle.cpp */; };
 		4BD424E82193B5830097291A /* Rectangle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD424E22193B5820097291A /* Rectangle.cpp */; };
 		4BD468F71D8DF41D0084958B /* 1770.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD468F51D8DF41D0084958B /* 1770.cpp */; };
 		4BD4A8D01E077FD20020D856 /* PCMTrackTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BD4A8CF1E077FD20020D856 /* PCMTrackTests.mm */; };
-		4BD5D2682199148100DDF17D /* ScanTargetGLSLFragments.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD5D2672199148100DDF17D /* ScanTargetGLSLFragments.cpp */; };
 		4BD5D2692199148100DDF17D /* ScanTargetGLSLFragments.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD5D2672199148100DDF17D /* ScanTargetGLSLFragments.cpp */; };
 		4BD61664206B2AC800236112 /* QuickLoadOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4BD61662206B2AC700236112 /* QuickLoadOptions.xib */; };
 		4BD67DCB209BE4D700AB2146 /* StaticAnalyser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BD67DCA209BE4D600AB2146 /* StaticAnalyser.cpp */; };
@@ -4597,7 +4592,6 @@
 				4B448E841F1C4C480009ABD6 /* PulseQueuedTape.cpp in Sources */,
 				4B0E61071FF34737002A9DBD /* MSX.cpp in Sources */,
 				4B4518A01F75FD1C00926311 /* CPCDSK.cpp in Sources */,
-				4BD424DF2193B5340097291A /* TextureTarget.cpp in Sources */,
 				4B0CCC451C62D0B3001CAC5F /* CRT.cpp in Sources */,
 				4BC23A2C2467600F001A6030 /* OPLL.cpp in Sources */,
 				4B322E041F5A2E3C004EB04C /* Z80Base.cpp in Sources */,
@@ -4635,13 +4629,11 @@
 				4B4DC82B1D2C27A4003C5BF8 /* SerialBus.cpp in Sources */,
 				4BBFFEE61F7B27F1005F3FEB /* TrackSerialiser.cpp in Sources */,
 				4BAE49582032881E004BE78E /* CSZX8081.mm in Sources */,
-				4BD424E52193B5830097291A /* Shader.cpp in Sources */,
 				4B0333AF2094081A0050B93D /* AppleDSK.cpp in Sources */,
 				4B894518201967B4007DE474 /* ConfidenceCounter.cpp in Sources */,
 				4BCE005A227CFFCA000CA200 /* Macintosh.cpp in Sources */,
 				4B6AAEA4230E3E1D0078E864 /* MassStorageDevice.cpp in Sources */,
 				4B89452E201967B4007DE474 /* StaticAnalyser.cpp in Sources */,
-				4BD5D2682199148100DDF17D /* ScanTargetGLSLFragments.cpp in Sources */,
 				4BC890D3230F86020025A55A /* DirectAccessDevice.cpp in Sources */,
 				4B7BA03723CEB86000B98D9E /* BD500.cpp in Sources */,
 				4B38F3481F2EC11D00D9235D /* AmstradCPC.cpp in Sources */,
@@ -4691,7 +4683,6 @@
 				4B8334841F5DA0360097E338 /* Z80Storage.cpp in Sources */,
 				4BA61EB01D91515900B3C876 /* NSData+StdVector.mm in Sources */,
 				4BDA00E022E644AF00AC3CD0 /* CSROMReceiverView.m in Sources */,
-				4BD191F42191180E0042E144 /* ScanTarget.cpp in Sources */,
 				4B228CDB24DA41890077EF25 /* ScanTarget.metal in Sources */,
 				4B228CD524D773B40077EF25 /* CSScanTarget.mm in Sources */,
 				4BCD634922D6756400F567F1 /* MacintoshDoubleDensityDrive.cpp in Sources */,
@@ -4776,7 +4767,6 @@
 				4B37EE821D7345A6006A09A4 /* BinaryDump.cpp in Sources */,
 				4BCE0053227CE8CA000CA200 /* AppleII.cpp in Sources */,
 				4B8334821F5D9FF70097E338 /* PartialMachineCycle.cpp in Sources */,
-				4BD424E72193B5830097291A /* Rectangle.cpp in Sources */,
 				4B1B88C0202E3DB200B67DFF /* MultiConfigurable.cpp in Sources */,
 				4BFF1D3922337B0300838EA1 /* 68000Storage.cpp in Sources */,
 				4B54C0BC1F8D8E790050900F /* KeyboardMachine.cpp in Sources */,
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index 5f05d5c5c..26d164dee 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -32,12 +32,6 @@
 #include <atomic>
 #include <bitset>
 
-#import <OpenGL/OpenGL.h>
-#include <OpenGL/gl3.h>
-
-#include "../../../../Outputs/OpenGL/ScanTarget.hpp"
-#include "../../../../Outputs/OpenGL/Screenshot.hpp"
-
 @interface CSMachine() <CSScanTargetViewDisplayLinkDelegate>
 - (void)speaker:(Outputs::Speaker::Speaker *)speaker didCompleteSamples:(const int16_t *)samples length:(int)length;
 - (void)speakerDidChangeInputClock:(Outputs::Speaker::Speaker *)speaker;
@@ -377,7 +371,7 @@ struct ActivityObserver: public Activity::Observer {
 
 - (NSBitmapImageRep *)imageRepresentation {
 	// Grab a screenshot.
-	Outputs::Display::OpenGL::Screenshot screenshot(4, 3);
+/*	Outputs::Display::OpenGL::Screenshot screenshot(4, 3);
 
 	// Generate an NSBitmapImageRep containing the screenshot's data.
 	NSBitmapImageRep *const result =
@@ -395,7 +389,8 @@ struct ActivityObserver: public Activity::Observer {
 
 	memcpy(result.bitmapData, screenshot.pixel_data.data(), size_t(screenshot.width*screenshot.height*4));
 
-	return result;
+	return result;*/
+	return nil;
 }
 
 - (void)applyMedia:(const Analyser::Static::Media &)media {
diff --git a/OSBindings/Mac/Clock SignalTests/MasterSystemVDPTests.mm b/OSBindings/Mac/Clock SignalTests/MasterSystemVDPTests.mm
index 57e9a7488..5a6167bd4 100644
--- a/OSBindings/Mac/Clock SignalTests/MasterSystemVDPTests.mm	
+++ b/OSBindings/Mac/Clock SignalTests/MasterSystemVDPTests.mm	
@@ -7,7 +7,6 @@
 //
 
 #import <XCTest/XCTest.h>
-#import <OpenGL/OpenGL.h>
 
 #include "9918.hpp"
 
diff --git a/Outputs/OpenGL/OpenGL.hpp b/Outputs/OpenGL/OpenGL.hpp
index 1cef48dda..77101d070 100644
--- a/Outputs/OpenGL/OpenGL.hpp
+++ b/Outputs/OpenGL/OpenGL.hpp
@@ -16,9 +16,9 @@
 #ifdef __APPLE__
 	#if TARGET_OS_IPHONE
 	#else
-		#include <OpenGL/OpenGL.h>
-		#include <OpenGL/gl3.h>
-		#include <OpenGL/gl3ext.h>
+//		#include <OpenGL/OpenGL.h>
+//		#include <OpenGL/gl3.h>
+//		#include <OpenGL/gl3ext.h>
 	#endif
 #else
 #define GL_GLEXT_PROTOTYPES

From 525233e10b6a5aee37537e8c5aa4082167c29eb4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 10 Aug 2020 19:47:47 -0400
Subject: [PATCH 029/131] Ensures all input data types are parseable in Metal.

Though now I need to think a bit more about the best way to compose signal-type conversions, and whether output-type calculations (i.e. gamma, brightness) are applied.
---
 .../xcschemes/Clock Signal.xcscheme           |   2 +-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  49 +++++++--
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 101 ++++++++++++++++--
 Outputs/ScanTarget.hpp                        |  26 ++++-
 4 files changed, 154 insertions(+), 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index 63be2c037..a99eb0a5d 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
@@ -67,7 +67,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Release"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       enableASanStackUseAfterReturn = "YES"
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 926bc9494..6505fad52 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -121,11 +121,20 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the appropriate input texture.
 		MTLPixelFormat pixelFormat;
 		_bytesPerInputPixel = size_for_data_type(newModals->input_data_type);
-		switch(_bytesPerInputPixel) {
-			default:
-			case 1: pixelFormat = MTLPixelFormatR8Unorm;	break;
-			case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
-			case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
+		if(data_type_is_normalised(newModals->input_data_type)) {
+			switch(_bytesPerInputPixel) {
+				default:
+				case 1: pixelFormat = MTLPixelFormatR8Unorm;	break;
+				case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
+				case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
+			}
+		} else {
+			switch(_bytesPerInputPixel) {
+				default:
+				case 1: pixelFormat = MTLPixelFormatR8Uint;		break;
+				case 2: pixelFormat = MTLPixelFormatRG8Uint;	break;
+				case 4: pixelFormat = MTLPixelFormatRGBA8Uint;	break;
+			}
 		}
 		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
 			texture2DDescriptorWithPixelFormat:pixelFormat
@@ -148,13 +157,33 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
 
 		// TODO: logic somewhat more complicated than this, probably
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanVertexMain"];
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToDisplay"];
 		switch(newModals->input_data_type) {
-			default:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMainRGB"];
-			break;
 			case Outputs::Display::InputDataType::Luminance1:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"scanFragmentMainL1"];
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance1"];
+			break;
+			case Outputs::Display::InputDataType::Luminance8:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8"];
+			break;
+			case Outputs::Display::InputDataType::PhaseLinkedLuminance8:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"samplePhaseLinkedLuminance8"];
+			break;
+
+			case Outputs::Display::InputDataType::Luminance8Phase8:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8Phase8"];
+			break;
+
+			case Outputs::Display::InputDataType::Red1Green1Blue1:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed1Green1Blue1"];
+			break;
+			case Outputs::Display::InputDataType::Red2Green2Blue2:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed2Green2Blue2"];
+			break;
+			case Outputs::Display::InputDataType::Red4Green4Blue4:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed4Green4Blue4"];
+			break;
+			case Outputs::Display::InputDataType::Red8Green8Blue8:
+				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
 			break;
 		}
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index f2e81d258..0ab29335d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -21,6 +21,8 @@ struct Uniforms {
 	float aspectRatioMultiplier;
 };
 
+// MARK: - Structs used for receiving data from the emulation.
+
 // This is intended to match the net effect of `Scan` as defined by the BufferingScanTarget.
 struct Scan {
 	struct EndPoint {
@@ -47,20 +49,25 @@ struct Line {
 	uint8_t compositeAmplitude;
 };
 
+// MARK: - Intermediate structs.
 
 // This is an intermediate struct, which is TEMPORARY.
-struct ColouredVertex {
+struct SourceInterpolator {
 	float4 position [[position]];
 	float2 textureCoordinates;
+	float colourPhase;
+	float colourAmplitude;
 };
 
 
 // MARK: - Scan shaders; these do final output to the display.
 
-vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
-										constant Scan *scans [[buffer(0)]],
-										uint instanceID [[instance_id]],
-										uint vertexID [[vertex_id]]) {
+vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)]],
+											constant Scan *scans [[buffer(0)]],
+											uint instanceID [[instance_id]],
+											uint vertexID [[vertex_id]]) {
+	SourceInterpolator output;
+
 	// Get start and end vertices in regular float2 form.
 	const float2 start = float2(
 		float(scans[instanceID].endPoints[0].position[0]) / float(uniforms.scale.x),
@@ -75,8 +82,15 @@ vertex ColouredVertex scanVertexMain(	constant Uniforms &uniforms [[buffer(1)]],
 	const float2 tangent = (end - start);
 	const float2 normal = float2(-tangent.y, tangent.x) / length(tangent);
 
+	// Load up the colour details.
+	output.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
+	output.colourPhase = mix(
+		float(scans[instanceID].endPoints[0].compositeAngle),
+		float(scans[instanceID].endPoints[1].compositeAngle),
+		float((vertexID&2) >> 1)
+	) / 64.0;
+
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
-	ColouredVertex output;
 	output.position = float4(
 		((start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
 		0.0,
@@ -96,12 +110,77 @@ constexpr sampler standardSampler(	coord::pixel,
 
 }
 
-// MARK: - Input formst to RGB conversions.
+// MARK: - Various input format conversion samplers.
 
-fragment half4 scanFragmentMainRGB (ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return half4(texture.sample(standardSampler, vert.textureCoordinates));
+/*
+	Luminance1,				// 1 byte/pixel; any bit set => white; no bits set => black.
+	Luminance8,				// 1 byte/pixel; linear scale.
+
+	PhaseLinkedLuminance8,	// 4 bytes/pixel; each byte is an individual 8-bit luminance
+							// value and which value is output is a function of
+							// colour subcarrier phase — byte 0 defines the first quarter
+							// of each colour cycle, byte 1 the next quarter, etc. This
+							// format is intended to permit replay of sampled original data.
+
+	// The luminance plus phase types describe a luminance and the phase offset
+	// of a colour subcarrier. So they can be used to generate a luminance signal,
+	// or an s-video pipeline.
+
+	Luminance8Phase8,		// 2 bytes/pixel; first is luminance, second is phase.
+							// Phase is encoded on a 192-unit circle; anything
+							// greater than 192 implies that the colour part of
+							// the signal should be omitted.
+
+	// The RGB types can directly feed an RGB pipeline, naturally, or can be mapped
+	// to phase+luminance, or just to luminance.
+
+	Red1Green1Blue1,		// 1 byte/pixel; bit 0 is blue on or off, bit 1 is green, bit 2 is red.
+	Red2Green2Blue2,		// 1 byte/pixel; bits 0 and 1 are blue, bits 2 and 3 are green, bits 4 and 5 are blue.
+	Red4Green4Blue4,		// 2 bytes/pixel; first nibble is red, second is green, third is blue.
+	Red8Green8Blue8,		// 4 bytes/pixel; first is red, second is green, third is blue, fourth is vacant.
+
+ */
+
+
+// There's only one meaningful way to sample the luminance formats.
+
+fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+	return float4(float3(texture.sample(standardSampler, vert.textureCoordinates).r), 1.0);
 }
 
-fragment half4 scanFragmentMainL1(ColouredVertex vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return half4(half3(texture.sample(standardSampler, vert.textureCoordinates).r * 255.0), 1.0);
+fragment float4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return float4(float3(texture.sample(standardSampler, vert.textureCoordinates).r), 1.0);
+}
+
+fragment float4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	const int offset = int(vert.colourPhase * 4.0);
+	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
+	return float4(float3(sample[offset]), 1.0);
+}
+
+// The luminance/phase format can produce either composite or S-Video.
+
+fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return float4(texture.sample(standardSampler, vert.textureCoordinates).rg, 0.0, 1.0);
+}
+
+// All the RGB formats can produce RGB, composite or S-Video.
+
+fragment float4 sampleRed8Green8Blue8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return float4(texture.sample(standardSampler, vert.textureCoordinates));
+}
+
+fragment float4 sampleRed1Green1Blue1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
+	return float4(sample&4, sample&2, sample&1, 1.0);
+}
+
+fragment float4 sampleRed2Green2Blue2(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
+	return float4((sample >> 4)&3, (sample >> 2)&3, sample&3, 3.0) / 3.0;
+}
+
+fragment float4 sampleRed4Green4Blue4(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).rg;
+	return float4(sample.r&15, (sample.g >> 4)&15, sample.g&15, 15.0) / 15.0;
 }
diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index 3284f5e03..e74c85289 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -89,7 +89,8 @@ enum class InputDataType {
 	Red8Green8Blue8,		// 4 bytes/pixel; first is red, second is green, third is blue, fourth is vacant.
 };
 
-inline size_t size_for_data_type(InputDataType data_type) {
+/// @returns the number of bytes per sample for data of type @c data_type.
+constexpr inline size_t size_for_data_type(InputDataType data_type) {
 	switch(data_type) {
 		case InputDataType::Luminance1:
 		case InputDataType::Luminance8:
@@ -110,7 +111,28 @@ inline size_t size_for_data_type(InputDataType data_type) {
 	}
 }
 
-inline DisplayType natural_display_type_for_data_type(InputDataType data_type) {
+/// @returns @c true if this data type presents normalised data, i.e. each byte holds a
+/// value in the range [0, 255] representing a real number in the range [0.0, 1.0]; @c false otherwise.
+constexpr inline size_t data_type_is_normalised(InputDataType data_type) {
+	switch(data_type) {
+		case InputDataType::Luminance8:
+		case InputDataType::Luminance8Phase8:
+		case InputDataType::Red8Green8Blue8:
+		case InputDataType::PhaseLinkedLuminance8:
+			return true;
+
+		default:
+		case InputDataType::Luminance1:
+		case InputDataType::Red1Green1Blue1:
+		case InputDataType::Red2Green2Blue2:
+		case InputDataType::Red4Green4Blue4:
+			return false;
+	}
+}
+
+/// @returns The 'natural' display type for data of type @c data_type. The natural display is whichever would
+/// display it with the least number of conversions. Caveat: a colour display is assumed for pure-composite data types.
+constexpr inline DisplayType natural_display_type_for_data_type(InputDataType data_type) {
 	switch(data_type) {
 		default:
 		case InputDataType::Luminance1:

From 8374a5e579f388ccd1cd61b256f24b0272bf051d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 10 Aug 2020 21:33:59 -0400
Subject: [PATCH 030/131] Adds superficially correct
 `compositeSampleLuminance8Phase8` function.

Thereby uncovering a minor error in my decoding of colour phase.
---
 .../xcschemes/Clock Signal.xcscheme           |  2 +-
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 41 ++++---------------
 Outputs/ScanTarget.hpp                        |  6 ++-
 3 files changed, 14 insertions(+), 35 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index a99eb0a5d..63be2c037 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
@@ -67,7 +67,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Release"
+      buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       enableASanStackUseAfterReturn = "YES"
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 0ab29335d..205bbd39a 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -84,11 +84,11 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 
 	// Load up the colour details.
 	output.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
-	output.colourPhase = mix(
+	output.colourPhase = 3.141592654f * mix(
 		float(scans[instanceID].endPoints[0].compositeAngle),
 		float(scans[instanceID].endPoints[1].compositeAngle),
 		float((vertexID&2) >> 1)
-	) / 64.0;
+	) / 32.0;
 
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
 	output.position = float4(
@@ -112,36 +112,6 @@ constexpr sampler standardSampler(	coord::pixel,
 
 // MARK: - Various input format conversion samplers.
 
-/*
-	Luminance1,				// 1 byte/pixel; any bit set => white; no bits set => black.
-	Luminance8,				// 1 byte/pixel; linear scale.
-
-	PhaseLinkedLuminance8,	// 4 bytes/pixel; each byte is an individual 8-bit luminance
-							// value and which value is output is a function of
-							// colour subcarrier phase — byte 0 defines the first quarter
-							// of each colour cycle, byte 1 the next quarter, etc. This
-							// format is intended to permit replay of sampled original data.
-
-	// The luminance plus phase types describe a luminance and the phase offset
-	// of a colour subcarrier. So they can be used to generate a luminance signal,
-	// or an s-video pipeline.
-
-	Luminance8Phase8,		// 2 bytes/pixel; first is luminance, second is phase.
-							// Phase is encoded on a 192-unit circle; anything
-							// greater than 192 implies that the colour part of
-							// the signal should be omitted.
-
-	// The RGB types can directly feed an RGB pipeline, naturally, or can be mapped
-	// to phase+luminance, or just to luminance.
-
-	Red1Green1Blue1,		// 1 byte/pixel; bit 0 is blue on or off, bit 1 is green, bit 2 is red.
-	Red2Green2Blue2,		// 1 byte/pixel; bits 0 and 1 are blue, bits 2 and 3 are green, bits 4 and 5 are blue.
-	Red4Green4Blue4,		// 2 bytes/pixel; first nibble is red, second is green, third is blue.
-	Red8Green8Blue8,		// 4 bytes/pixel; first is red, second is green, third is blue, fourth is vacant.
-
- */
-
-
 // There's only one meaningful way to sample the luminance formats.
 
 fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
@@ -164,6 +134,13 @@ fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], tex
 	return float4(texture.sample(standardSampler, vert.textureCoordinates).rg, 0.0, 1.0);
 }
 
+fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	const auto luminancePhase = texture.sample(standardSampler, vert.textureCoordinates).rg;
+	const float phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
+	const float rawChroma = step(luminancePhase.g, 0.75) * cos(vert.colourPhase + phaseOffset);
+	return float4(float3(mix(luminancePhase.r, rawChroma, vert.colourAmplitude)), 1.0f);
+}
+
 // All the RGB formats can produce RGB, composite or S-Video.
 
 fragment float4 sampleRed8Green8Blue8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index e74c85289..b8f5858ae 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -75,8 +75,10 @@ enum class InputDataType {
 	// of a colour subcarrier. So they can be used to generate a luminance signal,
 	// or an s-video pipeline.
 
-	Luminance8Phase8,		// 2 bytes/pixel; first is luminance, second is phase.
-							// Phase is encoded on a 192-unit circle; anything
+	Luminance8Phase8,		// 2 bytes/pixel; first is luminance, second is phase
+							// of a cosine wave.
+							//
+							// Phase is encoded on a 128-unit circle; anything
 							// greater than 192 implies that the colour part of
 							// the signal should be omitted.
 

From 8fa89baf54fd989295218ea3c35544dcd93fc426 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 10 Aug 2020 21:43:32 -0400
Subject: [PATCH 031/131] Slightly cleans up Xcode project; reenables
 kiosk-for-Mac builds.

---
 .../Clock Signal.xcodeproj/project.pbxproj    | 25 +++++++++++++------
 Outputs/OpenGL/OpenGL.hpp                     |  8 +++---
 2 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index a1f6124d1..521b01ba4 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -770,6 +770,8 @@
 		4BB73EAC1B587A5100552FC2 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4BB73EAA1B587A5100552FC2 /* MainMenu.xib */; };
 		4BB73EB71B587A5100552FC2 /* AllSuiteATests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BB73EB61B587A5100552FC2 /* AllSuiteATests.swift */; };
 		4BB73EC21B587A5100552FC2 /* Clock_SignalUITests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BB73EC11B587A5100552FC2 /* Clock_SignalUITests.swift */; };
+		4BB8616E24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */; };
+		4BB8616F24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */; };
 		4BBB70A4202011C2002FE009 /* MultiMediaTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */; };
 		4BBB70A5202011C2002FE009 /* MultiMediaTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */; };
 		4BBB70A8202014E2002FE009 /* MultiProducer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A6202014E2002FE009 /* MultiProducer.cpp */; };
@@ -788,8 +790,6 @@
 		4BC1317B2346DF2B00E4FF3D /* MSA.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC131782346DF2B00E4FF3D /* MSA.cpp */; };
 		4BC23A2C2467600F001A6030 /* OPLL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC23A2B2467600E001A6030 /* OPLL.cpp */; };
 		4BC23A2D2467600F001A6030 /* OPLL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC23A2B2467600E001A6030 /* OPLL.cpp */; };
-		4BC3C67C24C9230F0027BF76 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */; };
-		4BC3C67D24C9230F0027BF76 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */; };
 		4BC57CD92436A62900FBC404 /* State.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC57CD82436A62900FBC404 /* State.cpp */; };
 		4BC57CDA2436A62900FBC404 /* State.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC57CD82436A62900FBC404 /* State.cpp */; };
 		4BC5C3E022C994CD00795658 /* 68000MoveTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4BC5C3DF22C994CC00795658 /* 68000MoveTests.mm */; };
@@ -1639,6 +1639,8 @@
 		4BB73EC11B587A5100552FC2 /* Clock_SignalUITests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Clock_SignalUITests.swift; sourceTree = "<group>"; };
 		4BB73EC31B587A5100552FC2 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		4BB73ECF1B587A6700552FC2 /* Clock Signal.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = "Clock Signal.entitlements"; sourceTree = "<group>"; };
+		4BB8616C24E22DC500A00E03 /* BufferingScanTarget.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = BufferingScanTarget.hpp; sourceTree = "<group>"; };
+		4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BufferingScanTarget.cpp; sourceTree = "<group>"; };
 		4BBB709C2020109C002FE009 /* DynamicMachine.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = DynamicMachine.hpp; sourceTree = "<group>"; };
 		4BBB70A2202011C2002FE009 /* MultiMediaTarget.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MultiMediaTarget.hpp; sourceTree = "<group>"; };
 		4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MultiMediaTarget.cpp; sourceTree = "<group>"; };
@@ -1671,8 +1673,6 @@
 		4BC23A292467600E001A6030 /* OPLBase.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = OPLBase.hpp; sourceTree = "<group>"; };
 		4BC23A2A2467600E001A6030 /* EnvelopeGenerator.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = EnvelopeGenerator.hpp; sourceTree = "<group>"; };
 		4BC23A2B2467600E001A6030 /* OPLL.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OPLL.cpp; sourceTree = "<group>"; };
-		4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = BufferingScanTarget.cpp; path = ../../Outputs/ScanTargets/BufferingScanTarget.cpp; sourceTree = "<group>"; };
-		4BC3C67B24C9230F0027BF76 /* BufferingScanTarget.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; name = BufferingScanTarget.hpp; path = ../../Outputs/ScanTargets/BufferingScanTarget.hpp; sourceTree = "<group>"; };
 		4BC57CD2243427C700FBC404 /* AudioProducer.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = AudioProducer.hpp; sourceTree = "<group>"; };
 		4BC57CD32434282000FBC404 /* TimedMachine.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = TimedMachine.hpp; sourceTree = "<group>"; };
 		4BC57CD424342E0600FBC404 /* MachineTypes.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = MachineTypes.hpp; sourceTree = "<group>"; };
@@ -2235,6 +2235,7 @@
 				4BF52672218E752E00313227 /* ScanTarget.hpp */,
 				4B0CCC411C62D0B3001CAC5F /* CRT */,
 				4BD191D5219113B80042E144 /* OpenGL */,
+				4BB8616B24E22DC500A00E03 /* ScanTargets */,
 				4BD060A41FE49D3C006E14BE /* Speaker */,
 			);
 			name = Outputs;
@@ -3323,8 +3324,6 @@
 		4BB73E951B587A5100552FC2 = {
 			isa = PBXGroup;
 			children = (
-				4BC3C67A24C9230F0027BF76 /* BufferingScanTarget.cpp */,
-				4BC3C67B24C9230F0027BF76 /* BufferingScanTarget.hpp */,
 				4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */,
 				4B51F70820A521D700AFA2C1 /* Activity */,
 				4B8944E2201967B4007DE474 /* Analyser */,
@@ -3493,6 +3492,16 @@
 			path = ../../Processors;
 			sourceTree = "<group>";
 		};
+		4BB8616B24E22DC500A00E03 /* ScanTargets */ = {
+			isa = PBXGroup;
+			children = (
+				4BB8616C24E22DC500A00E03 /* BufferingScanTarget.hpp */,
+				4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */,
+			);
+			name = ScanTargets;
+			path = ../../Outputs/ScanTargets;
+			sourceTree = "<group>";
+		};
 		4BBB70A1202011C2002FE009 /* Implementation */ = {
 			isa = PBXGroup;
 			children = (
@@ -4504,7 +4513,7 @@
 				4BEBFB522002DB30000708CC /* DiskROM.cpp in Sources */,
 				4BC23A2D2467600F001A6030 /* OPLL.cpp in Sources */,
 				4B055AA11FAE85DA0060FFFF /* OricMFMDSK.cpp in Sources */,
-				4BC3C67D24C9230F0027BF76 /* BufferingScanTarget.cpp in Sources */,
+				4BB8616F24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */,
 				4B0ACC2923775819008902D0 /* DMAController.cpp in Sources */,
 				4B055A951FAE85BB0060FFFF /* BitReverse.cpp in Sources */,
 				4B055ACE1FAE9B030060FFFF /* Plus3.cpp in Sources */,
@@ -4617,6 +4626,7 @@
 				4B1497921EE4B5A800CE2596 /* ZX8081.cpp in Sources */,
 				4B643F3F1D77B88000D431D6 /* DocumentController.swift in Sources */,
 				4BDA00E422E663B900AC3CD0 /* NSData+CRC32.m in Sources */,
+				4BB8616E24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */,
 				4BB4BFB022A42F290069048D /* MacintoshIMG.cpp in Sources */,
 				4B05401E219D1618001BF69C /* ScanTarget.cpp in Sources */,
 				4B4518861F75E91A00926311 /* MFMDiskController.cpp in Sources */,
@@ -4649,7 +4659,6 @@
 				4B3BF5B01F146265005B6C36 /* CSW.cpp in Sources */,
 				4BCE0060227D39AB000CA200 /* Video.cpp in Sources */,
 				4B0ACC2E23775819008902D0 /* TIA.cpp in Sources */,
-				4BC3C67C24C9230F0027BF76 /* BufferingScanTarget.cpp in Sources */,
 				4B74CF85231370BC00500CE8 /* MacintoshVolume.cpp in Sources */,
 				4B4518A51F75FD1C00926311 /* SSD.cpp in Sources */,
 				4B55CE5F1C3B7D960093A61B /* MachineDocument.swift in Sources */,
diff --git a/Outputs/OpenGL/OpenGL.hpp b/Outputs/OpenGL/OpenGL.hpp
index 77101d070..d8e86ef90 100644
--- a/Outputs/OpenGL/OpenGL.hpp
+++ b/Outputs/OpenGL/OpenGL.hpp
@@ -16,9 +16,11 @@
 #ifdef __APPLE__
 	#if TARGET_OS_IPHONE
 	#else
-//		#include <OpenGL/OpenGL.h>
-//		#include <OpenGL/gl3.h>
-//		#include <OpenGL/gl3ext.h>
+		// These remain so that I can, at least for now, build the kiosk version under macOS.
+		// They can be eliminated if and when Apple fully withdraws OpenGL support.
+		#include <OpenGL/OpenGL.h>
+		#include <OpenGL/gl3.h>
+		#include <OpenGL/gl3ext.h>
 	#endif
 #else
 #define GL_GLEXT_PROTOTYPES

From b9309268ba27a068204557dcc77ce6fc37e0b174 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 10 Aug 2020 21:46:11 -0400
Subject: [PATCH 032/131] Possibly finally succeeds at moving
 Accelerate.framework to where it should be.

---
 .../Mac/Clock Signal.xcodeproj/project.pbxproj     | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index 521b01ba4..fcc791b6c 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -98,7 +98,6 @@
 		4B055AED1FAE9BA20060FFFF /* Z80Storage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8334831F5DA0360097E338 /* Z80Storage.cpp */; };
 		4B055AEE1FAE9BBF0060FFFF /* Keyboard.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B86E2591F8C628F006FAA45 /* Keyboard.cpp */; };
 		4B055AEF1FAE9BF00060FFFF /* Typer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B2B3A471F9B8FA70062DABF /* Typer.cpp */; };
-		4B055AF11FAE9C160060FFFF /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */; };
 		4B055AF21FAE9C1C0060FFFF /* OpenGL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4B055AF01FAE9C080060FFFF /* OpenGL.framework */; };
 		4B08A2751EE35D56008B7065 /* Z80InterruptTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B08A2741EE35D56008B7065 /* Z80InterruptTests.swift */; };
 		4B08A2781EE39306008B7065 /* TestMachine.mm in Sources */ = {isa = PBXBuildFile; fileRef = 4B08A2771EE39306008B7065 /* TestMachine.mm */; };
@@ -372,7 +371,6 @@
 		4B778F6123A5F3560000D260 /* Disk.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B8944FC201967B4007DE474 /* Disk.cpp */; };
 		4B778F6223A5F35F0000D260 /* File.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894500201967B4007DE474 /* File.cpp */; };
 		4B778F6323A5F3630000D260 /* Tape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B894501201967B4007DE474 /* Tape.cpp */; };
-		4B778F6423A5F3730000D260 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */; };
 		4B7913CC1DFCD80E00175A82 /* Video.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B7913CA1DFCD80E00175A82 /* Video.cpp */; };
 		4B79A5011FC913C900EEDAD5 /* MSX.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4B79A4FF1FC913C900EEDAD5 /* MSX.cpp */; };
 		4B79E4441E3AF38600141F11 /* cassette.png in Resources */ = {isa = PBXBuildFile; fileRef = 4B79E4411E3AF38600141F11 /* cassette.png */; };
@@ -772,6 +770,8 @@
 		4BB73EC21B587A5100552FC2 /* Clock_SignalUITests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BB73EC11B587A5100552FC2 /* Clock_SignalUITests.swift */; };
 		4BB8616E24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */; };
 		4BB8616F24E22DC500A00E03 /* BufferingScanTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */; };
+		4BB8617124E22F5700A00E03 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BB8617024E22F4900A00E03 /* Accelerate.framework */; };
+		4BB8617224E22F5A00A00E03 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BB8617024E22F4900A00E03 /* Accelerate.framework */; };
 		4BBB70A4202011C2002FE009 /* MultiMediaTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */; };
 		4BBB70A5202011C2002FE009 /* MultiMediaTarget.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */; };
 		4BBB70A8202014E2002FE009 /* MultiProducer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BBB70A6202014E2002FE009 /* MultiProducer.cpp */; };
@@ -796,7 +796,6 @@
 		4BC5FC3020CDDDEF00410AA0 /* AppleIIOptions.xib in Resources */ = {isa = PBXBuildFile; fileRef = 4BC5FC2E20CDDDEE00410AA0 /* AppleIIOptions.xib */; };
 		4BC751B21D157E61006C31D9 /* 6522Tests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4BC751B11D157E61006C31D9 /* 6522Tests.swift */; };
 		4BC76E691C98E31700E6EF73 /* FIRFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC76E671C98E31700E6EF73 /* FIRFilter.cpp */; };
-		4BC76E6B1C98F43700E6EF73 /* Accelerate.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */; };
 		4BC890D3230F86020025A55A /* DirectAccessDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC890D1230F86020025A55A /* DirectAccessDevice.cpp */; };
 		4BC890D4230F86020025A55A /* DirectAccessDevice.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC890D1230F86020025A55A /* DirectAccessDevice.cpp */; };
 		4BC91B831D1F160E00884B76 /* CommodoreTAP.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4BC91B811D1F160E00884B76 /* CommodoreTAP.cpp */; };
@@ -1641,6 +1640,7 @@
 		4BB73ECF1B587A6700552FC2 /* Clock Signal.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = "Clock Signal.entitlements"; sourceTree = "<group>"; };
 		4BB8616C24E22DC500A00E03 /* BufferingScanTarget.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = BufferingScanTarget.hpp; sourceTree = "<group>"; };
 		4BB8616D24E22DC500A00E03 /* BufferingScanTarget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BufferingScanTarget.cpp; sourceTree = "<group>"; };
+		4BB8617024E22F4900A00E03 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = System/Library/Frameworks/Accelerate.framework; sourceTree = SDKROOT; };
 		4BBB709C2020109C002FE009 /* DynamicMachine.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = DynamicMachine.hpp; sourceTree = "<group>"; };
 		4BBB70A2202011C2002FE009 /* MultiMediaTarget.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = MultiMediaTarget.hpp; sourceTree = "<group>"; };
 		4BBB70A3202011C2002FE009 /* MultiMediaTarget.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MultiMediaTarget.cpp; sourceTree = "<group>"; };
@@ -1683,7 +1683,6 @@
 		4BC751B11D157E61006C31D9 /* 6522Tests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = 6522Tests.swift; sourceTree = "<group>"; };
 		4BC76E671C98E31700E6EF73 /* FIRFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FIRFilter.cpp; sourceTree = "<group>"; };
 		4BC76E681C98E31700E6EF73 /* FIRFilter.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = FIRFilter.hpp; sourceTree = "<group>"; };
-		4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Accelerate.framework; path = System/Library/Frameworks/Accelerate.framework; sourceTree = SDKROOT; };
 		4BC890D1230F86020025A55A /* DirectAccessDevice.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = DirectAccessDevice.cpp; sourceTree = "<group>"; };
 		4BC890D2230F86020025A55A /* DirectAccessDevice.hpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.h; path = DirectAccessDevice.hpp; sourceTree = "<group>"; };
 		4BC91B811D1F160E00884B76 /* CommodoreTAP.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CommodoreTAP.cpp; sourceTree = "<group>"; };
@@ -1810,7 +1809,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				4B055AF21FAE9C1C0060FFFF /* OpenGL.framework in Frameworks */,
-				4B055AF11FAE9C160060FFFF /* Accelerate.framework in Frameworks */,
+				4BB8617224E22F5A00A00E03 /* Accelerate.framework in Frameworks */,
 				4B055ABD1FAE86530060FFFF /* libz.tbd in Frameworks */,
 				4B055A7A1FAE78A00060FFFF /* SDL2.framework in Frameworks */,
 			);
@@ -1820,8 +1819,8 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				4BB8617124E22F5700A00E03 /* Accelerate.framework in Frameworks */,
 				4B50AF80242817F40099BBD7 /* QuartzCore.framework in Frameworks */,
-				4BC76E6B1C98F43700E6EF73 /* Accelerate.framework in Frameworks */,
 				4B69FB461C4D950F00B5F0AA /* libz.tbd in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -1831,7 +1830,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				4B9F11CA2272433900701480 /* libz.tbd in Frameworks */,
-				4B778F6423A5F3730000D260 /* Accelerate.framework in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -1848,6 +1846,7 @@
 		4B055A761FAE78210060FFFF /* Frameworks */ = {
 			isa = PBXGroup;
 			children = (
+				4BB8617024E22F4900A00E03 /* Accelerate.framework */,
 				4B50AF7F242817F40099BBD7 /* QuartzCore.framework */,
 				4B055AF01FAE9C080060FFFF /* OpenGL.framework */,
 				4B055A771FAE78210060FFFF /* SDL2.framework */,
@@ -3324,7 +3323,6 @@
 		4BB73E951B587A5100552FC2 = {
 			isa = PBXGroup;
 			children = (
-				4BC76E6A1C98F43700E6EF73 /* Accelerate.framework */,
 				4B51F70820A521D700AFA2C1 /* Activity */,
 				4B8944E2201967B4007DE474 /* Analyser */,
 				4BB73EA01B587A5100552FC2 /* Clock Signal */,

From 4b55df1cb4ad50fbdc025e7c2249a968797e3127 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 10 Aug 2020 22:03:39 -0400
Subject: [PATCH 033/131] Starts upon a macro-oriented means of RGB input
 function generation.

---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 205bbd39a..ae1a11703 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -142,11 +142,28 @@ fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_
 }
 
 // All the RGB formats can produce RGB, composite or S-Video.
+//
+// Note on the below: in Metal you may not call a fragment function. Also I can find no
+// functioning way to offer a templated fragment function. So I don't currently know how
+// I would avoid the mess below.
 
-fragment float4 sampleRed8Green8Blue8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return float4(texture.sample(standardSampler, vert.textureCoordinates));
+float3 convertRed8Green8Blue8(SourceInterpolator vert, texture2d<float> texture) {
+	return float3(texture.sample(standardSampler, vert.textureCoordinates));
 }
 
+#define DeclareShaders(name)	\
+	fragment float4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {	\
+		return float4(convert##name(vert, texture), 1.0);	\
+	}	\
+	\
+	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {	\
+		const auto colour = convert##name(vert, texture);	\
+		return float4(colour, 1.0);	\
+	}
+
+// TODO: a colour-space conversion matrix is required to proceed.
+DeclareShaders(Red8Green8Blue8)
+
 fragment float4 sampleRed1Green1Blue1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
 	return float4(sample&4, sample&2, sample&1, 1.0);

From 637ec35d6a28f3d9e08acc0c1305ed0c2436f5f4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 11 Aug 2020 19:58:57 -0400
Subject: [PATCH 034/131] Adds getters for standard colour-space conversion
 matrices.

These are just more details on the meaning of the colour spaces, so I think they belong here.
---
 Outputs/ScanTarget.hpp | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index b8f5858ae..92899e0c3 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -9,6 +9,7 @@
 #ifndef Outputs_Display_ScanTarget_h
 #define Outputs_Display_ScanTarget_h
 
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include "../ClockReceiver/TimeTypes.hpp"
@@ -153,6 +154,34 @@ constexpr inline DisplayType natural_display_type_for_data_type(InputDataType da
 	}
 }
 
+/// @returns A 3x3 matrix in row-major order to convert from @c colour_space to RGB.
+inline std::array<float, 9> to_rgb_matrix(ColourSpace colour_space) {
+	const std::array<float, 9> yiq_to_rgb = {1.0f, 1.0f, 1.0f, 0.956f, -0.272f, -1.106f, 0.621f, -0.647f, 1.703f};
+	const std::array<float, 9> yuv_to_rgb = {1.0f, 1.0f, 1.0f, 0.0f, -0.39465f, 2.03211f, 1.13983f, -0.58060f, 0.0f};
+
+	switch(colour_space) {
+		case ColourSpace::YIQ:	return yiq_to_rgb;
+		case ColourSpace::YUV:	return yuv_to_rgb;
+	}
+
+	// Should be unreachable.
+	return std::array<float, 9>{};
+}
+
+/// @returns A 3x3 matrix in row-major order to convert to @c colour_space to RGB.
+inline std::array<float, 9> from_rgb_matrix(ColourSpace colour_space) {
+	const std::array<float, 9> rgb_to_yiq = {0.299f, 0.596f, 0.211f, 0.587f, -0.274f, -0.523f, 0.114f, -0.322f, 0.312f};
+	const std::array<float, 9> rgb_to_yuv = {0.299f, -0.14713f, 0.615f, 0.587f, -0.28886f, -0.51499f, 0.114f, 0.436f, -0.10001f};
+
+	switch(colour_space) {
+		case ColourSpace::YIQ:	return rgb_to_yiq;
+		case ColourSpace::YUV:	return rgb_to_yuv;
+	}
+
+	// Should be unreachable.
+	return std::array<float, 9>{};
+}
+
 /*!
 	Provides an abstract target for 'scans' i.e. continuous sweeps of output data,
 	which are identified by 2d start and end coordinates, and the PCM-sampled data

From a136a00a2f63299a7f8715561fd8aa6e52bc1cd4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 11 Aug 2020 22:11:50 -0400
Subject: [PATCH 035/131] Takes a shot at adding RGB -> S-Video and composite
 conversion, for all RGB types.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 182 ++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  72 ++++---
 2 files changed, 153 insertions(+), 101 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 6505fad52..b85da72f1 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -18,6 +18,8 @@ struct Uniforms {
 	int32_t scale[2];
 	float lineWidth;
 	float aspectRatioMultiplier;
+	simd::float3x3 toRGB;
+	simd::float3x3 fromRGB;
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -104,6 +106,108 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	uniforms()->aspectRatioMultiplier = float((4.0 / 3.0) / (size.width / size.height));
 }
 
+- (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals view:(nonnull MTKView *)view {
+	//
+	// Populate uniforms.
+	//
+	uniforms()->scale[0] = modals.output_scale.x;
+	uniforms()->scale[1] = modals.output_scale.y;
+	uniforms()->lineWidth = 1.0f / modals.expected_vertical_lines;
+
+	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
+	uniforms()->toRGB = simd::float3x3(
+		simd::float3{toRGB[0], toRGB[1], toRGB[2]},
+		simd::float3{toRGB[3], toRGB[4], toRGB[5]},
+		simd::float3{toRGB[6], toRGB[7], toRGB[8]}
+	);
+
+	const auto fromRGB = from_rgb_matrix(modals.composite_colour_space);
+	uniforms()->fromRGB = simd::float3x3(
+		simd::float3{fromRGB[0], fromRGB[1], fromRGB[2]},
+		simd::float3{fromRGB[3], fromRGB[4], fromRGB[5]},
+		simd::float3{fromRGB[6], fromRGB[7], fromRGB[8]}
+	);
+
+
+
+	//
+	// Generate input texture.
+	//
+	MTLPixelFormat pixelFormat;
+	_bytesPerInputPixel = size_for_data_type(modals.input_data_type);
+	if(data_type_is_normalised(modals.input_data_type)) {
+		switch(_bytesPerInputPixel) {
+			default:
+			case 1: pixelFormat = MTLPixelFormatR8Unorm;	break;
+			case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
+			case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
+		}
+	} else {
+		switch(_bytesPerInputPixel) {
+			default:
+			case 1: pixelFormat = MTLPixelFormatR8Uint;		break;
+			case 2: pixelFormat = MTLPixelFormatRG8Uint;	break;
+			case 4: pixelFormat = MTLPixelFormatRGBA8Uint;	break;
+		}
+	}
+	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:pixelFormat
+		width:BufferingScanTarget::WriteAreaWidth
+		height:BufferingScanTarget::WriteAreaHeight
+		mipmapped:NO];
+	textureDescriptor.resourceOptions = SharedResourceOptionsTexture;
+
+	// TODO: the call below is the only reason why this project now requires macOS 10.13; is it all that helpful versus just uploading each frame?
+	const NSUInteger bytesPerRow = BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel;
+	_writeAreaTexture = [_writeAreaBuffer
+		newTextureWithDescriptor:textureDescriptor
+		offset:0
+		bytesPerRow:bytesPerRow];
+	_totalTextureBytes = bytesPerRow * BufferingScanTarget::WriteAreaHeight;
+
+
+
+	//
+	// Generate pipeline.
+	//
+	id<MTLLibrary> library = [view.device newDefaultLibrary];
+	MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+	pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+
+	// TODO: logic somewhat more complicated than this, probably
+	pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToDisplay"];
+	switch(modals.input_data_type) {
+		case Outputs::Display::InputDataType::Luminance1:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance1"];
+		break;
+		case Outputs::Display::InputDataType::Luminance8:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8"];
+		break;
+		case Outputs::Display::InputDataType::PhaseLinkedLuminance8:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"samplePhaseLinkedLuminance8"];
+		break;
+
+		case Outputs::Display::InputDataType::Luminance8Phase8:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8Phase8"];
+		break;
+
+		case Outputs::Display::InputDataType::Red1Green1Blue1:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed1Green1Blue1"];
+		break;
+		case Outputs::Display::InputDataType::Red2Green2Blue2:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed2Green2Blue2"];
+		break;
+		case Outputs::Display::InputDataType::Red4Green4Blue4:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed4Green4Blue4"];
+		break;
+		case Outputs::Display::InputDataType::Red8Green8Blue8:
+			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
+		break;
+	}
+
+	_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+}
+
 /*!
  @method drawInMTKView:
  @abstract Called on the delegate when it is asked to render into the view
@@ -112,82 +216,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 - (void)drawInMTKView:(nonnull MTKView *)view {
 	const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
 	if(newModals) {
-		uniforms()->scale[0] = newModals->output_scale.x;
-		uniforms()->scale[1] = newModals->output_scale.y;
-		uniforms()->lineWidth = 1.0f / newModals->expected_vertical_lines;
-
-		// TODO: obey the rest of the modals generally.
-
-		// Generate the appropriate input texture.
-		MTLPixelFormat pixelFormat;
-		_bytesPerInputPixel = size_for_data_type(newModals->input_data_type);
-		if(data_type_is_normalised(newModals->input_data_type)) {
-			switch(_bytesPerInputPixel) {
-				default:
-				case 1: pixelFormat = MTLPixelFormatR8Unorm;	break;
-				case 2: pixelFormat = MTLPixelFormatRG8Unorm;	break;
-				case 4: pixelFormat = MTLPixelFormatRGBA8Unorm;	break;
-			}
-		} else {
-			switch(_bytesPerInputPixel) {
-				default:
-				case 1: pixelFormat = MTLPixelFormatR8Uint;		break;
-				case 2: pixelFormat = MTLPixelFormatRG8Uint;	break;
-				case 4: pixelFormat = MTLPixelFormatRGBA8Uint;	break;
-			}
-		}
-		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:pixelFormat
-			width:BufferingScanTarget::WriteAreaWidth
-			height:BufferingScanTarget::WriteAreaHeight
-			mipmapped:NO];
-		textureDescriptor.resourceOptions = SharedResourceOptionsTexture;
-
-		// TODO: the call below is the only reason why this project now requires macOS 10.13; is it all that helpful versus just uploading each frame?
-		const NSUInteger bytesPerRow = BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel;
-		_writeAreaTexture = [_writeAreaBuffer
-			newTextureWithDescriptor:textureDescriptor
-			offset:0
-			bytesPerRow:bytesPerRow];
-		_totalTextureBytes = bytesPerRow * BufferingScanTarget::WriteAreaHeight;
-
-		// Generate pipeline.
-		id<MTLLibrary> library = [view.device newDefaultLibrary];
-		MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-		pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
-
-		// TODO: logic somewhat more complicated than this, probably
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToDisplay"];
-		switch(newModals->input_data_type) {
-			case Outputs::Display::InputDataType::Luminance1:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance1"];
-			break;
-			case Outputs::Display::InputDataType::Luminance8:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8"];
-			break;
-			case Outputs::Display::InputDataType::PhaseLinkedLuminance8:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"samplePhaseLinkedLuminance8"];
-			break;
-
-			case Outputs::Display::InputDataType::Luminance8Phase8:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8Phase8"];
-			break;
-
-			case Outputs::Display::InputDataType::Red1Green1Blue1:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed1Green1Blue1"];
-			break;
-			case Outputs::Display::InputDataType::Red2Green2Blue2:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed2Green2Blue2"];
-			break;
-			case Outputs::Display::InputDataType::Red4Green4Blue4:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed4Green4Blue4"];
-			break;
-			case Outputs::Display::InputDataType::Red8Green8Blue8:
-				pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
-			break;
-		}
-
-		_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+		[self setModals:*newModals view:view];
 	}
 
 	// Generate a command encoder for the view.
@@ -201,6 +230,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
 	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 	_scanTarget.perform([=] (const BufferingScanTarget::OutputArea &outputArea) {
 		// Ensure texture changes are noted.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index ae1a11703..d5bfa4877 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -19,6 +19,10 @@ struct Uniforms {
 
 	// Provides a scaling factor in order to preserve 4:3 central content.
 	float aspectRatioMultiplier;
+
+	// Provides conversions to and from RGB for the active colour space.
+	float3x3 toRGB;
+	float3x3 fromRGB;
 };
 
 // MARK: - Structs used for receiving data from the emulation.
@@ -143,38 +147,56 @@ fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_
 
 // All the RGB formats can produce RGB, composite or S-Video.
 //
-// Note on the below: in Metal you may not call a fragment function. Also I can find no
-// functioning way to offer a templated fragment function. So I don't currently know how
-// I would avoid the mess below.
+// Note on the below: in Metal you may not call a fragment function (so e.g. svideoSampleX can't just cann sampleX).
+// Also I can find no functioning way to offer a templated fragment function. So I don't currently know how
+// I could avoid the macro mess below.
 
+// TODO: is the calling convention here causing `vert` and `texture` to be copied?
 float3 convertRed8Green8Blue8(SourceInterpolator vert, texture2d<float> texture) {
 	return float3(texture.sample(standardSampler, vert.textureCoordinates));
 }
 
-#define DeclareShaders(name)	\
-	fragment float4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {	\
+float3 convertRed4Green4Blue4(SourceInterpolator vert, texture2d<ushort> texture) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).rg;
+	return float3(sample.r&15, (sample.g >> 4)&15, sample.g&15);
+}
+
+float3 convertRed2Green2Blue2(SourceInterpolator vert, texture2d<ushort> texture) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
+	return float3((sample >> 4)&3, (sample >> 2)&3, sample&3);
+}
+
+float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture) {
+	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
+	return float3(sample&4, sample&2, sample&1);
+}
+
+#define DeclareShaders(name, pixelType)	\
+	fragment float4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]]) {	\
 		return float4(convert##name(vert, texture), 1.0);	\
 	}	\
 	\
-	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {	\
-		const auto colour = convert##name(vert, texture);	\
-		return float4(colour, 1.0);	\
+	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
+		const float2 colourSubcarrier = float2(sin(vert.colourPhase), cos(vert.colourPhase))*0.5 + float2(0.5);	\
+		return float4(	\
+			colour.r,	\
+			dot(colour.gb, colourSubcarrier),	\
+			0.0,	\
+			1.0		\
+		);	\
+	}	\
+	\
+	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
+		const float2 colourSubcarrier = float2(sin(vert.colourPhase), cos(vert.colourPhase));	\
+		return float4(	\
+			float3(mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude)),	\
+			1.0		\
+		);	\
 	}
 
-// TODO: a colour-space conversion matrix is required to proceed.
-DeclareShaders(Red8Green8Blue8)
-
-fragment float4 sampleRed1Green1Blue1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
-	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return float4(sample&4, sample&2, sample&1, 1.0);
-}
-
-fragment float4 sampleRed2Green2Blue2(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
-	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return float4((sample >> 4)&3, (sample >> 2)&3, sample&3, 3.0) / 3.0;
-}
-
-fragment float4 sampleRed4Green4Blue4(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
-	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).rg;
-	return float4(sample.r&15, (sample.g >> 4)&15, sample.g&15, 15.0) / 15.0;
-}
+DeclareShaders(Red8Green8Blue8, float)
+DeclareShaders(Red4Green4Blue4, ushort)
+DeclareShaders(Red2Green2Blue2, ushort)
+DeclareShaders(Red1Green1Blue1, ushort)

From 27ca782cacddcadb24c2b04ba5c1efe7df45a6b3 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 12 Aug 2020 19:34:07 -0400
Subject: [PATCH 036/131] Enables blending; attempts to enable frame
 preservation.

The latter seems to be evidencing a double buffer at play. More investigation required.

On the plus side, the direct route is still well within GPU budget at 4k on my Core M. So a huge improvement there.
---
 .../Clock Signal/Base.lproj/MachineDocument.xib   |  2 +-
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm   | 15 +++++++++++++--
 .../Mac/Clock Signal/ScanTarget/ScanTarget.metal  |  3 ++-
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib
index b1eeadf5a..93bf418b9 100644
--- a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
+++ b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
@@ -27,7 +27,7 @@
                 <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                 <autoresizingMask key="autoresizingMask"/>
                 <subviews>
-                    <openGLView hidden="YES" wantsLayer="YES" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSScanTargetView">
+                    <openGLView hidden="YES" wantsLayer="YES" stencilSize="8bit" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSScanTargetView">
                         <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                     </openGLView>
                     <box hidden="YES" boxType="custom" cornerRadius="4" title="Box" titlePosition="noTitle" translatesAutoresizingMaskIntoConstraints="NO" id="4ap-Gi-2AO">
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index b85da72f1..a5059fa4d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -112,7 +112,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	//
 	uniforms()->scale[0] = modals.output_scale.x;
 	uniforms()->scale[1] = modals.output_scale.y;
-	uniforms()->lineWidth = 1.0f / modals.expected_vertical_lines;
+	uniforms()->lineWidth = 0.75f / modals.expected_vertical_lines;	// TODO: return to 1.0 (or slightly more), once happy.
 
 	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
 	uniforms()->toRGB = simd::float3x3(
@@ -205,6 +205,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		break;
 	}
 
+	// Enable blending.
+	pipelineDescriptor.colorAttachments[0].blendingEnabled = YES;
+	pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorSourceAlpha;
+	pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
+
 	_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 }
 
@@ -219,9 +224,15 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		[self setModals:*newModals view:view];
 	}
 
+	// Buy into framebuffer preservation.
+	// TODO: do I really need to do this on every draw?
+	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
+	descriptor.colorAttachments[0].loadAction = MTLLoadActionLoad;
+	descriptor.colorAttachments[0].storeAction = MTLStoreActionStore;
+	descriptor.colorAttachments[0].clearColor = MTLClearColorMake(1.0, 1.0, 0.0, 1.0);
+
 	// Generate a command encoder for the view.
 	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
 	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
 
 	// Drawing. Just scans.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index d5bfa4877..944222e87 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -171,9 +171,10 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	return float3(sample&4, sample&2, sample&1);
 }
 
+// TODO: don't hard code the 0.64 in sample##name.
 #define DeclareShaders(name, pixelType)	\
 	fragment float4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]]) {	\
-		return float4(convert##name(vert, texture), 1.0);	\
+		return float4(convert##name(vert, texture), 0.64);	\
 	}	\
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\

From 230b9fc9e69c41a0fd87edb527681906b29c6332 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 12 Aug 2020 22:08:41 -0400
Subject: [PATCH 037/131] Permits multiple simultaneous scan reading ranges.

Also updates the OpenGL scan target as per the latest movements of things.
---
 .../Base.lproj/MachineDocument.xib            |  2 +-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 55 ++++++++++---------
 Outputs/OpenGL/ScanTarget.cpp                 | 10 +++-
 Outputs/ScanTargets/BufferingScanTarget.cpp   | 37 +++++++------
 Outputs/ScanTargets/BufferingScanTarget.hpp   | 26 ++++++++-
 5 files changed, 82 insertions(+), 48 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib
index 93bf418b9..b1eeadf5a 100644
--- a/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
+++ b/OSBindings/Mac/Clock Signal/Base.lproj/MachineDocument.xib	
@@ -27,7 +27,7 @@
                 <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                 <autoresizingMask key="autoresizingMask"/>
                 <subviews>
-                    <openGLView hidden="YES" wantsLayer="YES" stencilSize="8bit" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSScanTargetView">
+                    <openGLView hidden="YES" wantsLayer="YES" useAuxiliaryDepthBufferStencil="NO" allowOffline="YES" wantsBestResolutionOpenGLSurface="YES" translatesAutoresizingMaskIntoConstraints="NO" id="DEG-fq-cjd" customClass="CSScanTargetView">
                         <rect key="frame" x="0.0" y="0.0" width="600" height="450"/>
                     </openGLView>
                     <box hidden="YES" boxType="custom" cornerRadius="4" title="Box" titlePosition="noTitle" translatesAutoresizingMaskIntoConstraints="NO" id="4ap-Gi-2AO">
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a5059fa4d..763746aab 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -243,38 +243,43 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
 	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
 
-	_scanTarget.perform([=] (const BufferingScanTarget::OutputArea &outputArea) {
-		// Ensure texture changes are noted.
-		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
-		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
-		if(writeAreaModificationStart != writeAreaModificationEnd) {
-			if(writeAreaModificationStart < writeAreaModificationEnd) {
-				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
-			} else {
-				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
-				if(writeAreaModificationEnd) {
-					[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
-				}
-			}
+	const auto outputArea = _scanTarget.get_output_area();
 
-		}
-
-		// TEMPORARY: just draw the scans.
-		if(outputArea.start.scan != outputArea.end.scan) {
-			if(outputArea.start.scan < outputArea.end.scan) {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
-			} else {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
-				if(outputArea.end.scan) {
-					[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
-				}
+	// Ensure texture changes are noted.
+	const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
+	const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
+	if(writeAreaModificationStart != writeAreaModificationEnd) {
+		if(writeAreaModificationStart < writeAreaModificationEnd) {
+			[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
+		} else {
+			[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
+			if(writeAreaModificationEnd) {
+				[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
 			}
 		}
-	});
+
+	}
+
+	// TEMPORARY: just draw the scans.
+	if(outputArea.start.scan != outputArea.end.scan) {
+		if(outputArea.start.scan < outputArea.end.scan) {
+			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
+		} else {
+			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
+			if(outputArea.end.scan) {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
+			}
+		}
+	}
 
 	// Complete encoding.
 	[encoder endEncoding];
 
+	// Add a callback to update the buffer.
+	[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+		self->_scanTarget.complete_output_area(outputArea);
+	}];
+
 	// Register the drawable's presentation, finalise and commit.
 	[commandBuffer presentDrawable:view.currentDrawable];
 	[commandBuffer commit];
diff --git a/Outputs/OpenGL/ScanTarget.cpp b/Outputs/OpenGL/ScanTarget.cpp
index 3a1078422..55c27a216 100644
--- a/Outputs/OpenGL/ScanTarget.cpp
+++ b/Outputs/OpenGL/ScanTarget.cpp
@@ -118,8 +118,9 @@ void ScanTarget::setup_pipeline() {
 	const auto data_type_size = Outputs::Display::size_for_data_type(modals.input_data_type);
 
 	// Resize the texture only if required.
-	if(data_type_size != write_area_data_size()) {
-		write_area_texture_.resize(WriteAreaWidth*WriteAreaHeight*data_type_size);
+	const size_t required_size = WriteAreaWidth*WriteAreaHeight*data_type_size;
+	if(required_size != write_area_data_size()) {
+		write_area_texture_.resize(required_size);
 		set_write_area(write_area_texture_.data());
 	}
 
@@ -186,7 +187,9 @@ void ScanTarget::update(int, int output_height) {
 		true);
 
 	// Grab the new output list.
-	perform([=] (const OutputArea &area) {
+	perform([=] {
+		OutputArea area = get_output_area();
+
 		// Establish the pipeline if necessary.
 		const auto new_modals = BufferingScanTarget::new_modals();
 		const bool did_setup_pipeline = bool(new_modals);
@@ -478,6 +481,7 @@ void ScanTarget::update(int, int output_height) {
 		// Grab a fence sync object to avoid busy waiting upon the next extry into this
 		// function, and reset the is_updating_ flag.
 		fence_ = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+		complete_output_area(area);
 	});
 }
 
diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index b14f6f6e1..b89fcdbdf 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -284,40 +284,45 @@ void BufferingScanTarget::set_modals(Modals modals) {
 
 // MARK: - Consumer.
 
-void BufferingScanTarget::perform(const std::function<void(const OutputArea &)> &function) {
-#ifdef ONE_BIG_LOCK
-	std::lock_guard lock_guard(producer_mutex_);
-#endif
-
+BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 	// The area to draw is that between the read pointers, representing wherever reading
 	// last stopped, and the submit pointers, representing all the new data that has been
 	// cleared for submission.
 	const auto submit_pointers = submit_pointers_.load(std::memory_order::memory_order_acquire);
-	const auto read_pointers = read_pointers_.load(std::memory_order::memory_order_relaxed);
+	const auto read_ahead_pointers = read_ahead_pointers_.load(std::memory_order::memory_order_relaxed);
 
 	OutputArea area;
 
-	area.start.line = read_pointers.line;
+	area.start.line = read_ahead_pointers.line;
 	area.end.line = submit_pointers.line;
 
-	area.start.scan = read_pointers.scan_buffer;
+	area.start.scan = read_ahead_pointers.scan_buffer;
 	area.end.scan = submit_pointers.scan_buffer;
 
-	area.start.write_area_x = TextureAddressGetX(read_pointers.write_area);
-	area.start.write_area_y = TextureAddressGetY(read_pointers.write_area);
+	area.start.write_area_x = TextureAddressGetX(read_ahead_pointers.write_area);
+	area.start.write_area_y = TextureAddressGetY(read_ahead_pointers.write_area);
 	area.end.write_area_x = TextureAddressGetX(submit_pointers.write_area);
 	area.end.write_area_y = TextureAddressGetY(submit_pointers.write_area);
 
-	// Perform only while holding the is_updating lock.
-	while(is_updating_.test_and_set(std::memory_order_acquire));
-	function(area);
-	is_updating_.clear(std::memory_order_release);
+	// Update the read-ahead pointers.
+	read_ahead_pointers_.store(submit_pointers, std::memory_order::memory_order_relaxed);
 
-	// Update the read pointers.
-	read_pointers_.store(submit_pointers, std::memory_order::memory_order_relaxed);
+	return area;
+}
+
+void BufferingScanTarget::complete_output_area(const OutputArea &area) {
+	PointerSet new_read_pointers;
+	new_read_pointers.line = uint16_t(area.end.line);
+	new_read_pointers.scan_buffer = uint16_t(area.end.scan);
+	new_read_pointers.write_area = TextureAddress(area.end.write_area_x, area.end.write_area_y);
+	read_pointers_.store(new_read_pointers, std::memory_order::memory_order_relaxed);
 }
 
 void BufferingScanTarget::perform(const std::function<void(void)> &function) {
+#ifdef ONE_BIG_LOCK
+	std::lock_guard lock_guard(producer_mutex_);
+#endif
+
 	while(is_updating_.test_and_set(std::memory_order_acquire));
 	function();
 	is_updating_.clear(std::memory_order_release);
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 4809b3d74..07ea61da3 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -114,6 +114,10 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		/// (iii) the number of lines that have been completed.
 		///
 		/// New write areas and scans are exposed only upon completion of the corresponding lines.
+		/// The values indicated by the start point are the first that should be drawn. Those indicated
+		/// by the end point are one after the final that should be drawn.
+		///
+		/// So e.g. start.scan = 23, end.scan = 24 means draw a single scan, index 23.
 		struct OutputArea {
 			struct Endpoint {
 				int write_area_x, write_area_y;
@@ -123,13 +127,27 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 
 			Endpoint start, end;
 		};
+
+		/// Gets the current range of content that has been posted but not yet returned by
+		/// a previous call to get_output_area().
+		///
+		/// Does not require the caller to be within a @c perform block.
+		OutputArea get_output_area();
+
+		/// Announces that the output area has now completed output, freeing up its memory for
+		/// further modification.
+		///
+		/// It is the caller's responsibility to ensure that the areas passed to complete_output_area
+		/// are those from get_output_area and are marked as completed in the same order that
+		/// they were originally provided.
+		///
+		/// Does not require the caller to be within a @c perform block.
+		void complete_output_area(const OutputArea &);
+
 		/// Performs @c action ensuring that no other @c perform actions, or any
 		/// change to modals, occurs simultaneously.
 		void perform(const std::function<void(void)> &action);
 
-		/// Acts as per void(void) @c perform but also dequeues all latest available video output.
-		void perform(const std::function<void(const OutputArea &)> &);
-
 		/// @returns new Modals if any have been set since the last call to get_new_modals().
 		///		The caller must be within a @c perform block.
 		const Modals *new_modals();
@@ -201,6 +219,8 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		/// may run and is therefore used by both producer and consumer.
 		std::atomic<PointerSet> read_pointers_;
 
+		std::atomic<PointerSet> read_ahead_pointers_;
+
 		/// This is used as a spinlock to guard `perform` calls.
 		std::atomic_flag is_updating_;
 

From 7ac88536dd99b608abb6171c94b32601df550cc4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 14 Aug 2020 21:24:25 -0400
Subject: [PATCH 038/131] Respects machine aspect ratio.

To an extent. Doesn't currently deal with cropping of machines when the window aspect ratio is smaller.
---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 763746aab..cfb9dbc2f 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -103,7 +103,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @param size New drawable size in pixels
  */
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
-	uniforms()->aspectRatioMultiplier = float((4.0 / 3.0) / (size.width / size.height));
+	uniforms()->aspectRatioMultiplier = float(_scanTarget.modals().aspect_ratio / (size.width / size.height));
 }
 
 - (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals view:(nonnull MTKView *)view {
@@ -113,6 +113,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	uniforms()->scale[0] = modals.output_scale.x;
 	uniforms()->scale[1] = modals.output_scale.y;
 	uniforms()->lineWidth = 0.75f / modals.expected_vertical_lines;	// TODO: return to 1.0 (or slightly more), once happy.
+	uniforms()->aspectRatioMultiplier = float(modals.aspect_ratio / (view.bounds.size.width / view.bounds.size.height));
 
 	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
 	uniforms()->toRGB = simd::float3x3(
@@ -156,6 +157,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		height:BufferingScanTarget::WriteAreaHeight
 		mipmapped:NO];
 	textureDescriptor.resourceOptions = SharedResourceOptionsTexture;
+	if(@available(macOS 10.14, *)) {
+		textureDescriptor.allowGPUOptimizedContents = NO;
+	}
 
 	// TODO: the call below is the only reason why this project now requires macOS 10.13; is it all that helpful versus just uploading each frame?
 	const NSUInteger bytesPerRow = BufferingScanTarget::WriteAreaWidth * _bytesPerInputPixel;

From e55945674df1c95d027c1ec5fc31d7c867f4feb0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 14 Aug 2020 22:16:49 -0400
Subject: [PATCH 039/131] Reduces main thread blocking.

---
 .../Mac/Clock Signal/Machine/CSMachine.mm     | 164 ++++++++++--------
 1 file changed, 93 insertions(+), 71 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index 26d164dee..aa783e070 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -159,6 +159,12 @@ struct ActivityObserver: public Activity::Observer {
 	Time::ScanSynchroniser _scanSynchroniser;
 
 	NSTimer *_joystickTimer;
+
+	// This array exists to reduce blocking on the main queue; anything that would otherwise need
+	// to synchronise on self in order to post input to the machine can instead synchronise on
+	// _inputEvents and add a block to it. The main machine execution loop promises to synchronise
+	// on _inputEvents very briefly at the start of every tick and execute all enqueued blocks.
+	NSMutableArray<dispatch_block_t> *_inputEvents;
 }
 
 - (instancetype)initWithAnalyser:(CSStaticAnalyser *)result missingROMs:(inout NSMutableArray<CSMissingROM *> *)missingROMs {
@@ -210,6 +216,8 @@ struct ActivityObserver: public Activity::Observer {
 		_speakerDelegate.machine = self;
 		_speakerDelegate.machineAccessLock = _delegateMachineAccessLock;
 
+		_inputEvents = [[NSMutableArray alloc] init];
+
 		_joystickMachine = _machine->joystick_machine();
 		[self updateJoystickTimer];
 		_isUpdating.clear();
@@ -415,84 +423,84 @@ struct ActivityObserver: public Activity::Observer {
 }
 
 - (void)setKey:(uint16_t)key characters:(NSString *)characters isPressed:(BOOL)isPressed {
-	auto keyboard_machine = _machine->keyboard_machine();
-	if(keyboard_machine && (self.inputMode != CSMachineKeyboardInputModeJoystick || !keyboard_machine->get_keyboard().is_exclusive())) {
-		Inputs::Keyboard::Key mapped_key = Inputs::Keyboard::Key::Help;	// Make an innocuous default guess.
+	[self applyInputEvent:^{
+		auto keyboard_machine = self->_machine->keyboard_machine();
+		if(keyboard_machine && (self.inputMode != CSMachineKeyboardInputModeJoystick || !keyboard_machine->get_keyboard().is_exclusive())) {
+			Inputs::Keyboard::Key mapped_key = Inputs::Keyboard::Key::Help;	// Make an innocuous default guess.
 #define BIND(source, dest) case source: mapped_key = Inputs::Keyboard::Key::dest; break;
-		// Connect the Carbon-era Mac keyboard scancodes to Clock Signal's 'universal' enumeration in order
-		// to pass into the platform-neutral realm.
-		switch(key) {
-			BIND(VK_ANSI_0, k0);	BIND(VK_ANSI_1, k1);	BIND(VK_ANSI_2, k2);	BIND(VK_ANSI_3, k3);	BIND(VK_ANSI_4, k4);
-			BIND(VK_ANSI_5, k5);	BIND(VK_ANSI_6, k6);	BIND(VK_ANSI_7, k7);	BIND(VK_ANSI_8, k8);	BIND(VK_ANSI_9, k9);
+			// Connect the Carbon-era Mac keyboard scancodes to Clock Signal's 'universal' enumeration in order
+			// to pass into the platform-neutral realm.
+			switch(key) {
+				BIND(VK_ANSI_0, k0);	BIND(VK_ANSI_1, k1);	BIND(VK_ANSI_2, k2);	BIND(VK_ANSI_3, k3);	BIND(VK_ANSI_4, k4);
+				BIND(VK_ANSI_5, k5);	BIND(VK_ANSI_6, k6);	BIND(VK_ANSI_7, k7);	BIND(VK_ANSI_8, k8);	BIND(VK_ANSI_9, k9);
 
-			BIND(VK_ANSI_Q, Q);		BIND(VK_ANSI_W, W);		BIND(VK_ANSI_E, E);		BIND(VK_ANSI_R, R);		BIND(VK_ANSI_T, T);
-			BIND(VK_ANSI_Y, Y);		BIND(VK_ANSI_U, U);		BIND(VK_ANSI_I, I);		BIND(VK_ANSI_O, O);		BIND(VK_ANSI_P, P);
+				BIND(VK_ANSI_Q, Q);		BIND(VK_ANSI_W, W);		BIND(VK_ANSI_E, E);		BIND(VK_ANSI_R, R);		BIND(VK_ANSI_T, T);
+				BIND(VK_ANSI_Y, Y);		BIND(VK_ANSI_U, U);		BIND(VK_ANSI_I, I);		BIND(VK_ANSI_O, O);		BIND(VK_ANSI_P, P);
 
-			BIND(VK_ANSI_A, A);		BIND(VK_ANSI_S, S);		BIND(VK_ANSI_D, D);		BIND(VK_ANSI_F, F);		BIND(VK_ANSI_G, G);
-			BIND(VK_ANSI_H, H);		BIND(VK_ANSI_J, J);		BIND(VK_ANSI_K, K);		BIND(VK_ANSI_L, L);
+				BIND(VK_ANSI_A, A);		BIND(VK_ANSI_S, S);		BIND(VK_ANSI_D, D);		BIND(VK_ANSI_F, F);		BIND(VK_ANSI_G, G);
+				BIND(VK_ANSI_H, H);		BIND(VK_ANSI_J, J);		BIND(VK_ANSI_K, K);		BIND(VK_ANSI_L, L);
 
-			BIND(VK_ANSI_Z, Z);		BIND(VK_ANSI_X, X);		BIND(VK_ANSI_C, C);		BIND(VK_ANSI_V, V);
-			BIND(VK_ANSI_B, B);		BIND(VK_ANSI_N, N);		BIND(VK_ANSI_M, M);
+				BIND(VK_ANSI_Z, Z);		BIND(VK_ANSI_X, X);		BIND(VK_ANSI_C, C);		BIND(VK_ANSI_V, V);
+				BIND(VK_ANSI_B, B);		BIND(VK_ANSI_N, N);		BIND(VK_ANSI_M, M);
 
-			BIND(VK_F1, F1);		BIND(VK_F2, F2);		BIND(VK_F3, F3);		BIND(VK_F4, F4);
-			BIND(VK_F5, F5);		BIND(VK_F6, F6);		BIND(VK_F7, F7);		BIND(VK_F8, F8);
-			BIND(VK_F9, F9);		BIND(VK_F10, F10);		BIND(VK_F11, F11);		BIND(VK_F12, F12);
+				BIND(VK_F1, F1);		BIND(VK_F2, F2);		BIND(VK_F3, F3);		BIND(VK_F4, F4);
+				BIND(VK_F5, F5);		BIND(VK_F6, F6);		BIND(VK_F7, F7);		BIND(VK_F8, F8);
+				BIND(VK_F9, F9);		BIND(VK_F10, F10);		BIND(VK_F11, F11);		BIND(VK_F12, F12);
 
-			BIND(VK_ANSI_Keypad0, Keypad0);		BIND(VK_ANSI_Keypad1, Keypad1);		BIND(VK_ANSI_Keypad2, Keypad2);
-			BIND(VK_ANSI_Keypad3, Keypad3);		BIND(VK_ANSI_Keypad4, Keypad4);		BIND(VK_ANSI_Keypad5, Keypad5);
-			BIND(VK_ANSI_Keypad6, Keypad6);		BIND(VK_ANSI_Keypad7, Keypad7);		BIND(VK_ANSI_Keypad8, Keypad8);
-			BIND(VK_ANSI_Keypad9, Keypad9);
+				BIND(VK_ANSI_Keypad0, Keypad0);		BIND(VK_ANSI_Keypad1, Keypad1);		BIND(VK_ANSI_Keypad2, Keypad2);
+				BIND(VK_ANSI_Keypad3, Keypad3);		BIND(VK_ANSI_Keypad4, Keypad4);		BIND(VK_ANSI_Keypad5, Keypad5);
+				BIND(VK_ANSI_Keypad6, Keypad6);		BIND(VK_ANSI_Keypad7, Keypad7);		BIND(VK_ANSI_Keypad8, Keypad8);
+				BIND(VK_ANSI_Keypad9, Keypad9);
 
-			BIND(VK_ANSI_Equal, Equals);						BIND(VK_ANSI_Minus, Hyphen);
-			BIND(VK_ANSI_RightBracket, CloseSquareBracket);		BIND(VK_ANSI_LeftBracket, OpenSquareBracket);
-			BIND(VK_ANSI_Quote, Quote);							BIND(VK_ANSI_Grave, BackTick);
+				BIND(VK_ANSI_Equal, Equals);						BIND(VK_ANSI_Minus, Hyphen);
+				BIND(VK_ANSI_RightBracket, CloseSquareBracket);		BIND(VK_ANSI_LeftBracket, OpenSquareBracket);
+				BIND(VK_ANSI_Quote, Quote);							BIND(VK_ANSI_Grave, BackTick);
 
-			BIND(VK_ANSI_Semicolon, Semicolon);
-			BIND(VK_ANSI_Backslash, Backslash);					BIND(VK_ANSI_Slash, ForwardSlash);
-			BIND(VK_ANSI_Comma, Comma);							BIND(VK_ANSI_Period, FullStop);
+				BIND(VK_ANSI_Semicolon, Semicolon);
+				BIND(VK_ANSI_Backslash, Backslash);					BIND(VK_ANSI_Slash, ForwardSlash);
+				BIND(VK_ANSI_Comma, Comma);							BIND(VK_ANSI_Period, FullStop);
 
-			BIND(VK_ANSI_KeypadDecimal, KeypadDecimalPoint);	BIND(VK_ANSI_KeypadEquals, KeypadEquals);
-			BIND(VK_ANSI_KeypadMultiply, KeypadAsterisk);		BIND(VK_ANSI_KeypadDivide, KeypadSlash);
-			BIND(VK_ANSI_KeypadPlus, KeypadPlus);				BIND(VK_ANSI_KeypadMinus, KeypadMinus);
-			BIND(VK_ANSI_KeypadClear, KeypadDelete);			BIND(VK_ANSI_KeypadEnter, KeypadEnter);
+				BIND(VK_ANSI_KeypadDecimal, KeypadDecimalPoint);	BIND(VK_ANSI_KeypadEquals, KeypadEquals);
+				BIND(VK_ANSI_KeypadMultiply, KeypadAsterisk);		BIND(VK_ANSI_KeypadDivide, KeypadSlash);
+				BIND(VK_ANSI_KeypadPlus, KeypadPlus);				BIND(VK_ANSI_KeypadMinus, KeypadMinus);
+				BIND(VK_ANSI_KeypadClear, KeypadDelete);			BIND(VK_ANSI_KeypadEnter, KeypadEnter);
 
-			BIND(VK_Return, Enter);					BIND(VK_Tab, Tab);
-			BIND(VK_Space, Space);					BIND(VK_Delete, Backspace);
-			BIND(VK_Control, LeftControl);			BIND(VK_Option, LeftOption);
-			BIND(VK_Command, LeftMeta);				BIND(VK_Shift, LeftShift);
-			BIND(VK_RightControl, RightControl);	BIND(VK_RightOption, RightOption);
-			BIND(VK_Escape, Escape);				BIND(VK_CapsLock, CapsLock);
-			BIND(VK_Home, Home);					BIND(VK_End, End);
-			BIND(VK_PageUp, PageUp);				BIND(VK_PageDown, PageDown);
+				BIND(VK_Return, Enter);					BIND(VK_Tab, Tab);
+				BIND(VK_Space, Space);					BIND(VK_Delete, Backspace);
+				BIND(VK_Control, LeftControl);			BIND(VK_Option, LeftOption);
+				BIND(VK_Command, LeftMeta);				BIND(VK_Shift, LeftShift);
+				BIND(VK_RightControl, RightControl);	BIND(VK_RightOption, RightOption);
+				BIND(VK_Escape, Escape);				BIND(VK_CapsLock, CapsLock);
+				BIND(VK_Home, Home);					BIND(VK_End, End);
+				BIND(VK_PageUp, PageUp);				BIND(VK_PageDown, PageDown);
 
-			BIND(VK_RightShift, RightShift);
-			BIND(VK_Help, Help);
-			BIND(VK_ForwardDelete, Delete);
+				BIND(VK_RightShift, RightShift);
+				BIND(VK_Help, Help);
+				BIND(VK_ForwardDelete, Delete);
 
-			BIND(VK_LeftArrow, Left);		BIND(VK_RightArrow, Right);
-			BIND(VK_DownArrow, Down);		BIND(VK_UpArrow, Up);
-		}
+				BIND(VK_LeftArrow, Left);		BIND(VK_RightArrow, Right);
+				BIND(VK_DownArrow, Down);		BIND(VK_UpArrow, Up);
+			}
 #undef BIND
 
-		// Pick an ASCII code, if any.
-		char pressedKey = '\0';
-		if(characters.length) {
-			unichar firstCharacter = [characters characterAtIndex:0];
-			if(firstCharacter < 128) {
-				pressedKey = (char)firstCharacter;
+			// Pick an ASCII code, if any.
+			char pressedKey = '\0';
+			if(characters.length) {
+				unichar firstCharacter = [characters characterAtIndex:0];
+				if(firstCharacter < 128) {
+					pressedKey = (char)firstCharacter;
+				}
+			}
+
+			@synchronized(self) {
+				if(keyboard_machine->apply_key(mapped_key, pressedKey, isPressed, self.inputMode == CSMachineKeyboardInputModeKeyboardLogical)) {
+					return;
+				}
 			}
 		}
 
-		@synchronized(self) {
-			if(keyboard_machine->apply_key(mapped_key, pressedKey, isPressed, self.inputMode == CSMachineKeyboardInputModeKeyboardLogical)) {
-				return;
-			}
-		}
-	}
-
-	auto joystick_machine = _machine->joystick_machine();
-	if(self.inputMode == CSMachineKeyboardInputModeJoystick && joystick_machine) {
-		@synchronized(self) {
+		auto joystick_machine = self->_machine->joystick_machine();
+		if(self.inputMode == CSMachineKeyboardInputModeJoystick && joystick_machine) {
 			auto &joysticks = joystick_machine->get_joysticks();
 			if(!joysticks.empty()) {
 				// Convert to a C++ bool so that the following calls are resolved correctly even if overloaded.
@@ -517,49 +525,55 @@ struct ActivityObserver: public Activity::Observer {
 				}
 			}
 		}
+	}];
+}
+
+- (void)applyInputEvent:(dispatch_block_t)event {
+	@synchronized(_inputEvents) {
+		[_inputEvents addObject:event];
 	}
 }
 
 - (void)clearAllKeys {
 	const auto keyboard_machine = _machine->keyboard_machine();
 	if(keyboard_machine) {
-		@synchronized(self) {
+		[self applyInputEvent:^{
 			keyboard_machine->get_keyboard().reset_all_keys();
-		}
+		}];
 	}
 
 	const auto joystick_machine = _machine->joystick_machine();
 	if(joystick_machine) {
-		@synchronized(self) {
+		[self applyInputEvent:^{
 			for(auto &joystick : joystick_machine->get_joysticks()) {
 				joystick->reset_all_inputs();
 			}
-		}
+		}];
 	}
 
 	const auto mouse_machine = _machine->mouse_machine();
 	if(mouse_machine) {
-		@synchronized(self) {
+		[self applyInputEvent:^{
 			mouse_machine->get_mouse().reset_all_buttons();
-		}
+		}];
 	}
 }
 
 - (void)setMouseButton:(int)button isPressed:(BOOL)isPressed {
 	auto mouse_machine = _machine->mouse_machine();
 	if(mouse_machine) {
-		@synchronized(self) {
+		[self applyInputEvent:^{
 			mouse_machine->get_mouse().set_button_pressed(button % mouse_machine->get_mouse().get_number_of_buttons(), isPressed);
-		}
+		}];
 	}
 }
 
 - (void)addMouseMotionX:(CGFloat)deltaX y:(CGFloat)deltaY {
 	auto mouse_machine = _machine->mouse_machine();
 	if(mouse_machine) {
-		@synchronized(self) {
+		[self applyInputEvent:^{
 			mouse_machine->get_mouse().move(int(deltaX), int(deltaY));
-		}
+		}];
 	}
 }
 
@@ -773,6 +787,14 @@ struct ActivityObserver: public Activity::Observer {
 		CGSize pixelSize;
 		BOOL splitAndSync = NO;
 		@synchronized(self) {
+			// Post on input events.
+			@synchronized(self->_inputEvents) {
+				for(dispatch_block_t action: self->_inputEvents) {
+					action();
+				}
+				[self->_inputEvents removeAllObjects];
+			}
+
 			// If this tick includes vsync then inspect the machine.
 			if(timeNow >= self->_syncTime && lastTime < self->_syncTime) {
 				splitAndSync = self->_isSyncLocking = self->_scanSynchroniser.can_synchronise(self->_machine->scan_producer()->get_scan_status(), self->_refreshPeriod);

From 645c29f85333894adaf2190156951e583d83ad0f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 15 Aug 2020 21:24:10 -0400
Subject: [PATCH 040/131] Adds an intermediate buffer to correct inter-frame
 smoothing.

Also goes someway back to the old scan output scheduling, albeit presently with limited thread safety.
---
 .../Clock Signal.xcodeproj/project.pbxproj    |   2 +
 .../Documents/MachineDocument.swift           |   7 +-
 .../Mac/Clock Signal/Machine/CSMachine.h      |   3 -
 .../Mac/Clock Signal/Machine/CSMachine.mm     |  22 +---
 .../Clock Signal/ScanTarget/CSScanTarget.h    |   4 +
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 120 ++++++++++++++----
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  32 ++++-
 .../Mac/Clock Signal/Views/CSScanTargetView.h |   8 +-
 .../Mac/Clock Signal/Views/CSScanTargetView.m |  43 ++-----
 9 files changed, 150 insertions(+), 91 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index fcc791b6c..deeab7a7a 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -5259,6 +5259,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				INFOPLIST_FILE = "Clock Signal/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
+				MTL_TREAT_WARNINGS_AS_ERRORS = YES;
 				OTHER_CPLUSPLUSFLAGS = (
 					"$(OTHER_CFLAGS)",
 					"-Wreorder",
@@ -5306,6 +5307,7 @@
 				GCC_WARN_UNUSED_LABEL = YES;
 				INFOPLIST_FILE = "Clock Signal/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks";
+				MTL_TREAT_WARNINGS_AS_ERRORS = YES;
 				OTHER_CPLUSPLUSFLAGS = (
 					"$(OTHER_CFLAGS)",
 					"-Wreorder",
diff --git a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift
index 480d3c1c6..643e57d32 100644
--- a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
+++ b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
@@ -609,13 +609,10 @@ class MachineDocument:
 		let url = pictursURL.appendingPathComponent(filename)
 
 		// Obtain the machine's current display.
-		var imageRepresentation: NSBitmapImageRep? = nil
-		self.scanTargetView.perform {
-			imageRepresentation = self.machine.imageRepresentation
-		}
+		let imageRepresentation = self.machine.imageRepresentation
 
 		// Encode as a PNG and save.
-		let pngData = imageRepresentation!.representation(using: .png, properties: [:])
+		let pngData = imageRepresentation.representation(using: .png, properties: [:])
 		try! pngData?.write(to: url)
 	}
 
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.h b/OSBindings/Mac/Clock Signal/Machine/CSMachine.h
index 09cd4b295..eea2c1f01 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.h	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.h	
@@ -67,9 +67,6 @@ typedef NS_ENUM(NSInteger, CSMachineKeyboardInputMode) {
 - (void)start;
 - (void)stop;
 
-- (void)updateViewForPixelSize:(CGSize)pixelSize;
-- (void)drawViewForPixelSize:(CGSize)pixelSize;
-
 - (void)setKey:(uint16_t)key characters:(nullable NSString *)characters isPressed:(BOOL)isPressed;
 - (void)clearAllKeys;
 
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index aa783e070..a93328811 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -358,19 +358,6 @@ struct ActivityObserver: public Activity::Observer {
 	_machine->scan_producer()->set_scan_target(_view.scanTarget.scanTarget);
 }
 
-- (void)updateViewForPixelSize:(CGSize)pixelSize {
-//	_pixelSize = pixelSize;
-
-//	@synchronized(self) {
-//		const auto scan_status = _machine->crt_machine()->get_scan_status();
-//		NSLog(@"FPS (hopefully): %0.2f [retrace: %0.4f]", 1.0f / scan_status.field_duration, scan_status.retrace_duration);
-//	}
-}
-
-- (void)drawViewForPixelSize:(CGSize)pixelSize {
-//	_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
-}
-
 - (void)paste:(NSString *)paste {
 	auto keyboardMachine = _machine->keyboard_machine();
 	if(keyboardMachine)
@@ -831,13 +818,14 @@ struct ActivityObserver: public Activity::Observer {
 		}
 		if(!wasUpdating) {
 			dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
-				[self.view performWithGLContext:^{
+				[self.view updateBacking];
+//				[self.view performWithGLContext:^{
 //					self->_scanTarget->update((int)pixelSize.width, (int)pixelSize.height);
 
-					if(splitAndSync) {
+//					if(splitAndSync) {
 //						self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
-					}
-				} flushDrawable:splitAndSync];
+//					}
+//				} flushDrawable:splitAndSync];
 				self->_isUpdating.clear();
 			});
 		}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h
index 93f9fb62c..e3f021ea3 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
@@ -16,4 +16,8 @@
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view;
 
+// Draws all scans currently residing at the scan target to the backing store,
+// ready for output when next requested.
+- (void)updateFrameBuffer;
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index cfb9dbc2f..9ec8b0ce8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -42,7 +42,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	id<MTLFunction> _vertexShader;
 	id<MTLFunction> _fragmentShader;
+
 	id<MTLRenderPipelineState> _scanPipeline;
+	id<MTLRenderPipelineState> _copyPipeline;
 
 	// Buffers.
 	id<MTLBuffer> _uniformsBuffer;
@@ -56,10 +58,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	size_t _bytesPerInputPixel;
 	size_t _totalTextureBytes;
 
+	id<MTLTexture> _frameBuffer;
+	MTLRenderPassDescriptor *_frameBufferRenderPass;
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
 	std::atomic_bool _isDrawing;
+
+	// The output view's aspect ratio.
+	__weak MTKView *_view;
 }
 
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
@@ -89,6 +97,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
 
 		// Set initial aspect-ratio multiplier.
+		_view = view;
 		[self mtkView:view drawableSizeWillChange:view.drawableSize];
 	}
 
@@ -103,17 +112,41 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @param size New drawable size in pixels
  */
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
-	uniforms()->aspectRatioMultiplier = float(_scanTarget.modals().aspect_ratio / (size.width / size.height));
+	[self setAspectRatio];
+
+	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
+	// in order to maintain an ongoing buffer that supersamples only at the end.
+
+	// TODO: attach a stencil buffer.
+
+	// Generate a framebuffer and a pipeline that targets it.
+	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:view.colorPixelFormat
+		width:NSUInteger(size.width * view.layer.contentsScale)
+		height:NSUInteger(size.height * view.layer.contentsScale)
+		mipmapped:NO];
+	textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+	textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+	_frameBuffer = [view.device newTextureWithDescriptor:textureDescriptor];
+
+	_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
+	_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
+	_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
+	_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 }
 
-- (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals view:(nonnull MTKView *)view {
+- (void)setAspectRatio {
+	uniforms()->aspectRatioMultiplier = float(_scanTarget.modals().aspect_ratio / (_view.bounds.size.width / _view.bounds.size.height));
+}
+
+- (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals {
 	//
 	// Populate uniforms.
 	//
 	uniforms()->scale[0] = modals.output_scale.x;
 	uniforms()->scale[1] = modals.output_scale.y;
-	uniforms()->lineWidth = 0.75f / modals.expected_vertical_lines;	// TODO: return to 1.0 (or slightly more), once happy.
-	uniforms()->aspectRatioMultiplier = float(modals.aspect_ratio / (view.bounds.size.width / view.bounds.size.height));
+	uniforms()->lineWidth = 1.05f / modals.expected_vertical_lines;	// TODO: return to 1.0 (or slightly more), once happy.
+	[self setAspectRatio];
 
 	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
 	uniforms()->toRGB = simd::float3x3(
@@ -172,11 +205,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 
 	//
-	// Generate pipeline.
+	// Generate scan pipeline.
 	//
-	id<MTLLibrary> library = [view.device newDefaultLibrary];
+	id<MTLLibrary> library = [_view.device newDefaultLibrary];
 	MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-	pipelineDescriptor.colorAttachments[0].pixelFormat = view.colorPixelFormat;
+	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
 
 	// TODO: logic somewhat more complicated than this, probably
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToDisplay"];
@@ -214,30 +247,40 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorSourceAlpha;
 	pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
 
-	_scanPipeline = [view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+	_scanPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+
+
+	//
+	// Generate copy pipeline.
+	//
+	pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
+	pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"copyVertex"];
+	pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
+	_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 }
 
-/*!
- @method drawInMTKView:
- @abstract Called on the delegate when it is asked to render into the view
- @discussion Called on the delegate when it is asked to render into the view
- */
-- (void)drawInMTKView:(nonnull MTKView *)view {
-	const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
-	if(newModals) {
-		[self setModals:*newModals view:view];
-	}
+- (void)checkModals {
+	// TODO: rethink BufferingScanTarget::perform. Is it now really just for guarding the modals?
+	_scanTarget.perform([=] {
+		const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
+		if(newModals) {
+			[self setModals:*newModals];
+		}
+	});
+}
 
-	// Buy into framebuffer preservation.
-	// TODO: do I really need to do this on every draw?
-	MTLRenderPassDescriptor *const descriptor = view.currentRenderPassDescriptor;
-	descriptor.colorAttachments[0].loadAction = MTLLoadActionLoad;
-	descriptor.colorAttachments[0].storeAction = MTLStoreActionStore;
-	descriptor.colorAttachments[0].clearColor = MTLClearColorMake(1.0, 1.0, 0.0, 1.0);
+//- (void)updateFrameBuffer {
+//}
+
+- (void)updateFrameBuffer {
+	[self checkModals];
+	if(!_frameBufferRenderPass) return;
 
 	// Generate a command encoder for the view.
-	id <MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-	id <MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:descriptor];
+	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
 
 	// Drawing. Just scans.
 	[encoder setRenderPipelineState:_scanPipeline];
@@ -284,7 +327,30 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		self->_scanTarget.complete_output_area(outputArea);
 	}];
 
-	// Register the drawable's presentation, finalise and commit.
+	// Commit the drawing.
+	[commandBuffer commit];
+}
+
+/*!
+ @method drawInMTKView:
+ @abstract Called on the delegate when it is asked to render into the view
+ @discussion Called on the delegate when it is asked to render into the view
+ */
+- (void)drawInMTKView:(nonnull MTKView *)view {
+	[self checkModals];
+//	[self updateFrameBuffer];
+
+	// Schedule a copy from the current framebuffer to the view; blitting is unavailable as the target is a framebuffer texture.
+	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:view.currentRenderPassDescriptor];
+
+	[encoder setRenderPipelineState:_copyPipeline];
+	[encoder setVertexTexture:_frameBuffer atIndex:0];
+	[encoder setFragmentTexture:_frameBuffer atIndex:0];
+
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+	[encoder endEncoding];
+
 	[commandBuffer presentDrawable:view.currentDrawable];
 	[commandBuffer commit];
 }
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 944222e87..5c0081e3f 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -55,7 +55,6 @@ struct Line {
 
 // MARK: - Intermediate structs.
 
-// This is an intermediate struct, which is TEMPORARY.
 struct SourceInterpolator {
 	float4 position [[position]];
 	float2 textureCoordinates;
@@ -201,3 +200,34 @@ DeclareShaders(Red8Green8Blue8, float)
 DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
 DeclareShaders(Red1Green1Blue1, ushort)
+
+// MARK: - Shaders for copying from a same-sized texture to an MTKView's frame buffer.
+
+struct CopyInterpolator {
+	float4 position [[position]];
+	float2 textureCoordinates;
+};
+
+vertex CopyInterpolator copyVertex(uint vertexID [[vertex_id]], texture2d<float> texture [[texture(0)]]) {
+	CopyInterpolator vert;
+
+	const uint x = vertexID & 1;
+	const uint y = (vertexID >> 1) & 1;
+
+	vert.textureCoordinates = float2(
+		x * texture.get_width(),
+		y * texture.get_height()
+	);
+	vert.position = float4(
+		float(x) * 2.0 - 1.0,
+		1.0 - float(y) * 2.0,
+		0.0,
+		1.0
+	);
+
+	return vert;
+}
+
+fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return texture.sample(standardSampler, vert.textureCoordinates);
+}
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
index 57e51b62f..a8d3f4ac3 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
@@ -168,12 +168,8 @@ typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 /// The size in pixels of the OpenGL canvas, factoring in screen pixel density and view size in points.
 @property (nonatomic, readonly) CGSize backingSize;
 
-/*!
-	Locks this view's OpenGL context and makes it current, performs @c action and then unlocks
-	the context. @c action is performed on the calling queue.
-*/
-- (void)performWithGLContext:(nonnull dispatch_block_t)action flushDrawable:(BOOL)flushDrawable;
-- (void)performWithGLContext:(nonnull dispatch_block_t)action;
+- (void)updateBacking;
+//- (void)performWithGLContext:(nonnull dispatch_block_t)action;
 
 /*!
 	Instructs that the mouse cursor, if currently captured, should be released.
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index 8989fed90..4048b2745 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -119,20 +119,20 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	}
 }
 
-- (void)drawAtTime:(const CVTimeStamp *)now frequency:(double)frequency {
-	[self redrawWithEvent:CSScanTargetViewRedrawEventTimer];
-}
+//- (void)drawAtTime:(const CVTimeStamp *)now frequency:(double)frequency {
+//	[self redrawWithEvent:CSScanTargetViewRedrawEventTimer];
+//}
 
 //- (void)drawRect:(NSRect)dirtyRect {
 //	[self redrawWithEvent:CSScanTargetViewRedrawEventAppKit];
 //	NSLog(@"...");
 //}
 
-- (void)redrawWithEvent:(CSScanTargetViewRedrawEvent)event  {
-	[self performWithGLContext:^{
-//		[self.delegate openGLViewRedraw:self event:event];
-	} flushDrawable:YES];
-}
+//- (void)redrawWithEvent:(CSScanTargetViewRedrawEvent)event  {
+//	[self performWithGLContext:^{
+////		[self.delegate openGLViewRedraw:self event:event];
+//	} flushDrawable:YES];
+//}
 
 - (void)invalidate {
 	_isInvalid = YES;
@@ -174,17 +174,9 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	}
 }
 
-//- (void)reshape {
-//	[super reshape];
-//	@synchronized(self) {
-//		_backingSize = [self convertSizeToBacking:self.bounds.size];
-//	}
-//
-//	[self performWithGLContext:^{
-//		CGSize viewSize = [self backingSize];
-//		glViewport(0, 0, (GLsizei)viewSize.width, (GLsizei)viewSize.height);
-//	} flushDrawable:NO];
-//}
+- (void)updateBacking {
+	[_scanTarget updateFrameBuffer];
+}
 
 - (void)awakeFromNib {
 	// Use the preferred device if available.
@@ -202,19 +194,6 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	[self registerForDraggedTypes:@[(__bridge NSString *)kUTTypeFileURL]];
 }
 
-- (void)performWithGLContext:(dispatch_block_t)action flushDrawable:(BOOL)flushDrawable {
-//	CGLLockContext([[self openGLContext] CGLContextObj]);
-//	[self.openGLContext makeCurrentContext];
-//	action();
-//	CGLUnlockContext([[self openGLContext] CGLContextObj]);
-//
-//	if(flushDrawable) CGLFlushDrawable([[self openGLContext] CGLContextObj]);
-}
-
-- (void)performWithGLContext:(nonnull dispatch_block_t)action {
-//	[self performWithGLContext:action flushDrawable:NO];
-}
-
 #pragma mark - NSResponder
 
 - (BOOL)acceptsFirstResponder {

From 512c0079a91e642b76a0e67155e2548d4b1f2016 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 15 Aug 2020 21:52:55 -0400
Subject: [PATCH 041/131] Makes thread safe.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 144 +++++++++---------
 1 file changed, 70 insertions(+), 74 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9ec8b0ce8..f6c14ed1d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -99,6 +99,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Set initial aspect-ratio multiplier.
 		_view = view;
 		[self mtkView:view drawableSizeWillChange:view.drawableSize];
+
+		// Generate copy pipeline.
+		id<MTLLibrary> library = [_view.device newDefaultLibrary];
+		MTLRenderPipelineDescriptor *const pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+		pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"copyVertex"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
+		_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 	}
 
 	return self;
@@ -119,20 +127,22 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// TODO: attach a stencil buffer.
 
-	// Generate a framebuffer and a pipeline that targets it.
-	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-		texture2DDescriptorWithPixelFormat:view.colorPixelFormat
-		width:NSUInteger(size.width * view.layer.contentsScale)
-		height:NSUInteger(size.height * view.layer.contentsScale)
-		mipmapped:NO];
-	textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
-	textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
-	_frameBuffer = [view.device newTextureWithDescriptor:textureDescriptor];
+	@synchronized(self) {
+		// Generate a framebuffer and a pipeline that targets it.
+		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+			texture2DDescriptorWithPixelFormat:view.colorPixelFormat
+			width:NSUInteger(size.width * view.layer.contentsScale)
+			height:NSUInteger(size.height * view.layer.contentsScale)
+			mipmapped:NO];
+		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+		_frameBuffer = [view.device newTextureWithDescriptor:textureDescriptor];
 
-	_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
-	_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
-	_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
-	_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+		_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
+		_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
+		_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
+		_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+	}
 }
 
 - (void)setAspectRatio {
@@ -248,17 +258,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
 
 	_scanPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
-
-
-
-	//
-	// Generate copy pipeline.
-	//
-	pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
-	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
-	pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"copyVertex"];
-	pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
-	_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 }
 
 - (void)checkModals {
@@ -271,64 +270,64 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	});
 }
 
-//- (void)updateFrameBuffer {
-//}
-
 - (void)updateFrameBuffer {
 	[self checkModals];
-	if(!_frameBufferRenderPass) return;
 
-	// Generate a command encoder for the view.
-	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
+	@synchronized(self) {
+		if(!_frameBufferRenderPass) return;
 
-	// Drawing. Just scans.
-	[encoder setRenderPipelineState:_scanPipeline];
+		// Generate a command encoder for the view.
+		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+		id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
 
-	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
-	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
-	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
-	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
+		// Drawing. Just scans.
+		[encoder setRenderPipelineState:_scanPipeline];
 
-	const auto outputArea = _scanTarget.get_output_area();
+		[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
+		[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+		[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+		[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
 
-	// Ensure texture changes are noted.
-	const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
-	const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
-	if(writeAreaModificationStart != writeAreaModificationEnd) {
-		if(writeAreaModificationStart < writeAreaModificationEnd) {
-			[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
-		} else {
-			[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
-			if(writeAreaModificationEnd) {
-				[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
+		const auto outputArea = _scanTarget.get_output_area();
+
+		// Ensure texture changes are noted.
+		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
+		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
+		if(writeAreaModificationStart != writeAreaModificationEnd) {
+			if(writeAreaModificationStart < writeAreaModificationEnd) {
+				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
+			} else {
+				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
+				if(writeAreaModificationEnd) {
+					[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
+				}
+			}
+
+		}
+
+		// TEMPORARY: just draw the scans.
+		if(outputArea.start.scan != outputArea.end.scan) {
+			if(outputArea.start.scan < outputArea.end.scan) {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
+			} else {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
+				if(outputArea.end.scan) {
+					[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
+				}
 			}
 		}
 
+		// Complete encoding.
+		[encoder endEncoding];
+
+		// Add a callback to update the buffer.
+		[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+			self->_scanTarget.complete_output_area(outputArea);
+		}];
+
+		// Commit the drawing.
+		[commandBuffer commit];
 	}
-
-	// TEMPORARY: just draw the scans.
-	if(outputArea.start.scan != outputArea.end.scan) {
-		if(outputArea.start.scan < outputArea.end.scan) {
-			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
-		} else {
-			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
-			if(outputArea.end.scan) {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
-			}
-		}
-	}
-
-	// Complete encoding.
-	[encoder endEncoding];
-
-	// Add a callback to update the buffer.
-	[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
-		self->_scanTarget.complete_output_area(outputArea);
-	}];
-
-	// Commit the drawing.
-	[commandBuffer commit];
 }
 
 /*!
@@ -337,9 +336,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @discussion Called on the delegate when it is asked to render into the view
  */
 - (void)drawInMTKView:(nonnull MTKView *)view {
-	[self checkModals];
-//	[self updateFrameBuffer];
-
 	// Schedule a copy from the current framebuffer to the view; blitting is unavailable as the target is a framebuffer texture.
 	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:view.currentRenderPassDescriptor];

From 940e9e037e3e7fc44c66e626326a2cc772c93d96 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 16 Aug 2020 08:59:37 -0400
Subject: [PATCH 042/131] Adds `first_scan` to LineMetadata.

Also reorders `Line` fields to match `Scan` fields, just for visual consistency.
---
 .../Clock Signal.xcodeproj/project.pbxproj    |  1 +
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  2 ++
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  4 ++--
 Outputs/ScanTargets/BufferingScanTarget.cpp   | 20 ++++++++++++-------
 Outputs/ScanTargets/BufferingScanTarget.hpp   |  8 +++++---
 5 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj
index deeab7a7a..c4c11eb2c 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/project.pbxproj	
@@ -5113,6 +5113,7 @@
 				);
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_OPTIMIZATION_LEVEL = 2;
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
 				MACOSX_DEPLOYMENT_TARGET = 10.10;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 			};
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index f6c14ed1d..b95aab15c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -142,6 +142,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
 		_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
 		_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+
+		// TODO: old framebuffer should be resized onto the new one.
 	}
 }
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 5c0081e3f..1fb85a801 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -45,12 +45,12 @@ struct Scan {
 struct Line {
 	struct EndPoint {
 		uint16_t position[2];
-		uint16_t cyclesSinceRetrace;
 		uint16_t compositeAngle;
+		uint16_t cyclesSinceRetrace;
 	} endPoints[2];
 
-	uint16_t line;
 	uint8_t compositeAmplitude;
+	uint16_t line;
 };
 
 // MARK: - Intermediate structs.
diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index b89fcdbdf..cc8b0ecf9 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -131,19 +131,19 @@ Outputs::Display::ScanTarget::Scan *BufferingScanTarget::begin_scan() {
 		return nullptr;
 	}
 
-	const auto result = &scan_buffer_[write_pointers_.scan_buffer];
+	const auto result = &scan_buffer_[write_pointers_.scan];
 	const auto read_pointers = read_pointers_.load(std::memory_order::memory_order_relaxed);
 
 	// Advance the pointer.
-	const auto next_write_pointer = decltype(write_pointers_.scan_buffer)((write_pointers_.scan_buffer + 1) % scan_buffer_size_);
+	const auto next_write_pointer = decltype(write_pointers_.scan)((write_pointers_.scan + 1) % scan_buffer_size_);
 
 	// Check whether that's too many.
-	if(next_write_pointer == read_pointers.scan_buffer) {
+	if(next_write_pointer == read_pointers.scan) {
 		allocation_has_failed_ = true;
 		vended_scan_ = nullptr;
 		return nullptr;
 	}
-	write_pointers_.scan_buffer = next_write_pointer;
+	write_pointers_.scan = next_write_pointer;
 	++provided_scans_;
 
 	// Fill in extra OpenGL-specific details.
@@ -211,12 +211,18 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 	} else {
 		// Commit the most recent line only if any scans fell on it and all allocation was successful.
 		if(!allocation_has_failed_ && provided_scans_) {
+			const auto submit_pointers = submit_pointers_.load(std::memory_order::memory_order_relaxed);
+
 			// Store metadata.
 			LineMetadata &metadata = line_metadata_buffer_[size_t(write_pointers_.line)];
 			metadata.is_first_in_frame = is_first_in_frame_;
 			metadata.previous_frame_was_complete = previous_frame_was_complete_;
+			metadata.first_scan = submit_pointers.scan;
 			is_first_in_frame_ = false;
 
+			// Sanity check.
+			assert(((metadata.first_scan + provided_scans_) % scan_buffer_size_) == write_pointers_.scan);
+
 			// Store actual line data.
 			Line &active_line = line_buffer_[size_t(write_pointers_.line)];
 			active_line.end_points[1].x = location.x;
@@ -296,8 +302,8 @@ BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 	area.start.line = read_ahead_pointers.line;
 	area.end.line = submit_pointers.line;
 
-	area.start.scan = read_ahead_pointers.scan_buffer;
-	area.end.scan = submit_pointers.scan_buffer;
+	area.start.scan = read_ahead_pointers.scan;
+	area.end.scan = submit_pointers.scan;
 
 	area.start.write_area_x = TextureAddressGetX(read_ahead_pointers.write_area);
 	area.start.write_area_y = TextureAddressGetY(read_ahead_pointers.write_area);
@@ -313,7 +319,7 @@ BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 void BufferingScanTarget::complete_output_area(const OutputArea &area) {
 	PointerSet new_read_pointers;
 	new_read_pointers.line = uint16_t(area.end.line);
-	new_read_pointers.scan_buffer = uint16_t(area.end.scan);
+	new_read_pointers.scan = uint16_t(area.end.scan);
 	new_read_pointers.write_area = TextureAddress(area.end.write_area_x, area.end.write_area_y);
 	read_pointers_.store(new_read_pointers, std::memory_order::memory_order_relaxed);
 }
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 07ea61da3..5c9b6f3cb 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -70,12 +70,12 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		struct Line {
 			struct EndPoint {
 				uint16_t x, y;
-				uint16_t cycles_since_end_of_horizontal_retrace;
 				int16_t composite_angle;
+				uint16_t cycles_since_end_of_horizontal_retrace;
 			} end_points[2];
 
-			uint16_t line;
 			uint8_t composite_amplitude;
+			uint16_t line;
 		};
 
 		/// Provides additional metadata about lines; this is separate because it's unlikely to be of
@@ -88,6 +88,8 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 			/// from a frame if performance problems mean that the emulated machine is running
 			/// more quickly than complete frames can be generated.
 			bool previous_frame_was_complete;
+			/// The index of the first scan that will appear on this line.
+			size_t first_scan;
 		};
 
 		/// Sets the area of memory to use as a scan buffer.
@@ -205,7 +207,7 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 			int32_t write_area = 1;
 
 			// Points into the scan buffer.
-			uint16_t scan_buffer = 0;
+			uint16_t scan = 0;
 
 			// Points into the line buffer.
 			uint16_t line = 0;

From 745797b596b2792eb80e05a0118ac1432c2730ff Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 16 Aug 2020 16:42:32 -0400
Subject: [PATCH 043/131] Introduces a stencil buffer plus the inter-frame
 clearing it allows.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 165 ++++++++++++++----
 .../Clock Signal/ScanTarget/ScanTarget.metal  |   9 +-
 Outputs/ScanTargets/BufferingScanTarget.cpp   |   2 +-
 3 files changed, 138 insertions(+), 38 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index b95aab15c..292be240d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -45,6 +45,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	id<MTLRenderPipelineState> _scanPipeline;
 	id<MTLRenderPipelineState> _copyPipeline;
+	id<MTLRenderPipelineState> _clearPipeline;
 
 	// Buffers.
 	id<MTLBuffer> _uniformsBuffer;
@@ -61,6 +62,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLTexture> _frameBuffer;
 	MTLRenderPassDescriptor *_frameBufferRenderPass;
 
+	id<MTLTexture> _frameBufferStencil;
+	id<MTLDepthStencilState> _drawStencilState;		// Always draws, sets stencil to 1.
+	id<MTLDepthStencilState> _clearStencilState;	// Draws only where stencil is 0, clears all to 0.
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
@@ -100,13 +105,25 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_view = view;
 		[self mtkView:view drawableSizeWillChange:view.drawableSize];
 
-		// Generate copy pipeline.
+		// Generate copy and clear pipelines.
 		id<MTLLibrary> library = [_view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *const pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
 		pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"copyVertex"];
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
 		_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"clearFragment"];
+		pipelineDescriptor.stencilAttachmentPixelFormat = MTLPixelFormatStencil8;
+		_clearPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+		// Clear stencil: always write the reference value (of 0), but draw only where the stencil already
+		// had that value.
+		MTLDepthStencilDescriptor *depthStencilDescriptor = [[MTLDepthStencilDescriptor alloc] init];
+		depthStencilDescriptor.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionEqual;
+		depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
+		depthStencilDescriptor.frontFaceStencil.stencilFailureOperation = MTLStencilOperationReplace;
+		_clearStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 	}
 
 	return self;
@@ -125,10 +142,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
 	// in order to maintain an ongoing buffer that supersamples only at the end.
 
-	// TODO: attach a stencil buffer.
-
 	@synchronized(self) {
-		// Generate a framebuffer and a pipeline that targets it.
+		// Generate a framebuffer and a stencil.
 		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
 			texture2DDescriptorWithPixelFormat:view.colorPixelFormat
 			width:NSUInteger(size.width * view.layer.contentsScale)
@@ -138,11 +153,34 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
 		_frameBuffer = [view.device newTextureWithDescriptor:textureDescriptor];
 
+		MTLTextureDescriptor *const stencilTextureDescriptor = [MTLTextureDescriptor
+			texture2DDescriptorWithPixelFormat:MTLPixelFormatStencil8
+			width:NSUInteger(size.width * view.layer.contentsScale)
+			height:NSUInteger(size.height * view.layer.contentsScale)
+			mipmapped:NO];
+		stencilTextureDescriptor.usage = MTLTextureUsageRenderTarget;
+		stencilTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+		_frameBufferStencil = [view.device newTextureWithDescriptor:stencilTextureDescriptor];
+
+		// Generate a render pass with that framebuffer and stencil.
 		_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
 		_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
 		_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
 		_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 
+		_frameBufferRenderPass.stencilAttachment.clearStencil = 0;
+		_frameBufferRenderPass.stencilAttachment.texture = _frameBufferStencil;
+		_frameBufferRenderPass.stencilAttachment.loadAction = MTLLoadActionLoad;
+		_frameBufferRenderPass.stencilAttachment.storeAction = MTLStoreActionStore;
+
+		// Establish intended stencil useage; it's only to track which pixels haven't been painted
+		// at all at the end of every frame. So: always paint, and replace the stored stencil value
+		// (which is seeded as 0) with the nominated one (a 1).
+		MTLDepthStencilDescriptor *depthStencilDescriptor = [[MTLDepthStencilDescriptor alloc] init];
+		depthStencilDescriptor.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionAlways;
+		depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
+		_drawStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+
 		// TODO: old framebuffer should be resized onto the new one.
 	}
 }
@@ -259,10 +297,65 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorSourceAlpha;
 	pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
 
+	// Set stencil format.
+	pipelineDescriptor.stencilAttachmentPixelFormat = MTLPixelFormatStencil8;
+
+	// Finish.
 	_scanPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 }
 
-- (void)checkModals {
+- (void)outputScansFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
+	// Generate a command encoder for the view.
+	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
+
+	// Drawing. Just scans.
+	[encoder setRenderPipelineState:_scanPipeline];
+
+	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
+	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+	[encoder setDepthStencilState:_drawStencilState];
+	[encoder setStencilReferenceValue:1];
+#ifndef NDEBUG
+	// Quick aid for debugging: the stencil test is predicated on front-facing pixels, so make sure they're
+	// being generated.
+	[encoder setCullMode:MTLCullModeBack];
+#endif
+
+	if(start != end) {
+		if(start < end) {
+			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end - start baseInstance:start];
+		} else {
+			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - start baseInstance:start];
+			if(end) {
+				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end];
+			}
+		}
+	}
+
+	// Complete encoding and return.
+	[encoder endEncoding];
+}
+
+- (void)outputFrameCleanerToCommandBuffer:(id<MTLCommandBuffer>)commandBuffer {
+	// Generate a command encoder for the view.
+	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
+
+	// Drawing. Just scans.
+	[encoder setRenderPipelineState:_clearPipeline];
+	[encoder setDepthStencilState:_clearStencilState];
+	[encoder setStencilReferenceValue:0];
+
+	[encoder setVertexTexture:_frameBuffer atIndex:0];
+	[encoder setFragmentTexture:_frameBuffer atIndex:0];
+
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+	[encoder endEncoding];
+}
+
+- (void)updateFrameBuffer {
 	// TODO: rethink BufferingScanTarget::perform. Is it now really just for guarding the modals?
 	_scanTarget.perform([=] {
 		const Outputs::Display::ScanTarget::Modals *const newModals = _scanTarget.new_modals();
@@ -270,26 +363,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			[self setModals:*newModals];
 		}
 	});
-}
-
-- (void)updateFrameBuffer {
-	[self checkModals];
 
 	@synchronized(self) {
 		if(!_frameBufferRenderPass) return;
 
-		// Generate a command encoder for the view.
-		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-		id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
-
-		// Drawing. Just scans.
-		[encoder setRenderPipelineState:_scanPipeline];
-
-		[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
-		[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
-		[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
-		[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
-
 		const auto outputArea = _scanTarget.get_output_area();
 
 		// Ensure texture changes are noted.
@@ -307,27 +384,43 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		}
 
-		// TEMPORARY: just draw the scans.
-		if(outputArea.start.scan != outputArea.end.scan) {
-			if(outputArea.start.scan < outputArea.end.scan) {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan - outputArea.start.scan baseInstance:outputArea.start.scan];
-			} else {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - outputArea.start.scan baseInstance:outputArea.start.scan];
-				if(outputArea.end.scan) {
-					[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:outputArea.end.scan];
-				}
+		// Obtain a source for render command encoders.
+		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+
+		//
+		// Drawing algorithm used below, in broad terms:
+		//
+		// Maintain a persistent buffer of current CRT state.
+		//
+		// During each frame, paint to the persistent buffer anything new. Update a stencil buffer to track
+		// every pixel so-far touched.
+		//
+		// At the end of the frame, draw a 'frame cleaner', which is a whole-screen rect that paints over
+		// only those areas that the stencil buffer indicates weren't painted this frame.
+		//
+		// Hence every pixel is touched every frame, regardless of the machine's output.
+		//
+
+		// TODO: proceed as per the below inly if doing a scan-centric output.
+		// Draw scans to a composition buffer and from there to the display as lines otherwise.
+
+		// Break up scans by frame.
+		size_t line = outputArea.start.line;
+		size_t scan = outputArea.start.scan;
+		while(line != outputArea.end.line) {
+			if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+				[self outputScansFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
+				[self outputFrameCleanerToCommandBuffer:commandBuffer];
+				scan = _lineMetadataBuffer[line].first_scan;
 			}
+			line = (line + 1) % NumBufferedLines;
 		}
+		[self outputScansFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
 
-		// Complete encoding.
-		[encoder endEncoding];
-
-		// Add a callback to update the buffer.
+		// Add a callback to update the scan target buffer and commit the drawing.
 		[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
 			self->_scanTarget.complete_output_area(outputArea);
 		}];
-
-		// Commit the drawing.
 		[commandBuffer commit];
 	}
 }
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 1fb85a801..fa780d6c2 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -9,6 +9,9 @@
 #include <metal_stdlib>
 using namespace metal;
 
+// TODO: I'm being very loose, so far, in use of alpha. Sometimes it's 0.64, somtimes its 1.0.
+// Apply some rigour, for crying out loud.
+
 struct Uniforms {
 	// This is used to scale scan positions, i.e. it provides the range
 	// for mapping from scan-style integer positions into eye space.
@@ -83,7 +86,7 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 
 	// Calculate the tangent and normal.
 	const float2 tangent = (end - start);
-	const float2 normal = float2(-tangent.y, tangent.x) / length(tangent);
+	const float2 normal = float2(tangent.y, -tangent.x) / length(tangent);
 
 	// Load up the colour details.
 	output.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
@@ -231,3 +234,7 @@ vertex CopyInterpolator copyVertex(uint vertexID [[vertex_id]], texture2d<float>
 fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }
+
+fragment float4 clearFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return float4(0.0, 0.0, 0.0, 0.64);
+}
diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index cc8b0ecf9..684b1611b 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -221,7 +221,7 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 			is_first_in_frame_ = false;
 
 			// Sanity check.
-			assert(((metadata.first_scan + provided_scans_) % scan_buffer_size_) == write_pointers_.scan);
+			assert(((metadata.first_scan + size_t(provided_scans_)) % scan_buffer_size_) == write_pointers_.scan);
 
 			// Store actual line data.
 			Line &active_line = line_buffer_[size_t(write_pointers_.line)];

From 27e8a3a1b5cfb308d229224d528ebe60c31549b2 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 16 Aug 2020 21:11:43 -0400
Subject: [PATCH 044/131] Obeys modals' zoom.

Subject to an attempt at factoring aspect ratio differences.
---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 17 ++++++++++++++++-
 .../Clock Signal/ScanTarget/ScanTarget.metal    |  9 ++++++++-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 292be240d..31f82e7aa 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -20,6 +20,8 @@ struct Uniforms {
 	float aspectRatioMultiplier;
 	simd::float3x3 toRGB;
 	simd::float3x3 fromRGB;
+	float zoom;
+	simd::float2 offset;
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -186,7 +188,20 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (void)setAspectRatio {
-	uniforms()->aspectRatioMultiplier = float(_scanTarget.modals().aspect_ratio / (_view.bounds.size.width / _view.bounds.size.height));
+	const auto modals = _scanTarget.modals();
+	const auto viewAspectRatio = (_view.bounds.size.width / _view.bounds.size.height);
+
+	// Set the aspect ratio multiplier.
+	uniforms()->aspectRatioMultiplier = float(modals.aspect_ratio / viewAspectRatio);
+
+	// Also work out the proper zoom. Somehow?
+	const double fitWidthZoom = (viewAspectRatio / modals.aspect_ratio) / modals.visible_area.size.width;
+	const double fitHeightZoom = 1.0 / modals.visible_area.size.height;
+
+	// The differing signs for offset below reflect the inverted coordinate system in Metal.
+	uniforms()->zoom = float(std::min(fitWidthZoom, fitHeightZoom));
+	uniforms()->offset.x = -modals.visible_area.origin.x;
+	uniforms()->offset.y = -modals.visible_area.origin.y;
 }
 
 - (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals {
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index fa780d6c2..32faf8b6c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -26,6 +26,10 @@ struct Uniforms {
 	// Provides conversions to and from RGB for the active colour space.
 	float3x3 toRGB;
 	float3x3 fromRGB;
+
+	// Provides zoom and offset to scale the source data.
+	float zoom;
+	float2 offset;
 };
 
 // MARK: - Structs used for receiving data from the emulation.
@@ -97,8 +101,11 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 	) / 32.0;
 
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
+	float2 position2d = start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth;
+	position2d = (position2d + uniforms.offset) * uniforms.zoom  * float2(uniforms.aspectRatioMultiplier, 1.0);
+	position2d = position2d * float2(2.0, -2.0) + float2(-1.0, 1.0);
 	output.position = float4(
-		((start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth) * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0),
+		position2d,
 		0.0,
 		1.0
 	);

From 246b474a2521fca255dd860688938dba2578d6fe Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 16 Aug 2020 22:09:25 -0400
Subject: [PATCH 045/131] Removes ONE_BIG_LOCK, having effectively neutered it
 anyway.

Starts work on more explicit API usage validation. Maybe the issue isn't a race condition?
---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 33 ++++++++++-----------
 Outputs/ScanTargets/BufferingScanTarget.hpp |  5 ++++
 2 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 684b1611b..5c8d688e2 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -11,12 +11,6 @@
 #include <cassert>
 #include <cstring>
 
-// If enabled, this uses the producer lock to cover both production and consumption
-// rather than attempting to proceed lockfree. This is primarily for diagnostic purposes;
-// it allows empirical exploration of whether the logical and memory barriers that are
-// meant to mediate things between the read pointers and the submit pointers are functioning.
-#define ONE_BIG_LOCK
-
 #define TextureAddressGetY(v)	uint16_t((v) >> 11)
 #define TextureAddressGetX(v)	uint16_t((v) & 0x7ff)
 #define TextureSub(a, b)		(((a) - (b)) & 0x3fffff)
@@ -79,6 +73,7 @@ uint8_t *BufferingScanTarget::begin_data(size_t required_length, size_t required
 	}
 
 	// Everything checks out, note expectation of a future end_data and return the pointer.
+	assert(!data_is_allocated_);
 	data_is_allocated_ = true;
 	vended_write_area_pointer_ = write_pointers_.write_area = TextureAddress(aligned_start_x, output_y);
 
@@ -150,12 +145,23 @@ Outputs::Display::ScanTarget::Scan *BufferingScanTarget::begin_scan() {
 	result->line = write_pointers_.line;
 
 	vended_scan_ = result;
+
+#ifndef NDEBUG
+	assert(!scan_is_ongoing_);
+	scan_is_ongoing_ = true;
+#endif
+
 	return &result->scan;
 }
 
 void BufferingScanTarget::end_scan() {
 	std::lock_guard lock_guard(producer_mutex_);
 
+#ifndef NDEBUG
+	assert(scan_is_ongoing_);
+	scan_is_ongoing_ = false;
+#endif
+
 	// Complete the scan only if one is afoot.
 	if(vended_scan_) {
 		vended_scan_->data_y = TextureAddressGetY(vended_write_area_pointer_);
@@ -188,6 +194,10 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 	if(output_is_visible_ == is_visible) return;
 	output_is_visible_ = is_visible;
 
+#ifndef NDEBUG
+	assert(!scan_is_ongoing_);
+#endif
+
 	if(is_visible) {
 		const auto read_pointers = read_pointers_.load(std::memory_order::memory_order_relaxed);
 
@@ -261,14 +271,7 @@ const Outputs::Display::Metrics &BufferingScanTarget::display_metrics() {
 }
 
 void BufferingScanTarget::set_write_area(uint8_t *base) {
-	// This is a bit of a hack. This call needs the producer mutex and should be
-	// safe to call from a @c perform block in order to support all potential consumers.
-	// But the temporary hack of ONE_BIG_LOCK then implies that either I need a recursive
-	// mutex, or I have to make a coupling assumption about my caller. I've done the latter,
-	// because ONE_BIG_LOCK is really really meant to be temporary. I hope.
-#ifndef ONE_BIG_LOCK
 	std::lock_guard lock_guard(producer_mutex_);
-#endif
 	write_area_ = base;
 	write_pointers_ = submit_pointers_ = read_pointers_ = PointerSet();
 	allocation_has_failed_ = true;
@@ -325,10 +328,6 @@ void BufferingScanTarget::complete_output_area(const OutputArea &area) {
 }
 
 void BufferingScanTarget::perform(const std::function<void(void)> &function) {
-#ifdef ONE_BIG_LOCK
-	std::lock_guard lock_guard(producer_mutex_);
-#endif
-
 	while(is_updating_.test_and_set(std::memory_order_acquire));
 	function();
 	is_updating_.clear(std::memory_order_release);
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index 5c9b6f3cb..a0ceb8bf2 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -250,6 +250,11 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		// from a call to @c get_new_modals.
 		Modals modals_;
 		bool modals_are_dirty_ = false;
+
+#ifndef NDEBUG
+		// Debug features; these amount to API validate.
+		bool scan_is_ongoing_ = false;
+#endif
 };
 
 

From 9da79d2d8155c9fb62c274f2395850607afb5b8c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 17 Aug 2020 20:29:46 -0400
Subject: [PATCH 046/131] Clarifies scaling logic.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm       |  6 +++---
 .../Mac/Clock Signal/ScanTarget/ScanTarget.metal      | 11 +++++++++--
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 31f82e7aa..ed73e99f9 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -194,12 +194,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// Set the aspect ratio multiplier.
 	uniforms()->aspectRatioMultiplier = float(modals.aspect_ratio / viewAspectRatio);
 
-	// Also work out the proper zoom. Somehow?
+	// Also work out the proper zoom.
 	const double fitWidthZoom = (viewAspectRatio / modals.aspect_ratio) / modals.visible_area.size.width;
 	const double fitHeightZoom = 1.0 / modals.visible_area.size.height;
-
-	// The differing signs for offset below reflect the inverted coordinate system in Metal.
 	uniforms()->zoom = float(std::min(fitWidthZoom, fitHeightZoom));
+
+	// Store the offset.
 	uniforms()->offset.x = -modals.visible_area.origin.x;
 	uniforms()->offset.y = -modals.visible_area.origin.y;
 }
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 32faf8b6c..ac11d6ffc 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -101,9 +101,16 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 	) / 32.0;
 
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
+
+	// position2d is now in the range [0, 1].
 	float2 position2d = start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth;
-	position2d = (position2d + uniforms.offset) * uniforms.zoom  * float2(uniforms.aspectRatioMultiplier, 1.0);
-	position2d = position2d * float2(2.0, -2.0) + float2(-1.0, 1.0);
+
+	// Apply the requested offset and zoom, to map the desired area to the range [0, 1].
+	position2d = (position2d + uniforms.offset) * uniforms.zoom;
+
+	// Remap from [0, 1] to Metal's [-1, 1] and then apply the aspect ratio correction.
+	position2d = (position2d * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0);
+
 	output.position = float4(
 		position2d,
 		0.0,

From 59c4c8233fc27276a0f5cc2d0a34131b1e485223 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 17 Aug 2020 21:15:19 -0400
Subject: [PATCH 047/131] Generalises existing `scanToDisplay` to add
 `lineToDisplay`.

---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 69 +++++++++++++------
 1 file changed, 48 insertions(+), 21 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index ac11d6ffc..08d3ff2e9 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -32,6 +32,14 @@ struct Uniforms {
 	float2 offset;
 };
 
+namespace {
+
+constexpr sampler standardSampler(	coord::pixel,
+									address::clamp_to_edge,	// Although arbitrary, stick with this address mode for compatibility all the way to MTLFeatureSet_iOS_GPUFamily1_v1.
+									filter::nearest);
+
+}
+
 // MARK: - Structs used for receiving data from the emulation.
 
 // This is intended to match the net effect of `Scan` as defined by the BufferingScanTarget.
@@ -70,22 +78,35 @@ struct SourceInterpolator {
 };
 
 
-// MARK: - Scan shaders; these do final output to the display.
+// MARK: - Vertex shaders.
 
-vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)]],
-											constant Scan *scans [[buffer(0)]],
-											uint instanceID [[instance_id]],
-											uint vertexID [[vertex_id]]) {
+float2 textureLocation(constant Line *line, float offset) {
+	return float2(
+		mix(line->endPoints[0].cyclesSinceRetrace, line->endPoints[1].cyclesSinceRetrace, offset),
+		line->line);
+}
+
+float2 textureLocation(constant Scan *scan, float offset) {
+	return float2(
+		mix(scan->endPoints[0].dataOffset, scan->endPoints[1].dataOffset, offset),
+		scan->dataY);
+}
+
+template <typename Input> SourceInterpolator toDisplay(
+	constant Uniforms &uniforms [[buffer(1)]],
+	constant Input *inputs [[buffer(0)]],
+	uint instanceID [[instance_id]],
+	uint vertexID [[vertex_id]]) {
 	SourceInterpolator output;
 
 	// Get start and end vertices in regular float2 form.
 	const float2 start = float2(
-		float(scans[instanceID].endPoints[0].position[0]) / float(uniforms.scale.x),
-		float(scans[instanceID].endPoints[0].position[1]) / float(uniforms.scale.y)
+		float(inputs[instanceID].endPoints[0].position[0]) / float(uniforms.scale.x),
+		float(inputs[instanceID].endPoints[0].position[1]) / float(uniforms.scale.y)
 	);
 	const float2 end = float2(
-		float(scans[instanceID].endPoints[1].position[0]) / float(uniforms.scale.x),
-		float(scans[instanceID].endPoints[1].position[1]) / float(uniforms.scale.y)
+		float(inputs[instanceID].endPoints[1].position[0]) / float(uniforms.scale.x),
+		float(inputs[instanceID].endPoints[1].position[1]) / float(uniforms.scale.y)
 	);
 
 	// Calculate the tangent and normal.
@@ -93,10 +114,10 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 	const float2 normal = float2(tangent.y, -tangent.x) / length(tangent);
 
 	// Load up the colour details.
-	output.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
+	output.colourAmplitude = float(inputs[instanceID].compositeAmplitude) / 255.0f;
 	output.colourPhase = 3.141592654f * mix(
-		float(scans[instanceID].endPoints[0].compositeAngle),
-		float(scans[instanceID].endPoints[1].compositeAngle),
+		float(inputs[instanceID].endPoints[0].compositeAngle),
+		float(inputs[instanceID].endPoints[1].compositeAngle),
 		float((vertexID&2) >> 1)
 	) / 32.0;
 
@@ -116,20 +137,26 @@ vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)
 		0.0,
 		1.0
 	);
-	output.textureCoordinates = float2(
-		mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float((vertexID&2) >> 1)),
-		scans[instanceID].dataY);
+	output.textureCoordinates = textureLocation(&inputs[instanceID], float((vertexID&2) >> 1));
+
 	return output;
 }
 
-namespace {
-
-constexpr sampler standardSampler(	coord::pixel,
-									address::clamp_to_edge,	// Although arbitrary, stick with this address mode for compatibility all the way to MTLFeatureSet_iOS_GPUFamily1_v1.
-									filter::nearest);
-
+vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)]],
+											constant Scan *scans [[buffer(0)]],
+											uint instanceID [[instance_id]],
+											uint vertexID [[vertex_id]]) {
+	return toDisplay(uniforms, scans, instanceID, vertexID);
 }
 
+vertex SourceInterpolator lineToDisplay(	constant Uniforms &uniforms [[buffer(1)]],
+											constant Line *lines [[buffer(0)]],
+											uint instanceID [[instance_id]],
+											uint vertexID [[vertex_id]]) {
+	return toDisplay(uniforms, lines, instanceID, vertexID);
+}
+
+
 // MARK: - Various input format conversion samplers.
 
 // There's only one meaningful way to sample the luminance formats.

From 11dec6fc0fe1d2e95ae63b555dff2450b57e9c99 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 17 Aug 2020 22:09:15 -0400
Subject: [PATCH 048/131] Avoids a redundant clear.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index ed73e99f9..6a049b065 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -448,6 +448,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 - (void)drawInMTKView:(nonnull MTKView *)view {
 	// Schedule a copy from the current framebuffer to the view; blitting is unavailable as the target is a framebuffer texture.
 	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+
+	// Every pixel will be drawn, so don't clear or reload.
+	view.currentRenderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:view.currentRenderPassDescriptor];
 
 	[encoder setRenderPipelineState:_copyPipeline];

From 8811506adf0829ca6c6b42d1dfef61c1897a6eb3 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 17 Aug 2020 22:10:02 -0400
Subject: [PATCH 049/131] Starts towards building a compound[/composition?]
 buffer.

I now need to discover whether I can use natural integer texture coordinates.
---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 08d3ff2e9..4d69f3bc7 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -142,6 +142,9 @@ template <typename Input> SourceInterpolator toDisplay(
 	return output;
 }
 
+// These next two assume the incoming geometry to be a four-vertex triangle strip; each instance will therefore
+// produce a quad.
+
 vertex SourceInterpolator scanToDisplay(	constant Uniforms &uniforms [[buffer(1)]],
 											constant Scan *scans [[buffer(0)]],
 											uint instanceID [[instance_id]],
@@ -156,6 +159,26 @@ vertex SourceInterpolator lineToDisplay(	constant Uniforms &uniforms [[buffer(1)
 	return toDisplay(uniforms, lines, instanceID, vertexID);
 }
 
+// This assumes that it needs to generate endpoints for a line segment.
+
+vertex SourceInterpolator scanToCompound(	constant Uniforms &uniforms [[buffer(1)]],
+											constant Scan *scans [[buffer(0)]],
+											uint instanceID [[instance_id]],
+											uint vertexID [[vertex_id]],
+											texture2d<float> texture [[texture(0)]]) {
+	SourceInterpolator result;
+
+	// Populate result as if direct texture access were available.
+	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
+	result.position.y = scans[instanceID].line;
+	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
+	result.textureCoordinates.y = scans[instanceID].dataY;
+
+	// TODO: map position into eye space, allowing for target texture dimensions.
+
+	return result;
+}
+
 
 // MARK: - Various input format conversion samplers.
 

From 3597f687de7a0d0e474af0077b7090ded897d23f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 19 Aug 2020 21:20:06 -0400
Subject: [PATCH 050/131] Continues sidling towards composite & S-Video
 handling.

---
 Machines/Apple/Macintosh/Video.cpp            |   2 +-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 186 +++++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  15 +-
 3 files changed, 145 insertions(+), 58 deletions(-)

diff --git a/Machines/Apple/Macintosh/Video.cpp b/Machines/Apple/Macintosh/Video.cpp
index 211401e36..8d1bfcdf1 100644
--- a/Machines/Apple/Macintosh/Video.cpp
+++ b/Machines/Apple/Macintosh/Video.cpp
@@ -29,7 +29,7 @@ Video::Video(DeferredAudio &audio, DriveSpeedAccumulator &drive_speed_accumulato
  	crt_(704, 1, 370, 6, Outputs::Display::InputDataType::Luminance1) {
 
  	crt_.set_display_type(Outputs::Display::DisplayType::RGB);
-	crt_.set_visible_area(Outputs::Display::Rect(0.08f, -0.025f, 0.82f, 0.82f));
+//	crt_.set_visible_area(Outputs::Display::Rect(0.08f, -0.025f, 0.82f, 0.82f));
 	crt_.set_aspect_ratio(1.73f);	// The Mac uses a non-standard scanning area.
 }
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 6a049b065..893949848 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -45,7 +45,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLFunction> _vertexShader;
 	id<MTLFunction> _fragmentShader;
 
-	id<MTLRenderPipelineState> _scanPipeline;
+	id<MTLRenderPipelineState> _composePipeline;
+	id<MTLRenderPipelineState> _outputPipeline;
 	id<MTLRenderPipelineState> _copyPipeline;
 	id<MTLRenderPipelineState> _clearPipeline;
 
@@ -64,16 +65,22 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLTexture> _frameBuffer;
 	MTLRenderPassDescriptor *_frameBufferRenderPass;
 
+	id<MTLTexture> _compositionTexture;
+
+	// The stencil buffer and the two ways it's used.
 	id<MTLTexture> _frameBufferStencil;
 	id<MTLDepthStencilState> _drawStencilState;		// Always draws, sets stencil to 1.
 	id<MTLDepthStencilState> _clearStencilState;	// Draws only where stencil is 0, clears all to 0.
 
+	// The composition pipeline, and whether it's in use.
+	BOOL _isUsingCompositionPipeline;
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
-	std::atomic_bool _isDrawing;
+	std::atomic_flag _isDrawing;
 
-	// The output view's aspect ratio.
+	// The output view.
 	__weak MTKView *_view;
 }
 
@@ -126,6 +133,19 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
 		depthStencilDescriptor.frontFaceStencil.stencilFailureOperation = MTLStencilOperationReplace;
 		_clearStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+
+		// Create a composition texture up front.
+		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+			texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+			width:2048		// This 'should do'.
+			height:NumBufferedLines
+			mipmapped:NO];
+		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+		_compositionTexture = [view.device newTextureWithDescriptor:textureDescriptor];
+
+		// Ensure the is-drawing flag is initially clear.
+		_isDrawing.clear();
 	}
 
 	return self;
@@ -274,37 +294,75 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	//
 	id<MTLLibrary> library = [_view.device newDefaultLibrary];
 	MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+
+	// Occasions when the composition buffer isn't required are slender:
+	//
+	//	(i) input and output are both RGB; or
+	//	(i) output is composite monochrome.
+	_isUsingCompositionPipeline =
+		(
+			(natural_display_type_for_data_type(modals.input_data_type) != Outputs::Display::DisplayType::RGB) ||
+			(modals.display_type != Outputs::Display::DisplayType::RGB)
+		) && modals.display_type != Outputs::Display::DisplayType::CompositeMonochrome;
+
+	struct FragmentSamplerDictionary {
+		/// Fragment shader that outputs to the composition buffer for composite processing.
+		NSString *const compositionComposite;
+		/// Fragment shader that outputs to the composition buffer for S-Video processing.
+		NSString *const compositionSVideo;
+
+		/// Fragment shader that outputs directly as monochrome composite.
+		NSString *const directComposite;
+		/// Fragment shader that outputs directly as RGB.
+		NSString *const directRGB;
+	};
+
+	// TODO: create fragment shaders to apply composite multiplication.
+	// TODO: incorporate gamma correction into all direct outputters.
+	const FragmentSamplerDictionary samplerDictionary[8] = {
+		// Luminance1
+		{@"sampleLuminance1", nullptr, @"sampleLuminance1", nullptr},
+		{@"sampleLuminance8", nullptr, @"sampleLuminance8", nullptr},
+		{@"samplePhaseLinkedLuminance8", nullptr, @"samplePhaseLinkedLuminance8", nullptr},
+		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"compositeSampleLuminance8Phase8", nullptr},
+		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"compositeSampleRed1Green1Blue1", @"sampleRed1Green1Blue1"},
+		{@"compositeSampleRed2Green2Blue2", @"svideoSampleRed2Green2Blue2", @"compositeSampleRed2Green2Blue2", @"sampleRed2Green2Blue2"},
+		{@"compositeSampleRed4Green4Blue4", @"svideoSampleRed4Green4Blue4", @"compositeSampleRed4Green4Blue4", @"sampleRed4Green4Blue4"},
+		{@"compositeSampleRed8Green8Blue8", @"svideoSampleRed8Green8Blue8", @"compositeSampleRed8Green8Blue8", @"sampleRed8Green8Blue8"},
+	};
+
+#ifndef NDEBUG
+	// Do a quick check of the names entered above. I don't think this is possible at compile time.
+	for(int c = 0; c < 8; ++c) {
+		if(samplerDictionary[c].compositionComposite)	assert([library newFunctionWithName:samplerDictionary[c].compositionComposite]);
+		if(samplerDictionary[c].compositionSVideo)		assert([library newFunctionWithName:samplerDictionary[c].compositionSVideo]);
+		if(samplerDictionary[c].directComposite)		assert([library newFunctionWithName:samplerDictionary[c].directComposite]);
+		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
+	}
+#endif
+
+	// Build the composition pipeline if one is in use.
+	if(_isUsingCompositionPipeline) {
+		const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
+
+		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
+		pipelineDescriptor.fragmentFunction =
+			[library newFunctionWithName:isSVideoOutput ? samplerDictionary[int(modals.input_data_type)].compositionSVideo : samplerDictionary[int(modals.input_data_type)].compositionComposite];
+
+		_composePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+	}
+
+	// Build the output pipeline.
 	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
+	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
-	// TODO: logic somewhat more complicated than this, probably
-	pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToDisplay"];
-	switch(modals.input_data_type) {
-		case Outputs::Display::InputDataType::Luminance1:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance1"];
-		break;
-		case Outputs::Display::InputDataType::Luminance8:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8"];
-		break;
-		case Outputs::Display::InputDataType::PhaseLinkedLuminance8:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"samplePhaseLinkedLuminance8"];
-		break;
-
-		case Outputs::Display::InputDataType::Luminance8Phase8:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleLuminance8Phase8"];
-		break;
-
-		case Outputs::Display::InputDataType::Red1Green1Blue1:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed1Green1Blue1"];
-		break;
-		case Outputs::Display::InputDataType::Red2Green2Blue2:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed2Green2Blue2"];
-		break;
-		case Outputs::Display::InputDataType::Red4Green4Blue4:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed4Green4Blue4"];
-		break;
-		case Outputs::Display::InputDataType::Red8Green8Blue8:
-			pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
-		break;
+	if(_isUsingCompositionPipeline) {
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
+	} else {
+		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
+		pipelineDescriptor.fragmentFunction =
+			[library newFunctionWithName:isRGBOutput ? samplerDictionary[int(modals.input_data_type)].directRGB : samplerDictionary[int(modals.input_data_type)].directComposite];
 	}
 
 	// Enable blending.
@@ -316,18 +374,23 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.stencilAttachmentPixelFormat = MTLPixelFormatStencil8;
 
 	// Finish.
-	_scanPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+	_outputPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 }
 
-- (void)outputScansFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
+- (void)outputFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
 	// Generate a command encoder for the view.
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
 
-	// Drawing. Just scans.
-	[encoder setRenderPipelineState:_scanPipeline];
+	// Final output. Could be scans or lines.
+	[encoder setRenderPipelineState:_outputPipeline];
 
-	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
-	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+	if(_isUsingCompositionPipeline) {
+		[encoder setFragmentTexture:_compositionTexture atIndex:0];
+		[encoder setVertexBuffer:_linesBuffer offset:0 atIndex:0];
+	} else {
+		[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
+		[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+	}
 	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
 	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
 
@@ -343,7 +406,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		if(start < end) {
 			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end - start baseInstance:start];
 		} else {
-			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:NumBufferedScans - start baseInstance:start];
+			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:(_isUsingCompositionPipeline ? NumBufferedLines : NumBufferedScans) - start baseInstance:start];
 			if(end) {
 				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end];
 			}
@@ -416,21 +479,35 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Hence every pixel is touched every frame, regardless of the machine's output.
 		//
 
-		// TODO: proceed as per the below inly if doing a scan-centric output.
-		// Draw scans to a composition buffer and from there to the display as lines otherwise.
+		if(_isUsingCompositionPipeline) {
+			// TODO: Draw scans to a composition buffer and from there to the display as lines otherwise.
 
-		// Break up scans by frame.
-		size_t line = outputArea.start.line;
-		size_t scan = outputArea.start.scan;
-		while(line != outputArea.end.line) {
-			if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
-				[self outputScansFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
-				[self outputFrameCleanerToCommandBuffer:commandBuffer];
-				scan = _lineMetadataBuffer[line].first_scan;
+			// Output lines, broken up by frame.
+			size_t startLine = outputArea.start.line;
+			size_t line = outputArea.start.line;
+			while(line != outputArea.end.line) {
+				if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+					[self outputFrom:startLine to:line commandBuffer:commandBuffer];
+					[self outputFrameCleanerToCommandBuffer:commandBuffer];
+					startLine = line;
+				}
+				line = (line + 1) % NumBufferedLines;
 			}
-			line = (line + 1) % NumBufferedLines;
+			[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
+		} else {
+			// Output scans directly, broken up by frame.
+			size_t line = outputArea.start.line;
+			size_t scan = outputArea.start.scan;
+			while(line != outputArea.end.line) {
+				if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+					[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
+					[self outputFrameCleanerToCommandBuffer:commandBuffer];
+					scan = _lineMetadataBuffer[line].first_scan;
+				}
+				line = (line + 1) % NumBufferedLines;
+			}
+			[self outputFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
 		}
-		[self outputScansFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
 
 		// Add a callback to update the scan target buffer and commit the drawing.
 		[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
@@ -446,6 +523,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  @discussion Called on the delegate when it is asked to render into the view
  */
 - (void)drawInMTKView:(nonnull MTKView *)view {
+	if(_isDrawing.test_and_set()) {
+		return;
+	}
+
 	// Schedule a copy from the current framebuffer to the view; blitting is unavailable as the target is a framebuffer texture.
 	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
 
@@ -461,6 +542,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder endEncoding];
 
 	[commandBuffer presentDrawable:view.currentDrawable];
+	[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+		self->_isDrawing.clear();
+	}];
 	[commandBuffer commit];
 }
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 4d69f3bc7..0dee02f91 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -161,20 +161,23 @@ vertex SourceInterpolator lineToDisplay(	constant Uniforms &uniforms [[buffer(1)
 
 // This assumes that it needs to generate endpoints for a line segment.
 
-vertex SourceInterpolator scanToCompound(	constant Uniforms &uniforms [[buffer(1)]],
-											constant Scan *scans [[buffer(0)]],
-											uint instanceID [[instance_id]],
-											uint vertexID [[vertex_id]],
-											texture2d<float> texture [[texture(0)]]) {
+vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffer(1)]],
+												constant Scan *scans [[buffer(0)]],
+												uint instanceID [[instance_id]],
+												uint vertexID [[vertex_id]],
+												texture2d<float> texture [[texture(0)]]) {
 	SourceInterpolator result;
 
 	// Populate result as if direct texture access were available.
 	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
 	result.position.y = scans[instanceID].line;
+	result.position.wz = float2(0.0, 1.0);
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
 
-	// TODO: map position into eye space, allowing for target texture dimensions.
+	// Map position into eye space, allowing for target texture dimensions.
+	// TODO: is this really necessary? Is there nothing like coord::pixel that applies here?
+	result.position.xy = ((result.position.xy + float2(0.5)) / float2(texture.get_width(), texture.get_height())) * float2(2.0) - float2(1.0);
 
 	return result;
 }

From 5dc39a5d244e4c36c0655199b8a55d23dafcc1ac Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 19 Aug 2020 21:56:53 -0400
Subject: [PATCH 051/131] Adds the composition render pass.

Albeit that something here doesn't work at present.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 61 ++++++++++++-------
 1 file changed, 39 insertions(+), 22 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 893949848..ccef3330d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -35,6 +35,18 @@ constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheM
 
 #define uniforms() reinterpret_cast<Uniforms *>(_uniformsBuffer.contents)
 
+#define RangePerform(start, end, size, func)	\
+	if(start != end) {	\
+		if(start < end) {	\
+			func(start, end-start);	\
+		} else {	\
+			func(start, size-start);	\
+			if(end) {	\
+				func(0, end);	\
+			}	\
+		}	\
+	}
+
 }
 
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
@@ -66,6 +78,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	MTLRenderPassDescriptor *_frameBufferRenderPass;
 
 	id<MTLTexture> _compositionTexture;
+	MTLRenderPassDescriptor *_compositionRenderPass;
 
 	// The stencil buffer and the two ways it's used.
 	id<MTLTexture> _frameBufferStencil;
@@ -351,6 +364,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			[library newFunctionWithName:isSVideoOutput ? samplerDictionary[int(modals.input_data_type)].compositionSVideo : samplerDictionary[int(modals.input_data_type)].compositionComposite];
 
 		_composePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+		_compositionRenderPass = [[MTLRenderPassDescriptor alloc] init];
+		_compositionRenderPass.colorAttachments[0].texture = _compositionTexture;
+		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
+		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+
+		// TODO: set proper clear colour for S-Video.
 	}
 
 	// Build the output pipeline.
@@ -402,16 +422,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder setCullMode:MTLCullModeBack];
 #endif
 
-	if(start != end) {
-		if(start < end) {
-			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end - start baseInstance:start];
-		} else {
-			[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:(_isUsingCompositionPipeline ? NumBufferedLines : NumBufferedScans) - start baseInstance:start];
-			if(end) {
-				[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:end];
-			}
-		}
-	}
+#define OutputStrips(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:size baseInstance:start]
+	RangePerform(start, end, (_isUsingCompositionPipeline ? NumBufferedLines : NumBufferedScans), OutputStrips);
+#undef OutputStrips
 
 	// Complete encoding and return.
 	[encoder endEncoding];
@@ -450,17 +463,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Ensure texture changes are noted.
 		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
 		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
-		if(writeAreaModificationStart != writeAreaModificationEnd) {
-			if(writeAreaModificationStart < writeAreaModificationEnd) {
-				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, writeAreaModificationEnd - writeAreaModificationStart)];
-			} else {
-				[_writeAreaBuffer didModifyRange:NSMakeRange(writeAreaModificationStart, _totalTextureBytes - writeAreaModificationStart)];
-				if(writeAreaModificationEnd) {
-					[_writeAreaBuffer didModifyRange:NSMakeRange(0, writeAreaModificationEnd)];
-				}
-			}
-
-		}
+#define FlushRegion(start, size)	[_writeAreaBuffer didModifyRange:NSMakeRange(start, size)]
+		RangePerform(writeAreaModificationStart, writeAreaModificationEnd, _totalTextureBytes, FlushRegion);
+#undef FlushRegion
 
 		// Obtain a source for render command encoders.
 		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
@@ -480,7 +485,19 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		//
 
 		if(_isUsingCompositionPipeline) {
-			// TODO: Draw scans to a composition buffer and from there to the display as lines otherwise.
+			// Output all scans to the composition buffer.
+			id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_compositionRenderPass];
+			[encoder setRenderPipelineState:_composePipeline];
+
+			[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
+			[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+			[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+			[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+#define OutputScans(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeLine vertexStart:0 vertexCount:2 instanceCount:size baseInstance:start]
+			RangePerform(outputArea.start.scan, outputArea.end.scan, NumBufferedScans, OutputScans);
+#undef OutputScans
+			[encoder endEncoding];
 
 			// Output lines, broken up by frame.
 			size_t startLine = outputArea.start.line;

From ad6fb85fda9d7fe8ba49caca1241739101ddd2a2 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 20 Aug 2020 20:21:28 -0400
Subject: [PATCH 052/131] Corrects use of composition buffer.

Something is still very obviously amiss in colour processing somewhere down the line, but the correct forms are once again visibly in evidence.
---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm  | 6 ++++--
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 8 +++++---
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index ccef3330d..8dd3c08e4 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -426,7 +426,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	RangePerform(start, end, (_isUsingCompositionPipeline ? NumBufferedLines : NumBufferedScans), OutputStrips);
 #undef OutputStrips
 
-	// Complete encoding and return.
+	// Complete encoding.
 	[encoder endEncoding];
 }
 
@@ -489,10 +489,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_compositionRenderPass];
 			[encoder setRenderPipelineState:_composePipeline];
 
-			[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
 			[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
 			[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+			[encoder setVertexTexture:_compositionTexture atIndex:0];
+
 			[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
+			[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
 
 #define OutputScans(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeLine vertexStart:0 vertexCount:2 instanceCount:size baseInstance:start]
 			RangePerform(outputArea.start.scan, outputArea.end.scan, NumBufferedScans, OutputScans);
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 0dee02f91..6b550f7a9 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -171,13 +171,15 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	// Populate result as if direct texture access were available.
 	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
 	result.position.y = scans[instanceID].line;
-	result.position.wz = float2(0.0, 1.0);
+	result.position.zw = float2(0.0, 1.0);
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
+	result.colourPhase = mix(scans[instanceID].endPoints[0].compositeAngle, scans[instanceID].endPoints[1].compositeAngle, float(vertexID))  / 32.0;
+	result.colourAmplitude = scans[instanceID].compositeAmplitude;
 
 	// Map position into eye space, allowing for target texture dimensions.
 	// TODO: is this really necessary? Is there nothing like coord::pixel that applies here?
-	result.position.xy = ((result.position.xy + float2(0.5)) / float2(texture.get_width(), texture.get_height())) * float2(2.0) - float2(1.0);
+	result.position.xy = ((result.position.xy + float2(0.5)) / float2(texture.get_width(), texture.get_height())) * float2(2.0, -2.0) + float2(-1.0, 1.0);
 
 	return result;
 }
@@ -302,6 +304,6 @@ fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }
 
-fragment float4 clearFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment float4 clearFragment() {
 	return float4(0.0, 0.0, 0.0, 0.64);
 }

From 4e21d24b5f90d230c15834fc60e6ae7bb7a0519f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 20 Aug 2020 20:34:37 -0400
Subject: [PATCH 053/131] Corrects composition colour amplitude.

---
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 6b550f7a9..2cc6d10fa 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -174,8 +174,8 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	result.position.zw = float2(0.0, 1.0);
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
-	result.colourPhase = mix(scans[instanceID].endPoints[0].compositeAngle, scans[instanceID].endPoints[1].compositeAngle, float(vertexID))  / 32.0;
-	result.colourAmplitude = scans[instanceID].compositeAmplitude;
+	result.colourPhase = mix(scans[instanceID].endPoints[0].compositeAngle, scans[instanceID].endPoints[1].compositeAngle, float(vertexID))  / 32.0f;
+	result.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
 
 	// Map position into eye space, allowing for target texture dimensions.
 	// TODO: is this really necessary? Is there nothing like coord::pixel that applies here?

From 7c23c32e4401ddc3bcf899c670a9637348188f86 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 20 Aug 2020 20:45:45 -0400
Subject: [PATCH 054/131] Corrects composition colour phase.

---
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 2cc6d10fa..3e0ed2cd5 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -174,7 +174,11 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	result.position.zw = float2(0.0, 1.0);
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
-	result.colourPhase = mix(scans[instanceID].endPoints[0].compositeAngle, scans[instanceID].endPoints[1].compositeAngle, float(vertexID))  / 32.0f;
+	result.colourPhase = 3.141592654f * mix(
+		float(scans[instanceID].endPoints[0].compositeAngle),
+		float(scans[instanceID].endPoints[1].compositeAngle),
+		float(vertexID)
+	) / 32.0;
 	result.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
 
 	// Map position into eye space, allowing for target texture dimensions.

From d54b937ab6668ad8b0801933377b4c30cf69be2b Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 21 Aug 2020 21:11:25 -0400
Subject: [PATCH 055/131] Starts trying to do actual composite processing.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 21 ++++++++++++---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 27 +++++++++++++++++++
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 8dd3c08e4..e64723934 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -8,9 +8,12 @@
 
 #import "CSScanTarget.h"
 
-#include <atomic>
 #import <Metal/Metal.h>
+
+#include <atomic>
+
 #include "BufferingScanTarget.hpp"
+#include "FIRFilter.hpp"
 
 namespace {
 
@@ -22,6 +25,7 @@ struct Uniforms {
 	simd::float3x3 fromRGB;
 	float zoom;
 	simd::float2 offset;
+	float firCoefficients[8];
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -355,9 +359,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 #endif
 
 	// Build the composition pipeline if one is in use.
+	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
 	if(_isUsingCompositionPipeline) {
-		const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
-
 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
 		pipelineDescriptor.fragmentFunction =
@@ -371,6 +374,15 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 
 		// TODO: set proper clear colour for S-Video.
+
+		// TODO: work out fir coefficients, for real.
+		const float cyclesPerLine = float(modals.cycles_per_line);
+		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
+		SignalProcessing::FIRFilter filter(15, cyclesPerLine, 0.0f, 16.0f * cyclesPerLine / colourCyclesPerLine);
+
+		float *const firCoefficients = uniforms()->firCoefficients;
+		const auto calculatedCoefficients = filter.get_coefficients();
+		memcpy(firCoefficients, calculatedCoefficients.data(), calculatedCoefficients.size() * sizeof(float));
 	}
 
 	// Build the output pipeline.
@@ -378,7 +390,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
 	if(_isUsingCompositionPipeline) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"sampleRed8Green8Blue8"];
+		// TODO!
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"convertComposite"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 3e0ed2cd5..0308260d0 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -30,6 +30,10 @@ struct Uniforms {
 	// Provides zoom and offset to scale the source data.
 	float zoom;
 	float2 offset;
+
+	// Describes the FIR filter in use; it'll be 15 coefficients but they're
+	// symmetrical around the centre.
+	float firCoefficients[8];
 };
 
 namespace {
@@ -311,3 +315,26 @@ fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float
 fragment float4 clearFragment() {
 	return float4(0.0, 0.0, 0.0, 0.64);
 }
+
+// MARK: - Conversion fragment shaders
+
+fragment float4 convertComposite(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	const float3 colour =
+		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates - float2(7.0, 0.0)).rgb +
+		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates - float2(6.0, 0.0)).rgb +
+		uniforms.firCoefficients[2] * texture.sample(standardSampler, vert.textureCoordinates - float2(5.0, 0.0)).rgb +
+		uniforms.firCoefficients[3] * texture.sample(standardSampler, vert.textureCoordinates - float2(4.0, 0.0)).rgb +
+		uniforms.firCoefficients[4] * texture.sample(standardSampler, vert.textureCoordinates - float2(3.0, 0.0)).rgb +
+		uniforms.firCoefficients[5] * texture.sample(standardSampler, vert.textureCoordinates - float2(2.0, 0.0)).rgb +
+		uniforms.firCoefficients[6] * texture.sample(standardSampler, vert.textureCoordinates - float2(1.0, 0.0)).rgb +
+		uniforms.firCoefficients[7] * texture.sample(standardSampler, vert.textureCoordinates).rgb +
+		uniforms.firCoefficients[6] * texture.sample(standardSampler, vert.textureCoordinates + float2(1.0, 0.0)).rgb +
+		uniforms.firCoefficients[5] * texture.sample(standardSampler, vert.textureCoordinates + float2(2.0, 0.0)).rgb +
+		uniforms.firCoefficients[4] * texture.sample(standardSampler, vert.textureCoordinates + float2(3.0, 0.0)).rgb +
+		uniforms.firCoefficients[3] * texture.sample(standardSampler, vert.textureCoordinates + float2(4.0, 0.0)).rgb +
+		uniforms.firCoefficients[2] * texture.sample(standardSampler, vert.textureCoordinates + float2(5.0, 0.0)).rgb +
+		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates + float2(6.0, 0.0)).rgb +
+		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates + float2(7.0, 0.0)).rgb;
+
+	return float4(colour, 1.0);
+}

From bf6a0c9fc481da5bf6e2e64af4308dd5fc22db13 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 21 Aug 2020 22:06:36 -0400
Subject: [PATCH 056/131] Achieves a return of composite colour for
 RGB-producing machines.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 34 ++++++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 11 +++---
 2 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index e64723934..924b31047 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -25,7 +25,7 @@ struct Uniforms {
 	simd::float3x3 fromRGB;
 	float zoom;
 	simd::float2 offset;
-	float firCoefficients[8];
+	simd::float3 firCoefficients[8];
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -373,16 +373,33 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 
-		// TODO: set proper clear colour for S-Video.
+		// TODO: set proper clear colour for S-Video (and fragment function, below).
 
-		// TODO: work out fir coefficients, for real.
+		simd::float3 *const firCoefficients = uniforms()->firCoefficients;
 		const float cyclesPerLine = float(modals.cycles_per_line);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
-		SignalProcessing::FIRFilter filter(15, cyclesPerLine, 0.0f, 16.0f * cyclesPerLine / colourCyclesPerLine);
 
-		float *const firCoefficients = uniforms()->firCoefficients;
-		const auto calculatedCoefficients = filter.get_coefficients();
-		memcpy(firCoefficients, calculatedCoefficients.data(), calculatedCoefficients.size() * sizeof(float));
+		if(isSVideoOutput) {
+			// In S-Video, don't filter luminance.
+			for(size_t c = 0; c < 7; ++c) {
+				firCoefficients[c].x = 0.0f;
+			}
+			firCoefficients[7].x = 1.0f;
+		} else {
+			// In composite, filter luminance gently.
+			SignalProcessing::FIRFilter luminancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.75f);
+			const auto calculatedCoefficients = luminancefilter.get_coefficients();
+			for(size_t c = 0; c < 8; ++c) {
+				firCoefficients[c].x = calculatedCoefficients[c];
+			}
+		}
+
+		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.125f);
+		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
+		for(size_t c = 0; c < 8; ++c) {
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c];
+		}
 	}
 
 	// Build the output pipeline.
@@ -390,8 +407,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
 	if(_isUsingCompositionPipeline) {
-		// TODO!
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"convertComposite"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"filterFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 0308260d0..c4ddf11ce 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -33,7 +33,7 @@ struct Uniforms {
 
 	// Describes the FIR filter in use; it'll be 15 coefficients but they're
 	// symmetrical around the centre.
-	float firCoefficients[8];
+	float3 firCoefficients[8];
 };
 
 namespace {
@@ -270,8 +270,11 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
 		const float2 colourSubcarrier = float2(sin(vert.colourPhase), cos(vert.colourPhase));	\
+		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return float4(	\
-			float3(mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude)),	\
+			level,	\
+			0.5 + 0.5*level*sin(vert.colourPhase),\
+			0.5 + 0.5*level*cos(vert.colourPhase),\
 			1.0		\
 		);	\
 	}
@@ -318,7 +321,7 @@ fragment float4 clearFragment() {
 
 // MARK: - Conversion fragment shaders
 
-fragment float4 convertComposite(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
 	const float3 colour =
 		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates - float2(7.0, 0.0)).rgb +
 		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates - float2(6.0, 0.0)).rgb +
@@ -336,5 +339,5 @@ fragment float4 convertComposite(CopyInterpolator vert [[stage_in]], texture2d<f
 		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates + float2(6.0, 0.0)).rgb +
 		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates + float2(7.0, 0.0)).rgb;
 
-	return float4(colour, 1.0);
+	return float4(uniforms.toRGB * ((colour - float3(0.0, 0.5, 0.5)) * float3(1.0, 2.0 / vert.colourAmplitude, 2.0 / vert.colourAmplitude)), 1.0);
 }

From 5c6112415a03c4281779b0063fe7310203619ebc Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 21 Aug 2020 22:41:54 -0400
Subject: [PATCH 057/131] Sets appropriate clear colour for composition render
 pass.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 924b31047..038743842 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -372,8 +372,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].texture = _compositionTexture;
 		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
-
-		// TODO: set proper clear colour for S-Video (and fragment function, below).
+		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
 
 		simd::float3 *const firCoefficients = uniforms()->firCoefficients;
 		const float cyclesPerLine = float(modals.cycles_per_line);
@@ -395,7 +394,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.125f);
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.33f);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
 			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c];

From 56c7bd242a729a4056e0255d89d16cd8d31a2789 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 22 Aug 2020 16:38:36 -0400
Subject: [PATCH 058/131] Marginally tidies.

---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 33 ++++++++++---------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index c4ddf11ce..0e699eb84 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -322,22 +322,25 @@ fragment float4 clearFragment() {
 // MARK: - Conversion fragment shaders
 
 fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0)).rgb
+	const float3 rawSamples[] = {
+		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
+		Sample(0),
+		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
+	};
+#undef Sample
+
+#define Sample(c, o)	\
+	uniforms.firCoefficients[c] * rawSamples[o]
+
 	const float3 colour =
-		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates - float2(7.0, 0.0)).rgb +
-		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates - float2(6.0, 0.0)).rgb +
-		uniforms.firCoefficients[2] * texture.sample(standardSampler, vert.textureCoordinates - float2(5.0, 0.0)).rgb +
-		uniforms.firCoefficients[3] * texture.sample(standardSampler, vert.textureCoordinates - float2(4.0, 0.0)).rgb +
-		uniforms.firCoefficients[4] * texture.sample(standardSampler, vert.textureCoordinates - float2(3.0, 0.0)).rgb +
-		uniforms.firCoefficients[5] * texture.sample(standardSampler, vert.textureCoordinates - float2(2.0, 0.0)).rgb +
-		uniforms.firCoefficients[6] * texture.sample(standardSampler, vert.textureCoordinates - float2(1.0, 0.0)).rgb +
-		uniforms.firCoefficients[7] * texture.sample(standardSampler, vert.textureCoordinates).rgb +
-		uniforms.firCoefficients[6] * texture.sample(standardSampler, vert.textureCoordinates + float2(1.0, 0.0)).rgb +
-		uniforms.firCoefficients[5] * texture.sample(standardSampler, vert.textureCoordinates + float2(2.0, 0.0)).rgb +
-		uniforms.firCoefficients[4] * texture.sample(standardSampler, vert.textureCoordinates + float2(3.0, 0.0)).rgb +
-		uniforms.firCoefficients[3] * texture.sample(standardSampler, vert.textureCoordinates + float2(4.0, 0.0)).rgb +
-		uniforms.firCoefficients[2] * texture.sample(standardSampler, vert.textureCoordinates + float2(5.0, 0.0)).rgb +
-		uniforms.firCoefficients[1] * texture.sample(standardSampler, vert.textureCoordinates + float2(6.0, 0.0)).rgb +
-		uniforms.firCoefficients[0] * texture.sample(standardSampler, vert.textureCoordinates + float2(7.0, 0.0)).rgb;
+		Sample(0, 0) +	Sample(1, 1) +	Sample(2, 2) +	Sample(3, 3) +
+		Sample(4, 4) +	Sample(5, 5) +	Sample(6, 6) +
+		Sample(7, 7) +
+		Sample(6, 8) +	Sample(5, 9) +	Sample(4, 10) +
+		Sample(3, 11) +	Sample(2, 12) +	Sample(1, 13) +	Sample(0, 14);
+
+#undef Sample
 
 	return float4(uniforms.toRGB * ((colour - float3(0.0, 0.5, 0.5)) * float3(1.0, 2.0 / vert.colourAmplitude, 2.0 / vert.colourAmplitude)), 1.0);
 }

From 7ca0362f23dc319dd71e86453aaaff5681e0dbbd Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 23 Aug 2020 21:03:26 -0400
Subject: [PATCH 059/131] Treads water.

Difficult current question: why does the Atari 2600's display change colours as the display tries to achieve horizontal lock? Phase should be unchanged. Ergo something is amiss.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  9 ++---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 34 +++++++++++--------
 2 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 038743842..29f39ed98 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -359,8 +359,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 #endif
 
 	// Build the composition pipeline if one is in use.
-	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
 	if(_isUsingCompositionPipeline) {
+		const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
+
 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
 		pipelineDescriptor.fragmentFunction =
@@ -374,7 +375,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
 
-		simd::float3 *const firCoefficients = uniforms()->firCoefficients;
+		auto *const firCoefficients = uniforms()->firCoefficients;
 		const float cyclesPerLine = float(modals.cycles_per_line);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
@@ -386,7 +387,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			firCoefficients[7].x = 1.0f;
 		} else {
 			// In composite, filter luminance gently.
-			SignalProcessing::FIRFilter luminancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.75f);
+			SignalProcessing::FIRFilter luminancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.5f);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
 				firCoefficients[c].x = calculatedCoefficients[c];
@@ -394,7 +395,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.33f);
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.5f);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
 			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c];
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 0e699eb84..bcfb85d5b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -123,23 +123,23 @@ template <typename Input> SourceInterpolator toDisplay(
 		float(inputs[instanceID].endPoints[0].compositeAngle),
 		float(inputs[instanceID].endPoints[1].compositeAngle),
 		float((vertexID&2) >> 1)
-	) / 32.0;
+	) / 32.0f;
 
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
 
 	// position2d is now in the range [0, 1].
-	float2 position2d = start + (float(vertexID&2) * 0.5) * tangent + (float(vertexID&1) - 0.5) * normal * uniforms.lineWidth;
+	float2 position2d = start + (float(vertexID&2) * 0.5f) * tangent + (float(vertexID&1) - 0.5f) * normal * uniforms.lineWidth;
 
 	// Apply the requested offset and zoom, to map the desired area to the range [0, 1].
 	position2d = (position2d + uniforms.offset) * uniforms.zoom;
 
 	// Remap from [0, 1] to Metal's [-1, 1] and then apply the aspect ratio correction.
-	position2d = (position2d * float2(2.0, -2.0) + float2(-1.0, 1.0)) * float2(uniforms.aspectRatioMultiplier, 1.0);
+	position2d = (position2d * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f)) * float2(uniforms.aspectRatioMultiplier, 1.0f);
 
 	output.position = float4(
 		position2d,
-		0.0,
-		1.0
+		0.0f,
+		1.0f
 	);
 	output.textureCoordinates = textureLocation(&inputs[instanceID], float((vertexID&2) >> 1));
 
@@ -175,14 +175,14 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	// Populate result as if direct texture access were available.
 	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
 	result.position.y = scans[instanceID].line;
-	result.position.zw = float2(0.0, 1.0);
+	result.position.zw = float2(0.0f, 1.0f);
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
 	result.colourPhase = 3.141592654f * mix(
 		float(scans[instanceID].endPoints[0].compositeAngle),
 		float(scans[instanceID].endPoints[1].compositeAngle),
 		float(vertexID)
-	) / 32.0;
+	) / 32.0f;
 	result.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
 
 	// Map position into eye space, allowing for target texture dimensions.
@@ -221,7 +221,13 @@ fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_
 	const auto luminancePhase = texture.sample(standardSampler, vert.textureCoordinates).rg;
 	const float phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
 	const float rawChroma = step(luminancePhase.g, 0.75) * cos(vert.colourPhase + phaseOffset);
-	return float4(float3(mix(luminancePhase.r, rawChroma, vert.colourAmplitude)), 1.0f);
+	const float level = mix(luminancePhase.r, rawChroma, vert.colourAmplitude);
+	return float4(
+		level,
+		0.5 + 0.5*level*cos(vert.colourPhase),
+		0.5 + 0.5*level*sin(vert.colourPhase),
+		1.0
+	);
 }
 
 // All the RGB formats can produce RGB, composite or S-Video.
@@ -258,10 +264,10 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
-		const float2 colourSubcarrier = float2(sin(vert.colourPhase), cos(vert.colourPhase))*0.5 + float2(0.5);	\
+		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
 		return float4(	\
 			colour.r,	\
-			dot(colour.gb, colourSubcarrier),	\
+			dot(colour.gb, colourSubcarrier)*0.5 + 0.5,	\
 			0.0,	\
 			1.0		\
 		);	\
@@ -269,12 +275,12 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
-		const float2 colourSubcarrier = float2(sin(vert.colourPhase), cos(vert.colourPhase));	\
+		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return float4(	\
 			level,	\
-			0.5 + 0.5*level*sin(vert.colourPhase),\
 			0.5 + 0.5*level*cos(vert.colourPhase),\
+			0.5 + 0.5*level*sin(vert.colourPhase),\
 			1.0		\
 		);	\
 	}
@@ -322,7 +328,7 @@ fragment float4 clearFragment() {
 // MARK: - Conversion fragment shaders
 
 fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0)).rgb
+#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)).rgb
 	const float3 rawSamples[] = {
 		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
 		Sample(0),
@@ -342,5 +348,5 @@ fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<f
 
 #undef Sample
 
-	return float4(uniforms.toRGB * ((colour - float3(0.0, 0.5, 0.5)) * float3(1.0, 2.0 / vert.colourAmplitude, 2.0 / vert.colourAmplitude)), 1.0);
+	return float4(uniforms.toRGB * ((colour - float3(0.0f, 0.5f, 0.5f)) * float3(1.0f, 2.0f / vert.colourAmplitude, 2.0f / vert.colourAmplitude)), 1.0f);
 }

From 8b6879a782ceae13a89c98098d198bd1a38965b0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 23 Aug 2020 21:18:38 -0400
Subject: [PATCH 060/131] Brief detour: introduces myself to C++11 multiline
 string literals.

A full cleaning coming soon, I imagine.
---
 Outputs/OpenGL/ScanTargetGLSLFragments.cpp | 33 +++++++++++-----------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/Outputs/OpenGL/ScanTargetGLSLFragments.cpp b/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
index 9e5b83e53..7892011ba 100644
--- a/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
+++ b/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
@@ -489,28 +489,29 @@ std::unique_ptr<Shader> ScanTarget::conversion_shader() const {
 std::unique_ptr<Shader> ScanTarget::composition_shader() const {
 	const auto modals = BufferingScanTarget::modals();
 	const std::string vertex_shader =
-		"#version 150\n"
+	R"x(#version 150
 
-		"in float startDataX;"
-		"in float startClock;"
+		in float startDataX;
+		in float startClock;
 
-		"in float endDataX;"
-		"in float endClock;"
+		in float endDataX;
+		in float endClock;
 
-		"in float dataY;"
-		"in float lineY;"
+		in float dataY;
+		in float lineY;
 
-		"out vec2 textureCoordinate;"
-		"uniform usampler2D textureName;"
+		out vec2 textureCoordinate;
+		uniform usampler2D textureName;
 
-		"void main(void) {"
-			"float lateral = float(gl_VertexID & 1);"
-			"float longitudinal = float((gl_VertexID & 2) >> 1);"
+		void main(void) {
+			float lateral = float(gl_VertexID & 1);
+			float longitudinal = float((gl_VertexID & 2) >> 1);
 
-			"textureCoordinate = vec2(mix(startDataX, endDataX, lateral), dataY + 0.5) / textureSize(textureName, 0);"
-			"vec2 eyePosition = vec2(mix(startClock, endClock, lateral), lineY + longitudinal) / vec2(2048.0, 2048.0);"
-			"gl_Position = vec4(eyePosition*2.0 - vec2(1.0), 0.0, 1.0);"
-		"}";
+			textureCoordinate = vec2(mix(startDataX, endDataX, lateral), dataY + 0.5) / textureSize(textureName, 0);
+			vec2 eyePosition = vec2(mix(startClock, endClock, lateral), lineY + longitudinal) / vec2(2048.0, 2048.0);
+			gl_Position = vec4(eyePosition*2.0 - vec2(1.0), 0.0, 1.0);
+		}
+	)x";
 
 	std::string fragment_shader =
 		"#version 150\n"

From 807cb99f6d352adc48cc97cc307ead7f53188afc Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 23 Aug 2020 21:39:04 -0400
Subject: [PATCH 061/131] Composite angles are signed.

---
 .../Mac/Clock Signal/ScanTarget/ScanTarget.metal     | 12 ++++++++----
 Outputs/OpenGL/ScanTargetGLSLFragments.cpp           | 11 ++++++-----
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index bcfb85d5b..22c6a53bf 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -51,7 +51,7 @@ struct Scan {
 	struct EndPoint {
 		uint16_t position[2];
 		uint16_t dataOffset;
-		uint16_t compositeAngle;
+		int16_t compositeAngle;
 		uint16_t cyclesSinceRetrace;
 	} endPoints[2];
 
@@ -64,7 +64,7 @@ struct Scan {
 struct Line {
 	struct EndPoint {
 		uint16_t position[2];
-		uint16_t compositeAngle;
+		int16_t compositeAngle;
 		uint16_t cyclesSinceRetrace;
 	} endPoints[2];
 
@@ -176,8 +176,10 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
 	result.position.y = scans[instanceID].line;
 	result.position.zw = float2(0.0f, 1.0f);
+
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
+
 	result.colourPhase = 3.141592654f * mix(
 		float(scans[instanceID].endPoints[0].compositeAngle),
 		float(scans[instanceID].endPoints[1].compositeAngle),
@@ -186,8 +188,10 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	result.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
 
 	// Map position into eye space, allowing for target texture dimensions.
-	// TODO: is this really necessary? Is there nothing like coord::pixel that applies here?
-	result.position.xy = ((result.position.xy + float2(0.5)) / float2(texture.get_width(), texture.get_height())) * float2(2.0, -2.0) + float2(-1.0, 1.0);
+	const float2 textureSize = float2(texture.get_width(), texture.get_height());
+	result.position.xy =
+		((result.position.xy + float2(0.5f)) / textureSize)
+		* float2(2.0f, -2.0f) + float2(-1.0f, 1.0f);
 
 	return result;
 }
diff --git a/Outputs/OpenGL/ScanTargetGLSLFragments.cpp b/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
index 7892011ba..7a55329a0 100644
--- a/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
+++ b/Outputs/OpenGL/ScanTargetGLSLFragments.cpp
@@ -514,14 +514,15 @@ std::unique_ptr<Shader> ScanTarget::composition_shader() const {
 	)x";
 
 	std::string fragment_shader =
-		"#version 150\n"
+	R"x(#version 150
 
-		"out vec4 fragColour;"
-		"in vec2 textureCoordinate;"
+		out vec4 fragColour;
+		in vec2 textureCoordinate;
 
-		"uniform usampler2D textureName;"
+		uniform usampler2D textureName;
 
-		"void main(void) {";
+		void main(void) {
+	)x";
 
 	switch(modals.input_data_type) {
 		case InputDataType::Luminance1:

From e502d336db2dda59f1b9cf104ef7cb2d76ec3417 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 25 Aug 2020 22:05:19 -0400
Subject: [PATCH 062/131] Having decided that these things probably need to be
 separate, starts drilling down on S-Video.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 16 ++++---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 47 ++++++++++++-------
 2 files changed, 39 insertions(+), 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 29f39ed98..245ed9244 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -26,6 +26,7 @@ struct Uniforms {
 	float zoom;
 	simd::float2 offset;
 	simd::float3 firCoefficients[8];
+	float radiansPerPixel;
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -151,9 +152,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		depthStencilDescriptor.frontFaceStencil.stencilFailureOperation = MTLStencilOperationReplace;
 		_clearStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 
-		// Create a composition texture up front.
+		// Create a composition texture up front. (TODO: is it worth switching to an 8bpp texture in composite mode?)
 		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+			texture2DDescriptorWithPixelFormat:MTLPixelFormatRG8Unorm
 			width:2048		// This 'should do'.
 			height:NumBufferedLines
 			mipmapped:NO];
@@ -359,9 +360,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 #endif
 
 	// Build the composition pipeline if one is in use.
+	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
 	if(_isUsingCompositionPipeline) {
-		const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
-
 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
 		pipelineDescriptor.fragmentFunction =
@@ -395,11 +395,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.5f);
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.25f);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c];
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 3.0f : 1.0f);
 		}
+
+		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
 	}
 
 	// Build the output pipeline.
@@ -407,7 +409,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
 	if(_isUsingCompositionPipeline) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"filterFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:isSVideoOutput ? @"filterSVideoFragment" : @"filterCompositeFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 22c6a53bf..201be3260 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -34,6 +34,9 @@ struct Uniforms {
 	// Describes the FIR filter in use; it'll be 15 coefficients but they're
 	// symmetrical around the centre.
 	float3 firCoefficients[8];
+
+	// Maps from pixel offsets into the composition buffer to angular difference.
+	float radiansPerPixel;
 };
 
 namespace {
@@ -217,15 +220,20 @@ fragment float4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]]
 
 // The luminance/phase format can produce either composite or S-Video.
 
-fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return float4(texture.sample(standardSampler, vert.textureCoordinates).rg, 0.0, 1.0);
-}
-
-fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+float2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	const auto luminancePhase = texture.sample(standardSampler, vert.textureCoordinates).rg;
 	const float phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
 	const float rawChroma = step(luminancePhase.g, 0.75) * cos(vert.colourPhase + phaseOffset);
-	const float level = mix(luminancePhase.r, rawChroma, vert.colourAmplitude);
+	return float2(luminancePhase.r, rawChroma);
+}
+
+fragment float2 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return convertLuminance8Phase8(vert, texture);
+}
+
+fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	const float2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const float level = mix(luminanceChroma.r, luminanceChroma.g, vert.colourAmplitude);
 	return float4(
 		level,
 		0.5 + 0.5*level*cos(vert.colourPhase),
@@ -331,26 +339,31 @@ fragment float4 clearFragment() {
 
 // MARK: - Conversion fragment shaders
 
-fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)).rgb
-	const float3 rawSamples[] = {
+fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)).rg - float2(0.0f, 0.5f)
+	const float2 rawSamples[] = {
 		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
 		Sample(0),
 		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
 	};
 #undef Sample
 
-#define Sample(c, o)	\
-	uniforms.firCoefficients[c] * rawSamples[o]
+#define Sample(c, o, a)	\
+	uniforms.firCoefficients[c] * float3(rawSamples[o].r, rawSamples[o].g*cos(vert.colourPhase + (a)*uniforms.radiansPerPixel), rawSamples[o].g*sin(vert.colourPhase + (a)*uniforms.radiansPerPixel))
 
 	const float3 colour =
-		Sample(0, 0) +	Sample(1, 1) +	Sample(2, 2) +	Sample(3, 3) +
-		Sample(4, 4) +	Sample(5, 5) +	Sample(6, 6) +
-		Sample(7, 7) +
-		Sample(6, 8) +	Sample(5, 9) +	Sample(4, 10) +
-		Sample(3, 11) +	Sample(2, 12) +	Sample(1, 13) +	Sample(0, 14);
+		Sample(0, 0, -7) +	Sample(1, 1, -6) +	Sample(2, 2, -5) +	Sample(3, 3, -4) +
+		Sample(4, 4, -3) +	Sample(5, 5, -2) +	Sample(6, 6, -1) +
+		Sample(7, 7, 0) +
+		Sample(6, 8, 1) +	Sample(5, 9, 2) +	Sample(4, 10, 3) +
+		Sample(3, 11, 4) +	Sample(2, 12, 5) +	Sample(1, 13, 6) +	Sample(0, 14, 7);
 
 #undef Sample
 
-	return float4(uniforms.toRGB * ((colour - float3(0.0f, 0.5f, 0.5f)) * float3(1.0f, 2.0f / vert.colourAmplitude, 2.0f / vert.colourAmplitude)), 1.0f);
+	return float4(uniforms.toRGB * colour, 1.0f);
+}
+
+fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	// TODO.
+	return float4(1.0);
 }

From 02cea40ffaf83589d99b90379cc779acc6d36c84 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 25 Aug 2020 22:41:37 -0400
Subject: [PATCH 063/131] Attempts to avoid introducing phase error in
 scanToComposition.

Also brightens S-Video up to RGB levels.
---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm  | 2 +-
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 245ed9244..6feedf896 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -398,7 +398,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.25f);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 3.0f : 1.0f);
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 1.0f);
 		}
 
 		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 201be3260..89ca8a8bd 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -193,7 +193,7 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	// Map position into eye space, allowing for target texture dimensions.
 	const float2 textureSize = float2(texture.get_width(), texture.get_height());
 	result.position.xy =
-		((result.position.xy + float2(0.5f)) / textureSize)
+		((result.position.xy + float2(0.0f, 0.5f)) / textureSize)
 		* float2(2.0f, -2.0f) + float2(-1.0f, 1.0f);
 
 	return result;

From 3d564d85fd3577cca9c855b79da372dbe4930db4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 29 Aug 2020 18:53:37 -0400
Subject: [PATCH 064/131] Proves that per-pixel sine/cos evaluation avoids
 phase issues.

Even in PAL mode. But I'd rather not _require_ this as it kind of negates directly-sampled input.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 24 ++++++++--
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 46 ++++++++++++++-----
 2 files changed, 55 insertions(+), 15 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 6feedf896..71e3c04d9 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -15,6 +15,22 @@
 #include "BufferingScanTarget.hpp"
 #include "FIRFilter.hpp"
 
+/*
+	Pipelines in use:
+
+		RGB input -> RGB display:
+			just output it.
+
+		RGB input -> angular:
+			Composition in the display colour space (YIQ or YUV), conversion to and from S-Video or composite per output pixel.
+
+		Luminance/Phase -> angular:
+			Composition, conversion per output pixel.
+
+		Luminance -> composite:
+			Composition, conversion per input pixel.
+*/
+
 namespace {
 
 struct Uniforms {
@@ -154,9 +170,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Create a composition texture up front. (TODO: is it worth switching to an 8bpp texture in composite mode?)
 		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:MTLPixelFormatRG8Unorm
+			texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
 			width:2048		// This 'should do'.
-			height:NumBufferedLines
+			height:NumBufferedLines	// TODO: I want to turn this down _considerably_. A frame and a bit should be sufficient, though probably I'd also want to adjust the buffering scan target to keep most recent data?
 			mipmapped:NO];
 		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
@@ -395,10 +411,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.25f);
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 1.0f);
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 2.0f : 1.0f);
 		}
 
 		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 89ca8a8bd..6fcbeb812 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -81,10 +81,9 @@ struct SourceInterpolator {
 	float4 position [[position]];
 	float2 textureCoordinates;
 	float colourPhase;
-	float colourAmplitude;
+	float colourAmplitude [[flat]];
 };
 
-
 // MARK: - Vertex shaders.
 
 float2 textureLocation(constant Line *line, float offset) {
@@ -202,6 +201,10 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 
 // MARK: - Various input format conversion samplers.
 
+float2 quadrature(float phase) {
+	return float2(cos(phase), sin(phase));
+}
+
 // There's only one meaningful way to sample the luminance formats.
 
 fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
@@ -276,13 +279,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
-		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
-		return float4(	\
-			colour.r,	\
-			dot(colour.gb, colourSubcarrier)*0.5 + 0.5,	\
-			0.0,	\
-			1.0		\
-		);	\
+		return float4(colour, 1.0);	\
 	}	\
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
@@ -297,6 +294,14 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 		);	\
 	}
 
+//		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
+//		return float4(	\
+//			colour.r,	\
+//			dot(colour.gb, colourSubcarrier)*0.5 + 0.5,	\
+//			0.0,	\
+//			1.0		\
+//		);	\
+
 DeclareShaders(Red8Green8Blue8, float)
 DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
@@ -340,14 +345,33 @@ fragment float4 clearFragment() {
 // MARK: - Conversion fragment shaders
 
 fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)).rg - float2(0.0f, 0.5f)
-	const float2 rawSamples[] = {
+#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f))
+	float4 rawSamples[] = {
 		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
 		Sample(0),
 		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
 	};
 #undef Sample
 
+#define Offset(x)	vert.colourPhase + (x)*uniforms.radiansPerPixel
+	const float angles[] = {
+		Offset(-7),	Offset(-6),	Offset(-5),	Offset(-4),	Offset(-3),	Offset(-2),	Offset(-1),
+		vert.colourPhase,
+		Offset(1),	Offset(2),	Offset(3),	Offset(4),	Offset(5),	Offset(6),	Offset(7)
+	};
+#undef Offset
+
+#define Map(x)	{ \
+		const float2 colourSubcarrier = float2(cos(angles[x]), sin(angles[x]));	\
+		rawSamples[x].g = dot(rawSamples[x].gb, colourSubcarrier);	\
+	}
+
+	Map(0);	Map(1);	Map(2);	Map(3);	Map(4);	Map(5);
+	Map(6);	Map(7);	Map(8);	Map(9);	Map(10);	Map(11);
+	Map(12);	Map(13);	Map(14);
+
+#undef Map
+
 #define Sample(c, o, a)	\
 	uniforms.firCoefficients[c] * float3(rawSamples[o].r, rawSamples[o].g*cos(vert.colourPhase + (a)*uniforms.radiansPerPixel), rawSamples[o].g*sin(vert.colourPhase + (a)*uniforms.radiansPerPixel))
 

From c40d858f02de29136a5a8c11c365e3cad8a46173 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 29 Aug 2020 20:54:46 -0400
Subject: [PATCH 065/131] Switches back to angular stuff at input resolution;
 ensures all S-Video modes work.

Now to roll back onto composite. Fingers crossed!
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 31 ++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 63 +++++++++++++++----
 Outputs/ScanTargets/BufferingScanTarget.cpp   |  3 +
 3 files changed, 65 insertions(+), 32 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 71e3c04d9..9baa9b9fe 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -15,22 +15,6 @@
 #include "BufferingScanTarget.hpp"
 #include "FIRFilter.hpp"
 
-/*
-	Pipelines in use:
-
-		RGB input -> RGB display:
-			just output it.
-
-		RGB input -> angular:
-			Composition in the display colour space (YIQ or YUV), conversion to and from S-Video or composite per output pixel.
-
-		Luminance/Phase -> angular:
-			Composition, conversion per output pixel.
-
-		Luminance -> composite:
-			Composition, conversion per input pixel.
-*/
-
 namespace {
 
 struct Uniforms {
@@ -43,6 +27,7 @@ struct Uniforms {
 	simd::float2 offset;
 	simd::float3 firCoefficients[8];
 	float radiansPerPixel;
+	float cyclesMultiplier;
 };
 
 constexpr size_t NumBufferedScans = 2048;
@@ -374,6 +359,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
 	}
 #endif
+	// Pick a suitable cycle multiplier.
+	uniforms()->cyclesMultiplier = 1.0f;
+	if(_isUsingCompositionPipeline) {
+		const float minimumSize = 4.0f * float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
+		while(uniforms()->cyclesMultiplier * modals.cycles_per_line < minimumSize) {
+			uniforms()->cyclesMultiplier += 1.0f;
+		}
+	}
 
 	// Build the composition pipeline if one is in use.
 	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
@@ -392,7 +385,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
 
 		auto *const firCoefficients = uniforms()->firCoefficients;
-		const float cyclesPerLine = float(modals.cycles_per_line);
+		const float cyclesPerLine = float(modals.cycles_per_line) * uniforms()->cyclesMultiplier;
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
 		if(isSVideoOutput) {
@@ -414,7 +407,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine);
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 2.0f : 1.0f);
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 1.0f);
 		}
 
 		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
@@ -425,7 +418,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
 	if(_isUsingCompositionPipeline) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:isSVideoOutput ? @"filterSVideoFragment" : @"filterCompositeFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"filterFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 6fcbeb812..490d6be9d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -37,6 +37,9 @@ struct Uniforms {
 
 	// Maps from pixel offsets into the composition buffer to angular difference.
 	float radiansPerPixel;
+
+	// Applies a multiplication to all cyclesSinceRetrace values.
+	float cycleMultiplier;
 };
 
 namespace {
@@ -86,13 +89,13 @@ struct SourceInterpolator {
 
 // MARK: - Vertex shaders.
 
-float2 textureLocation(constant Line *line, float offset) {
+float2 textureLocation(constant Line *line, float offset, constant Uniforms &uniforms) {
 	return float2(
-		mix(line->endPoints[0].cyclesSinceRetrace, line->endPoints[1].cyclesSinceRetrace, offset),
+		uniforms.cycleMultiplier * mix(line->endPoints[0].cyclesSinceRetrace, line->endPoints[1].cyclesSinceRetrace, offset),
 		line->line);
 }
 
-float2 textureLocation(constant Scan *scan, float offset) {
+float2 textureLocation(constant Scan *scan, float offset, constant Uniforms &) {
 	return float2(
 		mix(scan->endPoints[0].dataOffset, scan->endPoints[1].dataOffset, offset),
 		scan->dataY);
@@ -143,7 +146,7 @@ template <typename Input> SourceInterpolator toDisplay(
 		0.0f,
 		1.0f
 	);
-	output.textureCoordinates = textureLocation(&inputs[instanceID], float((vertexID&2) >> 1));
+	output.textureCoordinates = textureLocation(&inputs[instanceID], float((vertexID&2) >> 1), uniforms);
 
 	return output;
 }
@@ -175,7 +178,7 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	SourceInterpolator result;
 
 	// Populate result as if direct texture access were available.
-	result.position.x = mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
+	result.position.x = uniforms.cycleMultiplier * mix(scans[instanceID].endPoints[0].cyclesSinceRetrace, scans[instanceID].endPoints[1].cyclesSinceRetrace, float(vertexID));
 	result.position.y = scans[instanceID].line;
 	result.position.zw = float2(0.0f, 1.0f);
 
@@ -223,6 +226,7 @@ fragment float4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]]
 
 // The luminance/phase format can produce either composite or S-Video.
 
+/// @returns A 2d vector comprised where .x = luminance; .y = chroma.
 float2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	const auto luminancePhase = texture.sample(standardSampler, vert.textureCoordinates).rg;
 	const float phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
@@ -230,8 +234,12 @@ float2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<f
 	return float2(luminancePhase.r, rawChroma);
 }
 
-fragment float2 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return convertLuminance8Phase8(vert, texture);
+fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	const float2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const float2 qam = quadrature(vert.colourPhase) * 0.5f;
+	return float4(luminanceChroma.r,
+			float2(0.5f) + luminanceChroma.g*qam,
+			1.0);
 }
 
 fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
@@ -279,7 +287,13 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
-		return float4(colour, 1.0);	\
+		const float2 qam = quadrature(vert.colourPhase);	\
+		const float chroma = dot(colour.gb, qam);	\
+		return float4(	\
+			colour.r,	\
+			float2(0.5f) + chroma*qam*0.5f,	\
+			1.0f		\
+		);	\
 	}	\
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
@@ -344,7 +358,7 @@ fragment float4 clearFragment() {
 
 // MARK: - Conversion fragment shaders
 
-fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+/*fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
 #define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f))
 	float4 rawSamples[] = {
 		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
@@ -382,12 +396,35 @@ fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], textu
 		Sample(6, 8, 1) +	Sample(5, 9, 2) +	Sample(4, 10, 3) +
 		Sample(3, 11, 4) +	Sample(2, 12, 5) +	Sample(1, 13, 6) +	Sample(0, 14, 7);
 
+#undef Sample
+
+	return float4(uniforms.toRGB * colour, 1.0f);
+}*/
+
+fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)) - float4(0.0f, 0.5f, 0.5f, 0.0f)
+	float4 rawSamples[] = {
+		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
+		Sample(0),
+		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
+	};
+#undef Sample
+
+#define Sample(c, o, a)	uniforms.firCoefficients[c] * rawSamples[o].rgb
+
+	const float3 colour =
+		Sample(0, 0, -7) +	Sample(1, 1, -6) +	Sample(2, 2, -5) +	Sample(3, 3, -4) +
+		Sample(4, 4, -3) +	Sample(5, 5, -2) +	Sample(6, 6, -1) +
+		Sample(7, 7, 0) +
+		Sample(6, 8, 1) +	Sample(5, 9, 2) +	Sample(4, 10, 3) +
+		Sample(3, 11, 4) +	Sample(2, 12, 5) +	Sample(1, 13, 6) +	Sample(0, 14, 7);
+
 #undef Sample
 
 	return float4(uniforms.toRGB * colour, 1.0f);
 }
 
-fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	// TODO.
-	return float4(1.0);
-}
+//fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+//	// TODO.
+//	return float4(1.0);
+//}
diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 5c8d688e2..3ee12e682 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -264,6 +264,9 @@ void BufferingScanTarget::will_change_owner() {
 	std::lock_guard lock_guard(producer_mutex_);
 	allocation_has_failed_ = true;
 	vended_scan_ = nullptr;
+#ifdef DEBUG
+	data_is_allocated_ = false;
+#endif
 }
 
 const Outputs::Display::Metrics &BufferingScanTarget::display_metrics() {

From 1e1f007bb76a6c9bc2027448d0f1028788867e9c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sat, 29 Aug 2020 21:25:49 -0400
Subject: [PATCH 066/131] Possibly convinces myself that no-separation
 chroma/luma isn't practical.

... as appealing as it may be, were filters perfect.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  6 +-
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 76 ++++---------------
 2 files changed, 19 insertions(+), 63 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9baa9b9fe..36153cc48 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -404,10 +404,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine);
+		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 0.25f));
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 1.0f);
+			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
 		}
 
 		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
@@ -418,7 +418,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
 
 	if(_isUsingCompositionPipeline) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"filterFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:isSVideoOutput ? @"filterSVideoFragment" : @"filterCompositeFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 490d6be9d..050c7b738 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -298,24 +298,15 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
 		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
-		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
+		const float2 colourSubcarrier = quadrature(vert.colourPhase);	\
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return float4(	\
 			level,	\
-			0.5 + 0.5*level*cos(vert.colourPhase),\
-			0.5 + 0.5*level*sin(vert.colourPhase),\
+			float2(0.5f) + level*colourSubcarrier*0.5f,	\
 			1.0		\
 		);	\
 	}
 
-//		const float2 colourSubcarrier = float2(cos(vert.colourPhase), sin(vert.colourPhase));	\
-//		return float4(	\
-//			colour.r,	\
-//			dot(colour.gb, colourSubcarrier)*0.5 + 0.5,	\
-//			0.0,	\
-//			1.0		\
-//		);	\
-
 DeclareShaders(Red8Green8Blue8, float)
 DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
@@ -358,50 +349,7 @@ fragment float4 clearFragment() {
 
 // MARK: - Conversion fragment shaders
 
-/*fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f))
-	float4 rawSamples[] = {
-		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
-		Sample(0),
-		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
-	};
-#undef Sample
-
-#define Offset(x)	vert.colourPhase + (x)*uniforms.radiansPerPixel
-	const float angles[] = {
-		Offset(-7),	Offset(-6),	Offset(-5),	Offset(-4),	Offset(-3),	Offset(-2),	Offset(-1),
-		vert.colourPhase,
-		Offset(1),	Offset(2),	Offset(3),	Offset(4),	Offset(5),	Offset(6),	Offset(7)
-	};
-#undef Offset
-
-#define Map(x)	{ \
-		const float2 colourSubcarrier = float2(cos(angles[x]), sin(angles[x]));	\
-		rawSamples[x].g = dot(rawSamples[x].gb, colourSubcarrier);	\
-	}
-
-	Map(0);	Map(1);	Map(2);	Map(3);	Map(4);	Map(5);
-	Map(6);	Map(7);	Map(8);	Map(9);	Map(10);	Map(11);
-	Map(12);	Map(13);	Map(14);
-
-#undef Map
-
-#define Sample(c, o, a)	\
-	uniforms.firCoefficients[c] * float3(rawSamples[o].r, rawSamples[o].g*cos(vert.colourPhase + (a)*uniforms.radiansPerPixel), rawSamples[o].g*sin(vert.colourPhase + (a)*uniforms.radiansPerPixel))
-
-	const float3 colour =
-		Sample(0, 0, -7) +	Sample(1, 1, -6) +	Sample(2, 2, -5) +	Sample(3, 3, -4) +
-		Sample(4, 4, -3) +	Sample(5, 5, -2) +	Sample(6, 6, -1) +
-		Sample(7, 7, 0) +
-		Sample(6, 8, 1) +	Sample(5, 9, 2) +	Sample(4, 10, 3) +
-		Sample(3, 11, 4) +	Sample(2, 12, 5) +	Sample(1, 13, 6) +	Sample(0, 14, 7);
-
-#undef Sample
-
-	return float4(uniforms.toRGB * colour, 1.0f);
-}*/
-
-fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+template <bool applyCompositeAmplitude> float4 applyFilter(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
 #define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)) - float4(0.0f, 0.5f, 0.5f, 0.0f)
 	float4 rawSamples[] = {
 		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
@@ -421,10 +369,18 @@ fragment float4 filterFragment(SourceInterpolator vert [[stage_in]], texture2d<f
 
 #undef Sample
 
-	return float4(uniforms.toRGB * colour, 1.0f);
+	// This would be `if constexpr`, were this C++17; the compiler should do compile-time selection here regardless.
+	if(applyCompositeAmplitude) {
+		return float4(uniforms.toRGB * (colour * float3(1.0f, 1.0f / vert.colourAmplitude, 1.0f / vert.colourAmplitude)), 1.0f);
+	} else {
+		return float4(uniforms.toRGB * colour, 1.0f);
+	}
 }
 
-//fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-//	// TODO.
-//	return float4(1.0);
-//}
+fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	return applyFilter<false>(vert, texture, uniforms);
+}
+
+fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	return applyFilter<true>(vert, texture, uniforms);
+}

From bb547610f2884090b741956910dac0838ff4561f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 30 Aug 2020 12:06:29 -0400
Subject: [PATCH 067/131] Adds commentary, shrinks some intermediate texture
 sizes.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 65 ++++++++++++-------
 1 file changed, 41 insertions(+), 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 36153cc48..695272d09 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -30,8 +30,8 @@ struct Uniforms {
 	float cyclesMultiplier;
 };
 
-constexpr size_t NumBufferedScans = 2048;
-constexpr size_t NumBufferedLines = 2048;
+constexpr size_t NumBufferedLines = 500;
+constexpr size_t NumBufferedScans = NumBufferedLines * 4;
 
 /// The shared resource options this app would most favour; applied as widely as possible.
 constexpr MTLResourceOptions SharedResourceOptionsStandard = MTLResourceCPUCacheModeWriteCombined | MTLResourceStorageModeShared;
@@ -58,41 +58,58 @@ constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheM
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 @implementation CSScanTarget {
+	// The command queue for the device in use.
 	id<MTLCommandQueue> _commandQueue;
 
-	id<MTLFunction> _vertexShader;
-	id<MTLFunction> _fragmentShader;
-
-	id<MTLRenderPipelineState> _composePipeline;
-	id<MTLRenderPipelineState> _outputPipeline;
-	id<MTLRenderPipelineState> _copyPipeline;
-	id<MTLRenderPipelineState> _clearPipeline;
+	// Pipelines.
+	id<MTLRenderPipelineState> _composePipeline;	// For rendering to the composition texture.
+	id<MTLRenderPipelineState> _outputPipeline;		// For drawing to the frame buffer.
+	id<MTLRenderPipelineState> _copyPipeline;		// For copying the frame buffer to the visible surface.
+	id<MTLRenderPipelineState> _clearPipeline;		// For applying additional inter-frame clearing (cf. the stencil).
 
 	// Buffers.
-	id<MTLBuffer> _uniformsBuffer;
+	id<MTLBuffer> _uniformsBuffer;	// A static buffer, containing a copy of the Uniforms struct.
+	id<MTLBuffer> _scansBuffer;		// A dynamic buffer, into which the CPU writes Scans for later display.
+	id<MTLBuffer> _linesBuffer;		// A dynamic buffer, into which the CPU writes Lines for later display.
 
-	id<MTLBuffer> _scansBuffer;
-	id<MTLBuffer> _linesBuffer;
-	id<MTLBuffer> _writeAreaBuffer;
-
-	// Textures.
+	// Textures: the write area.
+	//
+	// The write area receives fragments of output from the emulated machine.
+	// So it is written by the CPU and read by the GPU.
 	id<MTLTexture> _writeAreaTexture;
-	size_t _bytesPerInputPixel;
-	size_t _totalTextureBytes;
+	id<MTLBuffer> _writeAreaBuffer;		// The storage underlying the write-area texture.
+	size_t _bytesPerInputPixel;			// Determines per-pixel sizing within the write-area texture.
+	size_t _totalTextureBytes;			// Holds the total size of the write-area texture.
 
+	// Textures: the frame buffer.
+	//
+	// When inter-frame blending is in use, the frame buffer contains the most recent output.
+	// Metal isn't really set up for single-buffered output, so this acts as if it were that
+	// single buffer. This texture is complete 2d data, copied directly to the display.
 	id<MTLTexture> _frameBuffer;
-	MTLRenderPassDescriptor *_frameBufferRenderPass;
+	MTLRenderPassDescriptor *_frameBufferRenderPass;	// The render pass for _drawing to_ the frame buffer.
 
-	id<MTLTexture> _compositionTexture;
-	MTLRenderPassDescriptor *_compositionRenderPass;
-
-	// The stencil buffer and the two ways it's used.
+	// Textures: the stencil.
+	//
+	// Scan targets recceive scans, not full frames. Those scans may not cover the entire display,
+	// either because unlit areas have been omitted or because a sync discrepancy means that the full
+	// potential vertical or horizontal width of the display isn't used momentarily.
+	//
+	// In order to manage inter-frame blending correctly in those cases, a stencil is attached to the
+	// frame buffer so that a clearing step can darken any pixels that weren't naturally painted during
+	// any frame.
 	id<MTLTexture> _frameBufferStencil;
 	id<MTLDepthStencilState> _drawStencilState;		// Always draws, sets stencil to 1.
 	id<MTLDepthStencilState> _clearStencilState;	// Draws only where stencil is 0, clears all to 0.
 
-	// The composition pipeline, and whether it's in use.
-	BOOL _isUsingCompositionPipeline;
+	// Textures: the composition texture.
+	//
+	// If additional temporal processing is required (i.e. for S-Video and colour composite output),
+	// fragments from the write-area texture are assembled into the composition texture, where they
+	// properly adjoin their neighbours and everything is converted to a common clock.
+	id<MTLTexture> _compositionTexture;
+	MTLRenderPassDescriptor *_compositionRenderPass;	// The render pass for _drawing to_ the composition buffer.
+	BOOL _isUsingCompositionPipeline;					// Whether the composition pipeline is in use.
 
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;

From b3442691406afc444b2df9d7383491173c8302e0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 30 Aug 2020 20:21:01 -0400
Subject: [PATCH 068/131] I think I accept the need for intermediate steps now.

This allocates storage.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 62 +++++++++++++++++--
 1 file changed, 58 insertions(+), 4 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 695272d09..04a6cd33f 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -10,6 +10,7 @@
 
 #import <Metal/Metal.h>
 
+#include <algorithm>
 #include <atomic>
 
 #include "BufferingScanTarget.hpp"
@@ -111,6 +112,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	MTLRenderPassDescriptor *_compositionRenderPass;	// The render pass for _drawing to_ the composition buffer.
 	BOOL _isUsingCompositionPipeline;					// Whether the composition pipeline is in use.
 
+	// Textures: additional storage used when processing S-Video and composite colour input.
+	id<MTLTexture> _finalisedLineTexture;
+	MTLRenderPassDescriptor *_finalisedLineRenderPass;
+	id<MTLTexture> _separatedLumaTexture;
+	MTLRenderPassDescriptor *_separatedLumaRenderPass;
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
@@ -200,12 +207,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
 	// in order to maintain an ongoing buffer that supersamples only at the end.
 
+	// TODO: Do I need to multiply by contents scale here?
+	const NSUInteger frameBufferWidth = NSUInteger(size.width * view.layer.contentsScale);
+	const NSUInteger frameBufferHeight = NSUInteger(size.height * view.layer.contentsScale);
+
 	@synchronized(self) {
 		// Generate a framebuffer and a stencil.
 		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
 			texture2DDescriptorWithPixelFormat:view.colorPixelFormat
-			width:NSUInteger(size.width * view.layer.contentsScale)
-			height:NSUInteger(size.height * view.layer.contentsScale)
+			width:frameBufferWidth
+			height:frameBufferHeight
 			mipmapped:NO];
 		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
@@ -213,8 +224,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		MTLTextureDescriptor *const stencilTextureDescriptor = [MTLTextureDescriptor
 			texture2DDescriptorWithPixelFormat:MTLPixelFormatStencil8
-			width:NSUInteger(size.width * view.layer.contentsScale)
-			height:NSUInteger(size.height * view.layer.contentsScale)
+			width:frameBufferWidth
+			height:frameBufferHeight
 			mipmapped:NO];
 		stencilTextureDescriptor.usage = MTLTextureUsageRenderTarget;
 		stencilTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
@@ -240,6 +251,46 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_drawStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 
 		// TODO: old framebuffer should be resized onto the new one.
+
+		[self updateSizeAndModalBuffers];
+	}
+}
+
+- (void)updateSizeAndModalBuffers {
+	// Buffers are required only for the composition pipeline; so if this isn't that then release anything
+	// currently being held and return.
+	if(!_isUsingCompositionPipeline) {
+		_finalisedLineTexture = nil;
+		_finalisedLineRenderPass = nil;
+		_separatedLumaTexture = nil;
+		_separatedLumaRenderPass = nil;
+		return;
+	}
+
+	const auto modals = _scanTarget.modals();
+	const NSUInteger frameBufferWidth = NSUInteger(_view.drawableSize.width * _view.layer.contentsScale);
+	const NSUInteger maximumDetail = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
+
+	// maximumDetail = 0 => the modals haven't been set yet. So there's nothing to create buffers for.
+	if(!maximumDetail) {
+		return;
+	}
+
+	// Build a descriptor for any intermediate line texture.
+	MTLTextureDescriptor *const lineTextureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:_view.colorPixelFormat
+		width:std::min(frameBufferWidth, maximumDetail)
+		height:NumBufferedLines
+		mipmapped:NO];
+	lineTextureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+	lineTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+
+	// The finalised texture will definitely exist given that this is the composition pipeline.
+	_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+
+	// A luma separation texture will exist only for composite colour.
+	if(modals.display_type == Outputs::Display::DisplayType::CompositeColour) {
+		_separatedLumaTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
 	}
 }
 
@@ -452,6 +503,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Finish.
 	_outputPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+	// Update intermediate storage that is a function of both modals and current window size.
+	[self updateSizeAndModalBuffers];
 }
 
 - (void)outputFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {

From 67d4dbf91a0db10388e73c01b65faf66c1e331ff Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 31 Aug 2020 20:01:59 -0400
Subject: [PATCH 069/131] Starts girding for a third pipeline.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 288 ++++++++++++------
 1 file changed, 187 insertions(+), 101 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 04a6cd33f..6e66dae5f 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -16,6 +16,78 @@
 #include "BufferingScanTarget.hpp"
 #include "FIRFilter.hpp"
 
+/*
+
+	RGB and composite monochrome
+	----------------------------
+
+	Source data is converted to 32bpp RGB or to composite directly from its input, at output resolution.
+	Gamma correction is applied unless the inputs are 1bpp (e.g. Macintosh-style black/white, TTL-style RGB).
+
+	TODO: filtering when the output size is 'small'.
+
+	S-Video
+	-------
+
+	Source data is pasted together with a common clock in the composition buffer. Colour phase is baked in
+	at this point. Format within the composition buffer is:
+
+		.r = luminance
+		.g = 0.5 + 0.5 * chrominance * cos(phase)
+		.b = 0.5 + 0.5 * chrominance * sin(phase)
+
+	Contents of the composition buffer are then drawn into the finalised line texture; at this point a suitable
+	low-filter is applied to the two chrominance channels, colours are converted to RGB and gamma corrected.
+
+	Contents from the finalised line texture are then painted to the display.
+
+	Composite colour
+	----------------
+
+	Source data is pasted together with a common clock in the composition buffer. Colour phase and amplitude are
+	recorded at this point. Format within the composition buffer is:
+
+		.r = composite value
+		.g = phase
+		.b = amplitude
+
+	Contents of the composition buffer are transferred to the separated-luma buffer, subject to a low-paass filter
+	that has sought to separate luminance and chrominance, and with phase and amplitude now baked into the latter:
+
+		.r = luminance
+		.g = 0.5 + 0.5 * chrominance * cos(phase)
+		.b = 0.5 + 0.5 * chrominance * sin(phase)
+
+	The process now continues as per the corresponding S-Video steps.
+
+	NOTES
+	-----
+
+		1)	for many of the input pixel formats it would be possible to do the trigonometric side of things at
+			arbitrary precision. Since it would always be necessary to support fixed-precision processing because
+			of the directly-sampled input formats, I've used fixed throughout to reduce the number of permutations
+			and combinations of code I need to support. The precision is always selected to be at least four times
+			the colour clock.
+
+		2)	I experimented with skipping the separated-luma buffer for composite colour based on the observation that
+			just multiplying the raw signal by sin and cos and then filtering well below the colour subcarrier frequency
+			should be sufficient. It wasn't in practice because the bits of luminance that don't quite separate are then
+			of such massive amplitude that you get huge bands of bright colour in place of the usual chroma dots.
+
+		3)	I also initially didn't want to have a finalied-line texture, but processing costs changed my mind on that.
+			If you accept that output will be fixed precision, anyway. In that case, processing for a typical NTSC frame
+			in its original resolution means applying filtering (i.e. at least 15 samples per pixel) likely between
+			218,400 and 273,000 times per output frame, then upscaling from there at 1 sample per pixel. Count the second
+			sample twice for the original store and you're talking between 16*218,400 = 3,494,400 to 16*273,000 = 4,368,000
+			total pixel accesses. Though that's not a perfect way to measure cost, roll with it.
+
+			On my 4k monitor, doing it at actual output resolution would instead cost 3840*2160*15 = 124,416,000 total
+			accesses. Which doesn't necessarily mean "more than 28 times as much", but does mean "a lot more".
+
+			(going direct-to-display for composite monochrome means evaluating sin/cos a lot more often than it might
+			with more buffering in between, but that doesn't provisionally seem to be as much of a bottleneck)
+*/
+
 namespace {
 
 struct Uniforms {
@@ -110,7 +182,23 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// properly adjoin their neighbours and everything is converted to a common clock.
 	id<MTLTexture> _compositionTexture;
 	MTLRenderPassDescriptor *_compositionRenderPass;	// The render pass for _drawing to_ the composition buffer.
-	BOOL _isUsingCompositionPipeline;					// Whether the composition pipeline is in use.
+
+	enum class Pipeline {
+		/// Scans are painted directly to the frame buffer.
+		DirectToDisplay,
+		/// Scans are painted to the composition buffer, which is processed to the finalised line buffer,
+		/// from which lines are painted to the frame buffer.
+		SVideo,
+		/// Scans are painted to the composition buffer, which is processed to the separated luma buffer and then the finalised line buffer,
+		/// from which lines are painted to the frame buffer.
+		CompositeColour
+
+		// TODO: decide what to do for downard-scaled direct-to-display. Obvious options are to include lowpass
+		// filtering into the scan outputter and contine hoping that the vertical takes care of itself, or maybe
+		// to stick with DirectToDisplay but with a minimum size for the frame buffer and apply filtering from
+		// there to the screen.
+	};
+	Pipeline _pipeline;
 
 	// Textures: additional storage used when processing S-Video and composite colour input.
 	id<MTLTexture> _finalisedLineTexture;
@@ -177,16 +265,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		depthStencilDescriptor.frontFaceStencil.stencilFailureOperation = MTLStencilOperationReplace;
 		_clearStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 
-		// Create a composition texture up front. (TODO: is it worth switching to an 8bpp texture in composite mode?)
-		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
-			width:2048		// This 'should do'.
-			height:NumBufferedLines	// TODO: I want to turn this down _considerably_. A frame and a bit should be sufficient, though probably I'd also want to adjust the buffering scan target to keep most recent data?
-			mipmapped:NO];
-		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
-		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
-		_compositionTexture = [view.device newTextureWithDescriptor:textureDescriptor];
-
 		// Ensure the is-drawing flag is initially clear.
 		_isDrawing.clear();
 	}
@@ -204,93 +282,97 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 - (void)mtkView:(nonnull MTKView *)view drawableSizeWillChange:(CGSize)size {
 	[self setAspectRatio];
 
-	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
-	// in order to maintain an ongoing buffer that supersamples only at the end.
-
-	// TODO: Do I need to multiply by contents scale here?
-	const NSUInteger frameBufferWidth = NSUInteger(size.width * view.layer.contentsScale);
-	const NSUInteger frameBufferHeight = NSUInteger(size.height * view.layer.contentsScale);
-
 	@synchronized(self) {
-		// Generate a framebuffer and a stencil.
-		MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:view.colorPixelFormat
-			width:frameBufferWidth
-			height:frameBufferHeight
-			mipmapped:NO];
-		textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
-		textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
-		_frameBuffer = [view.device newTextureWithDescriptor:textureDescriptor];
-
-		MTLTextureDescriptor *const stencilTextureDescriptor = [MTLTextureDescriptor
-			texture2DDescriptorWithPixelFormat:MTLPixelFormatStencil8
-			width:frameBufferWidth
-			height:frameBufferHeight
-			mipmapped:NO];
-		stencilTextureDescriptor.usage = MTLTextureUsageRenderTarget;
-		stencilTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
-		_frameBufferStencil = [view.device newTextureWithDescriptor:stencilTextureDescriptor];
-
-		// Generate a render pass with that framebuffer and stencil.
-		_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
-		_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
-		_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
-		_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
-
-		_frameBufferRenderPass.stencilAttachment.clearStencil = 0;
-		_frameBufferRenderPass.stencilAttachment.texture = _frameBufferStencil;
-		_frameBufferRenderPass.stencilAttachment.loadAction = MTLLoadActionLoad;
-		_frameBufferRenderPass.stencilAttachment.storeAction = MTLStoreActionStore;
-
-		// Establish intended stencil useage; it's only to track which pixels haven't been painted
-		// at all at the end of every frame. So: always paint, and replace the stored stencil value
-		// (which is seeded as 0) with the nominated one (a 1).
-		MTLDepthStencilDescriptor *depthStencilDescriptor = [[MTLDepthStencilDescriptor alloc] init];
-		depthStencilDescriptor.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionAlways;
-		depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
-		_drawStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
-
-		// TODO: old framebuffer should be resized onto the new one.
-
-		[self updateSizeAndModalBuffers];
+		[self updateSizeBuffers];
 	}
 }
 
-- (void)updateSizeAndModalBuffers {
-	// Buffers are required only for the composition pipeline; so if this isn't that then release anything
-	// currently being held and return.
-	if(!_isUsingCompositionPipeline) {
-		_finalisedLineTexture = nil;
-		_finalisedLineRenderPass = nil;
-		_separatedLumaTexture = nil;
-		_separatedLumaRenderPass = nil;
-		return;
-	}
-
-	const auto modals = _scanTarget.modals();
+- (void)updateSizeBuffers {
+	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
+	// in order to maintain an ongoing buffer that supersamples only at the end.
 	const NSUInteger frameBufferWidth = NSUInteger(_view.drawableSize.width * _view.layer.contentsScale);
-	const NSUInteger maximumDetail = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
+	const NSUInteger frameBufferHeight = NSUInteger(_view.drawableSize.height * _view.layer.contentsScale);
 
-	// maximumDetail = 0 => the modals haven't been set yet. So there's nothing to create buffers for.
-	if(!maximumDetail) {
-		return;
-	}
+	// Generate a framebuffer and a stencil.
+	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:_view.colorPixelFormat
+		width:frameBufferWidth
+		height:frameBufferHeight
+		mipmapped:NO];
+	textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+	textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+	_frameBuffer = [_view.device newTextureWithDescriptor:textureDescriptor];
 
+	MTLTextureDescriptor *const stencilTextureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:MTLPixelFormatStencil8
+		width:frameBufferWidth
+		height:frameBufferHeight
+		mipmapped:NO];
+	stencilTextureDescriptor.usage = MTLTextureUsageRenderTarget;
+	stencilTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+	_frameBufferStencil = [_view.device newTextureWithDescriptor:stencilTextureDescriptor];
+
+	// Generate a render pass with that framebuffer and stencil.
+	_frameBufferRenderPass = [[MTLRenderPassDescriptor alloc] init];
+	_frameBufferRenderPass.colorAttachments[0].texture = _frameBuffer;
+	_frameBufferRenderPass.colorAttachments[0].loadAction = MTLLoadActionLoad;
+	_frameBufferRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+
+	_frameBufferRenderPass.stencilAttachment.clearStencil = 0;
+	_frameBufferRenderPass.stencilAttachment.texture = _frameBufferStencil;
+	_frameBufferRenderPass.stencilAttachment.loadAction = MTLLoadActionLoad;
+	_frameBufferRenderPass.stencilAttachment.storeAction = MTLStoreActionStore;
+
+	// Establish intended stencil useage; it's only to track which pixels haven't been painted
+	// at all at the end of every frame. So: always paint, and replace the stored stencil value
+	// (which is seeded as 0) with the nominated one (a 1).
+	MTLDepthStencilDescriptor *depthStencilDescriptor = [[MTLDepthStencilDescriptor alloc] init];
+	depthStencilDescriptor.frontFaceStencil.stencilCompareFunction = MTLCompareFunctionAlways;
+	depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
+	_drawStencilState = [_view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+
+	// TODO: old framebuffer should be resized onto the new one.
+}
+
+- (void)updateModalBuffers {
 	// Build a descriptor for any intermediate line texture.
 	MTLTextureDescriptor *const lineTextureDescriptor = [MTLTextureDescriptor
-		texture2DDescriptorWithPixelFormat:_view.colorPixelFormat
-		width:std::min(frameBufferWidth, maximumDetail)
+		texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+		width:2048		// This 'should do'.
 		height:NumBufferedLines
 		mipmapped:NO];
 	lineTextureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 	lineTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
 
-	// The finalised texture will definitely exist given that this is the composition pipeline.
-	_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+	if(_pipeline == Pipeline::DirectToDisplay) {
+		// Buffers are not required when outputting direct to display; so if this isn't that then release anything
+		// currently being held and return.
+		_finalisedLineTexture = nil;
+		_finalisedLineRenderPass = nil;
+		_separatedLumaTexture = nil;
+		_separatedLumaRenderPass = nil;
+		_compositionTexture = nil;
+		_compositionRenderPass = nil;
+		return;
+	}
+
+	// Create a composition texture if one does not yet exist.
+	if(!_compositionTexture) {
+		_compositionTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+	}
+
+	// The finalised texture will definitely exist.
+	if(!_finalisedLineTexture) {
+		_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+	}
 
 	// A luma separation texture will exist only for composite colour.
-	if(modals.display_type == Outputs::Display::DisplayType::CompositeColour) {
-		_separatedLumaTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+	if(_pipeline == Pipeline::CompositeColour) {
+		if(!_separatedLumaTexture) {
+			_separatedLumaTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+		}
+	} else {
+		_separatedLumaTexture = nil;
 	}
 }
 
@@ -386,12 +468,23 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	//
 	//	(i) input and output are both RGB; or
 	//	(i) output is composite monochrome.
-	_isUsingCompositionPipeline =
+	const bool isComposition =
 		(
 			(natural_display_type_for_data_type(modals.input_data_type) != Outputs::Display::DisplayType::RGB) ||
 			(modals.display_type != Outputs::Display::DisplayType::RGB)
 		) && modals.display_type != Outputs::Display::DisplayType::CompositeMonochrome;
+	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
 
+	if(!isComposition) {
+		_pipeline = Pipeline::DirectToDisplay;
+	} else {
+		_pipeline = isSVideoOutput ? Pipeline::SVideo : Pipeline::CompositeColour;
+	}
+
+	// Update intermediate storage.
+	[self updateModalBuffers];
+
+	// TODO: factor in gamma, which may or may not be a factor (it isn't for 1-bit formats).
 	struct FragmentSamplerDictionary {
 		/// Fragment shader that outputs to the composition buffer for composite processing.
 		NSString *const compositionComposite;
@@ -403,9 +496,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		/// Fragment shader that outputs directly as RGB.
 		NSString *const directRGB;
 	};
-
-	// TODO: create fragment shaders to apply composite multiplication.
-	// TODO: incorporate gamma correction into all direct outputters.
 	const FragmentSamplerDictionary samplerDictionary[8] = {
 		// Luminance1
 		{@"sampleLuminance1", nullptr, @"sampleLuminance1", nullptr},
@@ -427,19 +517,17 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
 	}
 #endif
-	// Pick a suitable cycle multiplier.
+
 	uniforms()->cyclesMultiplier = 1.0f;
-	if(_isUsingCompositionPipeline) {
+	if(_pipeline != Pipeline::DirectToDisplay) {
+		// Pick a suitable cycle multiplier.
 		const float minimumSize = 4.0f * float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 		while(uniforms()->cyclesMultiplier * modals.cycles_per_line < minimumSize) {
 			uniforms()->cyclesMultiplier += 1.0f;
 		}
-	}
 
-	// Build the composition pipeline if one is in use.
-	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
-	if(_isUsingCompositionPipeline) {
-		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
+		// Create the composition render pass.
+ 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
 		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
 		pipelineDescriptor.fragmentFunction =
 			[library newFunctionWithName:isSVideoOutput ? samplerDictionary[int(modals.input_data_type)].compositionSVideo : samplerDictionary[int(modals.input_data_type)].compositionComposite];
@@ -452,6 +540,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
 		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
 
+		// Create suitable FIR filters.
 		auto *const firCoefficients = uniforms()->firCoefficients;
 		const float cyclesPerLine = float(modals.cycles_per_line) * uniforms()->cyclesMultiplier;
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
@@ -483,9 +572,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Build the output pipeline.
 	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
-	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_isUsingCompositionPipeline ? @"lineToDisplay" : @"scanToDisplay"];
+	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_pipeline == Pipeline::DirectToDisplay ? @"scanToDisplay" : @"lineToDisplay"];
 
-	if(_isUsingCompositionPipeline) {
+	if(_pipeline != Pipeline::DirectToDisplay) {
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:isSVideoOutput ? @"filterSVideoFragment" : @"filterCompositeFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
@@ -503,9 +592,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Finish.
 	_outputPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
-
-	// Update intermediate storage that is a function of both modals and current window size.
-	[self updateSizeAndModalBuffers];
 }
 
 - (void)outputFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
@@ -515,7 +601,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// Final output. Could be scans or lines.
 	[encoder setRenderPipelineState:_outputPipeline];
 
-	if(_isUsingCompositionPipeline) {
+	if(_pipeline != Pipeline::DirectToDisplay) {
 		[encoder setFragmentTexture:_compositionTexture atIndex:0];
 		[encoder setVertexBuffer:_linesBuffer offset:0 atIndex:0];
 	} else {
@@ -534,7 +620,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 #endif
 
 #define OutputStrips(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:size baseInstance:start]
-	RangePerform(start, end, (_isUsingCompositionPipeline ? NumBufferedLines : NumBufferedScans), OutputStrips);
+	RangePerform(start, end, (_pipeline != Pipeline::DirectToDisplay ? NumBufferedLines : NumBufferedScans), OutputStrips);
 #undef OutputStrips
 
 	// Complete encoding.
@@ -595,7 +681,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Hence every pixel is touched every frame, regardless of the machine's output.
 		//
 
-		if(_isUsingCompositionPipeline) {
+		if(_pipeline != Pipeline::DirectToDisplay) {
 			// Output all scans to the composition buffer.
 			id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_compositionRenderPass];
 			[encoder setRenderPipelineState:_composePipeline];

From 67ca298a728c5243b74dd07f8483803720d4f369 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 18:39:52 -0400
Subject: [PATCH 070/131] Forces a no-op compute shader into the S-Video
 pipeline.

The intention is to restrict the area acted over, and to do the S-Video filtering in there. Then I'll just need two such stages for composite.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 141 +++++++++++-------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  10 ++
 2 files changed, 101 insertions(+), 50 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 6e66dae5f..d521821f7 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -202,9 +202,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Textures: additional storage used when processing S-Video and composite colour input.
 	id<MTLTexture> _finalisedLineTexture;
-	MTLRenderPassDescriptor *_finalisedLineRenderPass;
+	id<MTLComputePipelineState> _finalisedLineState;
 	id<MTLTexture> _separatedLumaTexture;
-	MTLRenderPassDescriptor *_separatedLumaRenderPass;
+	id<MTLComputePipelineState> _separatedLumaState;
+	NSUInteger _lineBufferPixelsPerLine;
 
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
@@ -341,16 +342,15 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		width:2048		// This 'should do'.
 		height:NumBufferedLines
 		mipmapped:NO];
-	lineTextureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 	lineTextureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
 
 	if(_pipeline == Pipeline::DirectToDisplay) {
 		// Buffers are not required when outputting direct to display; so if this isn't that then release anything
 		// currently being held and return.
 		_finalisedLineTexture = nil;
-		_finalisedLineRenderPass = nil;
+		_finalisedLineState = nil;
 		_separatedLumaTexture = nil;
-		_separatedLumaRenderPass = nil;
+		_separatedLumaState = nil;
 		_compositionTexture = nil;
 		_compositionRenderPass = nil;
 		return;
@@ -358,12 +358,18 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Create a composition texture if one does not yet exist.
 	if(!_compositionTexture) {
+		lineTextureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 		_compositionTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
 	}
 
+	// Grab the shader library.
+	id<MTLLibrary> library = [_view.device newDefaultLibrary];
+	lineTextureDescriptor.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
+
 	// The finalised texture will definitely exist.
 	if(!_finalisedLineTexture) {
 		_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"copyKernel"] error:nil];
 	}
 
 	// A luma separation texture will exist only for composite colour.
@@ -542,7 +548,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Create suitable FIR filters.
 		auto *const firCoefficients = uniforms()->firCoefficients;
-		const float cyclesPerLine = float(modals.cycles_per_line) * uniforms()->cyclesMultiplier;
+		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
 		if(isSVideoOutput) {
@@ -553,7 +559,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			firCoefficients[7].x = 1.0f;
 		} else {
 			// In composite, filter luminance gently.
-			SignalProcessing::FIRFilter luminancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * 0.5f);
+			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
 				firCoefficients[c].x = calculatedCoefficients[c];
@@ -561,13 +567,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 
 		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, cyclesPerLine, 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 0.25f));
+		SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 0.25f));
 		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 		for(size_t c = 0; c < 8; ++c) {
 			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
 		}
 
-		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / cyclesPerLine;
+		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
 	}
 
 	// Build the output pipeline.
@@ -602,7 +608,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder setRenderPipelineState:_outputPipeline];
 
 	if(_pipeline != Pipeline::DirectToDisplay) {
-		[encoder setFragmentTexture:_compositionTexture atIndex:0];
+		[encoder setFragmentTexture:_finalisedLineTexture atIndex:0];
 		[encoder setVertexBuffer:_linesBuffer offset:0 atIndex:0];
 	} else {
 		[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
@@ -643,6 +649,38 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder endEncoding];
 }
 
+- (void)composeOutputArea:(const BufferingScanTarget::OutputArea &)outputArea commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
+	// Output all scans to the composition buffer.
+	const id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_compositionRenderPass];
+	[encoder setRenderPipelineState:_composePipeline];
+
+	[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
+	[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
+	[encoder setVertexTexture:_compositionTexture atIndex:0];
+
+	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
+	[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
+
+#define OutputScans(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeLine vertexStart:0 vertexCount:2 instanceCount:size baseInstance:start]
+	RangePerform(outputArea.start.scan, outputArea.end.scan, NumBufferedScans, OutputScans);
+#undef OutputScans
+	[encoder endEncoding];
+}
+
+- (void)dispatchComputeCommandEncoder:(id<MTLComputeCommandEncoder>)encoder pipelineState:(id<MTLComputePipelineState>)pipelineState width:(NSUInteger)width height:(NSUInteger)height {
+	// This follows the recommendations at https://developer.apple.com/documentation/metal/calculating_threadgroup_and_grid_sizes ;
+	// I currently have no independent opinion whatsoever.
+	const MTLSize threadsPerThreadgroup = MTLSizeMake(
+		pipelineState.threadExecutionWidth,
+		pipelineState.maxTotalThreadsPerThreadgroup / pipelineState.threadExecutionWidth,
+		1
+	);
+	const MTLSize threadsPerGrid = MTLSizeMake(width, height, 1);
+
+	[encoder setComputePipelineState:pipelineState];
+	[encoder dispatchThreads:threadsPerGrid threadsPerThreadgroup:threadsPerThreadgroup];
+}
+
 - (void)updateFrameBuffer {
 	// TODO: rethink BufferingScanTarget::perform. Is it now really just for guarding the modals?
 	_scanTarget.perform([=] {
@@ -681,48 +719,51 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Hence every pixel is touched every frame, regardless of the machine's output.
 		//
 
-		if(_pipeline != Pipeline::DirectToDisplay) {
-			// Output all scans to the composition buffer.
-			id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_compositionRenderPass];
-			[encoder setRenderPipelineState:_composePipeline];
-
-			[encoder setVertexBuffer:_scansBuffer offset:0 atIndex:0];
-			[encoder setVertexBuffer:_uniformsBuffer offset:0 atIndex:1];
-			[encoder setVertexTexture:_compositionTexture atIndex:0];
-
-			[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
-			[encoder setFragmentTexture:_writeAreaTexture atIndex:0];
-
-#define OutputScans(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeLine vertexStart:0 vertexCount:2 instanceCount:size baseInstance:start]
-			RangePerform(outputArea.start.scan, outputArea.end.scan, NumBufferedScans, OutputScans);
-#undef OutputScans
-			[encoder endEncoding];
-
-			// Output lines, broken up by frame.
-			size_t startLine = outputArea.start.line;
-			size_t line = outputArea.start.line;
-			while(line != outputArea.end.line) {
-				if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
-					[self outputFrom:startLine to:line commandBuffer:commandBuffer];
-					[self outputFrameCleanerToCommandBuffer:commandBuffer];
-					startLine = line;
+		switch(_pipeline) {
+			case Pipeline::DirectToDisplay: {
+				// Output scans directly, broken up by frame.
+				size_t line = outputArea.start.line;
+				size_t scan = outputArea.start.scan;
+				while(line != outputArea.end.line) {
+					if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+						[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
+						[self outputFrameCleanerToCommandBuffer:commandBuffer];
+						scan = _lineMetadataBuffer[line].first_scan;
+					}
+					line = (line + 1) % NumBufferedLines;
 				}
-				line = (line + 1) % NumBufferedLines;
-			}
-			[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
-		} else {
-			// Output scans directly, broken up by frame.
-			size_t line = outputArea.start.line;
-			size_t scan = outputArea.start.scan;
-			while(line != outputArea.end.line) {
-				if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
-					[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
-					[self outputFrameCleanerToCommandBuffer:commandBuffer];
-					scan = _lineMetadataBuffer[line].first_scan;
+				[self outputFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
+			} break;
+
+			default:	// TODO: add composite colour pipeline, and eliminate default.
+			case Pipeline::SVideo: {
+				// Build the composition buffer.
+				[self composeOutputArea:outputArea commandBuffer:commandBuffer];
+
+				// Filter to the finalised line texture.
+				id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+				[computeEncoder setTexture:_compositionTexture atIndex:0];
+				[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
+				[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+				// TODO: limit processed area to those lines that are actually in use.
+				[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines];
+
+				[computeEncoder endEncoding];
+
+				// Output lines, broken up by frame.
+				size_t startLine = outputArea.start.line;
+				size_t line = outputArea.start.line;
+				while(line != outputArea.end.line) {
+					if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+						[self outputFrom:startLine to:line commandBuffer:commandBuffer];
+						[self outputFrameCleanerToCommandBuffer:commandBuffer];
+						startLine = line;
+					}
+					line = (line + 1) % NumBufferedLines;
 				}
-				line = (line + 1) % NumBufferedLines;
-			}
-			[self outputFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
+				[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
+			} break;
 		}
 
 		// Add a callback to update the scan target buffer and commit the drawing.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 050c7b738..e9d8fccbd 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -384,3 +384,13 @@ fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], textu
 fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
 	return applyFilter<true>(vert, texture, uniforms);
 }
+
+// MARK: - Kernel functions
+
+// TEST FUNCTION. Just copies from input to output.
+kernel void copyKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
+						texture2d<float, access::write> outTexture [[texture(1)]],
+						uint2 gid [[thread_position_in_grid]],
+						constant Uniforms &uniforms [[buffer(0)]]) {
+	outTexture.write(inTexture.read(gid), gid);
+}

From 245f2654f0bbc37a1423e7e29ce069be74bb7ae1 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 20:37:11 -0400
Subject: [PATCH 071/131] Shifts S-Video processing into the compute shader.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  4 +-
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 47 +++++++++++++++++--
 2 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index d521821f7..763a464c5 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -369,7 +369,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// The finalised texture will definitely exist.
 	if(!_finalisedLineTexture) {
 		_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
-		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"copyKernel"] error:nil];
+		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"filterChromaKernel"] error:nil];
 	}
 
 	// A luma separation texture will exist only for composite colour.
@@ -581,7 +581,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_pipeline == Pipeline::DirectToDisplay ? @"scanToDisplay" : @"lineToDisplay"];
 
 	if(_pipeline != Pipeline::DirectToDisplay) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:isSVideoOutput ? @"filterSVideoFragment" : @"filterCompositeFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e9d8fccbd..d2fcb82ed 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -48,6 +48,10 @@ constexpr sampler standardSampler(	coord::pixel,
 									address::clamp_to_edge,	// Although arbitrary, stick with this address mode for compatibility all the way to MTLFeatureSet_iOS_GPUFamily1_v1.
 									filter::nearest);
 
+constexpr sampler linearSampler(	coord::pixel,
+									address::clamp_to_edge,	// Although arbitrary, stick with this address mode for compatibility all the way to MTLFeatureSet_iOS_GPUFamily1_v1.
+									filter::linear);
+
 }
 
 // MARK: - Structs used for receiving data from the emulation.
@@ -101,6 +105,8 @@ float2 textureLocation(constant Scan *scan, float offset, constant Uniforms &) {
 		scan->dataY);
 }
 
+// TODO: add 0.5f to the y coordinates above to ensure the middle of each line is hit?
+
 template <typename Input> SourceInterpolator toDisplay(
 	constant Uniforms &uniforms [[buffer(1)]],
 	constant Input *inputs [[buffer(0)]],
@@ -385,12 +391,43 @@ fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], te
 	return applyFilter<true>(vert, texture, uniforms);
 }
 
+fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return texture.sample(linearSampler, vert.textureCoordinates);
+}
+
+
 // MARK: - Kernel functions
 
 // TEST FUNCTION. Just copies from input to output.
-kernel void copyKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
-						texture2d<float, access::write> outTexture [[texture(1)]],
-						uint2 gid [[thread_position_in_grid]],
-						constant Uniforms &uniforms [[buffer(0)]]) {
-	outTexture.write(inTexture.read(gid), gid);
+kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
+								texture2d<float, access::write> outTexture [[texture(1)]],
+								uint2 gid [[thread_position_in_grid]],
+								constant Uniforms &uniforms [[buffer(0)]]) {
+	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
+	const float4 rawSamples[] = {
+		inTexture.read(gid) - moveToZero,
+		inTexture.read(gid + uint2(1, 0)) - moveToZero,
+		inTexture.read(gid + uint2(2, 0)) - moveToZero,
+		inTexture.read(gid + uint2(3, 0)) - moveToZero,
+		inTexture.read(gid + uint2(4, 0)) - moveToZero,
+		inTexture.read(gid + uint2(5, 0)) - moveToZero,
+		inTexture.read(gid + uint2(6, 0)) - moveToZero,
+		inTexture.read(gid + uint2(7, 0)) - moveToZero,
+		inTexture.read(gid + uint2(8, 0)) - moveToZero,
+		inTexture.read(gid + uint2(9, 0)) - moveToZero,
+		inTexture.read(gid + uint2(10, 0)) - moveToZero,
+		inTexture.read(gid + uint2(11, 0)) - moveToZero,
+		inTexture.read(gid + uint2(12, 0)) - moveToZero,
+		inTexture.read(gid + uint2(13, 0)) - moveToZero,
+		inTexture.read(gid + uint2(14, 0)) - moveToZero,
+	};
+
+#define Sample(x, y) uniforms.firCoefficients[y] * rawSamples[x].rgb
+	const float3 colour =
+		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
+		Sample(7, 7) +
+		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
+#undef Sample
+
+	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, 0));
 }

From 9e2bf2af7e90d407abf84e77ecf80ee223af07f1 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 21:27:40 -0400
Subject: [PATCH 072/131] Restricts S-Video processing to updated lines.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 68 +++++++++++++------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 36 +++++-----
 2 files changed, 66 insertions(+), 38 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 763a464c5..502e4b31c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -207,6 +207,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLComputePipelineState> _separatedLumaState;
 	NSUInteger _lineBufferPixelsPerLine;
 
+	size_t _lineOffsetBuffer;
+	id<MTLBuffer> _lineOffsetBuffers[NumBufferedLines];	// Allocating NumBufferedLines buffers ensures these can't possibly be exhausted;
+														// for this list to be exhausted there'd have to be more draw calls in flight than
+														// there are lines for them to operate upon.
+
 	// The scan target in C++-world terms and the non-GPU storage for it.
 	BufferingScanTarget _scanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
@@ -266,6 +271,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		depthStencilDescriptor.frontFaceStencil.stencilFailureOperation = MTLStencilOperationReplace;
 		_clearStencilState = [view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 
+		// Allocate a large number of single-int buffers, for supplying offsets to the compute shaders.
+		// There's a ridiculous amount of overhead in this, but it avoids allocations during drawing,
+		// and a single int per instance is all I need.
+		for(size_t c = 0; c < NumBufferedLines; ++c) {
+			_lineOffsetBuffers[c] = [_view.device newBufferWithLength:sizeof(int) options:SharedResourceOptionsStandard];
+		}
+
 		// Ensure the is-drawing flag is initially clear.
 		_isDrawing.clear();
 	}
@@ -667,7 +679,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder endEncoding];
 }
 
-- (void)dispatchComputeCommandEncoder:(id<MTLComputeCommandEncoder>)encoder pipelineState:(id<MTLComputePipelineState>)pipelineState width:(NSUInteger)width height:(NSUInteger)height {
+- (void)dispatchComputeCommandEncoder:(id<MTLComputeCommandEncoder>)encoder pipelineState:(id<MTLComputePipelineState>)pipelineState width:(NSUInteger)width height:(NSUInteger)height offset:(size_t)offset {
+	// Store and apply the offset.
+	*(reinterpret_cast<int *>(_lineOffsetBuffers[_lineOffsetBuffer].contents)) = int(offset);
+	[encoder setBuffer:_lineOffsetBuffers[_lineOffsetBuffer] offset:0 atIndex:1];
+	_lineOffsetBuffer = (_lineOffsetBuffer + 1) % NumBufferedLines;
+
 	// This follows the recommendations at https://developer.apple.com/documentation/metal/calculating_threadgroup_and_grid_sizes ;
 	// I currently have no independent opinion whatsoever.
 	const MTLSize threadsPerThreadgroup = MTLSizeMake(
@@ -677,6 +694,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	);
 	const MTLSize threadsPerGrid = MTLSizeMake(width, height, 1);
 
+	// Set the pipeline state and dispatch the drawing. Which may slightly overdraw.
 	[encoder setComputePipelineState:pipelineState];
 	[encoder dispatchThreads:threadsPerGrid threadsPerThreadgroup:threadsPerThreadgroup];
 }
@@ -740,29 +758,37 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 				// Build the composition buffer.
 				[self composeOutputArea:outputArea commandBuffer:commandBuffer];
 
-				// Filter to the finalised line texture.
-				id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
-				[computeEncoder setTexture:_compositionTexture atIndex:0];
-				[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
-				[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+				if(outputArea.end.line != outputArea.start.line) {
+					// Filter to the finalised line texture.
+					id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+					[computeEncoder setTexture:_compositionTexture atIndex:0];
+					[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
+					[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
-				// TODO: limit processed area to those lines that are actually in use.
-				[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines];
-
-				[computeEncoder endEncoding];
-
-				// Output lines, broken up by frame.
-				size_t startLine = outputArea.start.line;
-				size_t line = outputArea.start.line;
-				while(line != outputArea.end.line) {
-					if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
-						[self outputFrom:startLine to:line commandBuffer:commandBuffer];
-						[self outputFrameCleanerToCommandBuffer:commandBuffer];
-						startLine = line;
+					if(outputArea.end.line > outputArea.start.line) {
+						[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+					} else {
+						[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+						if(outputArea.end.line) {
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+						}
 					}
-					line = (line + 1) % NumBufferedLines;
+
+					[computeEncoder endEncoding];
+
+					// Output lines, broken up by frame.
+					size_t startLine = outputArea.start.line;
+					size_t line = outputArea.start.line;
+					while(line != outputArea.end.line) {
+						if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+							[self outputFrom:startLine to:line commandBuffer:commandBuffer];
+							[self outputFrameCleanerToCommandBuffer:commandBuffer];
+							startLine = line;
+						}
+						line = (line + 1) % NumBufferedLines;
+					}
+					[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
 				}
-				[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
 			} break;
 		}
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index d2fcb82ed..f5eb88940 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -7,6 +7,7 @@
 //
 
 #include <metal_stdlib>
+
 using namespace metal;
 
 // TODO: I'm being very loose, so far, in use of alpha. Sometimes it's 0.64, somtimes its 1.0.
@@ -402,24 +403,25 @@ fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2
 kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
 								texture2d<float, access::write> outTexture [[texture(1)]],
 								uint2 gid [[thread_position_in_grid]],
-								constant Uniforms &uniforms [[buffer(0)]]) {
+								constant Uniforms &uniforms [[buffer(0)]],
+								constant int &offset [[buffer(1)]]) {
 	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
 	const float4 rawSamples[] = {
-		inTexture.read(gid) - moveToZero,
-		inTexture.read(gid + uint2(1, 0)) - moveToZero,
-		inTexture.read(gid + uint2(2, 0)) - moveToZero,
-		inTexture.read(gid + uint2(3, 0)) - moveToZero,
-		inTexture.read(gid + uint2(4, 0)) - moveToZero,
-		inTexture.read(gid + uint2(5, 0)) - moveToZero,
-		inTexture.read(gid + uint2(6, 0)) - moveToZero,
-		inTexture.read(gid + uint2(7, 0)) - moveToZero,
-		inTexture.read(gid + uint2(8, 0)) - moveToZero,
-		inTexture.read(gid + uint2(9, 0)) - moveToZero,
-		inTexture.read(gid + uint2(10, 0)) - moveToZero,
-		inTexture.read(gid + uint2(11, 0)) - moveToZero,
-		inTexture.read(gid + uint2(12, 0)) - moveToZero,
-		inTexture.read(gid + uint2(13, 0)) - moveToZero,
-		inTexture.read(gid + uint2(14, 0)) - moveToZero,
+		inTexture.read(gid + uint2(0, offset))  - moveToZero,
+		inTexture.read(gid + uint2(1, offset)) - moveToZero,
+		inTexture.read(gid + uint2(2, offset)) - moveToZero,
+		inTexture.read(gid + uint2(3, offset)) - moveToZero,
+		inTexture.read(gid + uint2(4, offset)) - moveToZero,
+		inTexture.read(gid + uint2(5, offset)) - moveToZero,
+		inTexture.read(gid + uint2(6, offset)) - moveToZero,
+		inTexture.read(gid + uint2(7, offset)) - moveToZero,
+		inTexture.read(gid + uint2(8, offset)) - moveToZero,
+		inTexture.read(gid + uint2(9, offset)) - moveToZero,
+		inTexture.read(gid + uint2(10, offset)) - moveToZero,
+		inTexture.read(gid + uint2(11, offset)) - moveToZero,
+		inTexture.read(gid + uint2(12, offset)) - moveToZero,
+		inTexture.read(gid + uint2(13, offset)) - moveToZero,
+		inTexture.read(gid + uint2(14, offset)) - moveToZero,
 	};
 
 #define Sample(x, y) uniforms.firCoefficients[y] * rawSamples[x].rgb
@@ -429,5 +431,5 @@ kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[textu
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, 0));
+	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, offset));
 }

From bf252b8061d1d3c9358432dd1c9ce44113ff5597 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 21:33:54 -0400
Subject: [PATCH 073/131] Fixes sizing of buffers to the current output.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 502e4b31c..da55ca7fa 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -296,15 +296,15 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[self setAspectRatio];
 
 	@synchronized(self) {
-		[self updateSizeBuffers];
+		[self updateSizeBuffersToSize:size];
 	}
 }
 
-- (void)updateSizeBuffers {
+- (void)updateSizeBuffersToSize:(CGSize)size {
 	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
 	// in order to maintain an ongoing buffer that supersamples only at the end.
-	const NSUInteger frameBufferWidth = NSUInteger(_view.drawableSize.width * _view.layer.contentsScale);
-	const NSUInteger frameBufferHeight = NSUInteger(_view.drawableSize.height * _view.layer.contentsScale);
+	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale);
+	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale);
 
 	// Generate a framebuffer and a stencil.
 	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor

From f2929230a20b2dde4fad5d0ef203d13f267257f4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 21:37:36 -0400
Subject: [PATCH 074/131] [Experimentally] introduces blending between computed
 S-Video fragments.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm  | 2 +-
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 6 ++----
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index da55ca7fa..d5b609efe 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -593,7 +593,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_pipeline == Pipeline::DirectToDisplay ? @"scanToDisplay" : @"lineToDisplay"];
 
 	if(_pipeline != Pipeline::DirectToDisplay) {
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"interpolateFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
 		pipelineDescriptor.fragmentFunction =
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index f5eb88940..e0d04f9c2 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -97,17 +97,15 @@ struct SourceInterpolator {
 float2 textureLocation(constant Line *line, float offset, constant Uniforms &uniforms) {
 	return float2(
 		uniforms.cycleMultiplier * mix(line->endPoints[0].cyclesSinceRetrace, line->endPoints[1].cyclesSinceRetrace, offset),
-		line->line);
+		line->line + 0.5f);
 }
 
 float2 textureLocation(constant Scan *scan, float offset, constant Uniforms &) {
 	return float2(
 		mix(scan->endPoints[0].dataOffset, scan->endPoints[1].dataOffset, offset),
-		scan->dataY);
+		scan->dataY + 0.5f);
 }
 
-// TODO: add 0.5f to the y coordinates above to ensure the middle of each line is hit?
-
 template <typename Input> SourceInterpolator toDisplay(
 	constant Uniforms &uniforms [[buffer(1)]],
 	constant Input *inputs [[buffer(0)]],

From 15296e43a40965babae78e91529b59626a2acd5d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 21:58:33 -0400
Subject: [PATCH 075/131] Attempts correctly to set up the CPU side of a
 composite video pipeline, at least.

So: I think this is really close, but I'm out of time for the day.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 162 +++++++++++-------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  91 +++++-----
 2 files changed, 151 insertions(+), 102 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index d5b609efe..b4721a7c4 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -388,6 +388,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	if(_pipeline == Pipeline::CompositeColour) {
 		if(!_separatedLumaTexture) {
 			_separatedLumaTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
+			_separatedLumaState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"separateLumaKernel"] error:nil];
 		}
 	} else {
 		_separatedLumaTexture = nil;
@@ -713,68 +714,104 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		const auto outputArea = _scanTarget.get_output_area();
 
-		// Ensure texture changes are noted.
-		const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
-		const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
+		if(outputArea.end.line != outputArea.start.line) {
+
+			// Ensure texture changes are noted.
+			const auto writeAreaModificationStart = size_t(outputArea.start.write_area_x + outputArea.start.write_area_y * 2048) * _bytesPerInputPixel;
+			const auto writeAreaModificationEnd = size_t(outputArea.end.write_area_x + outputArea.end.write_area_y * 2048) * _bytesPerInputPixel;
 #define FlushRegion(start, size)	[_writeAreaBuffer didModifyRange:NSMakeRange(start, size)]
-		RangePerform(writeAreaModificationStart, writeAreaModificationEnd, _totalTextureBytes, FlushRegion);
+			RangePerform(writeAreaModificationStart, writeAreaModificationEnd, _totalTextureBytes, FlushRegion);
 #undef FlushRegion
 
-		// Obtain a source for render command encoders.
-		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+			// Obtain a source for render command encoders.
+			id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
 
-		//
-		// Drawing algorithm used below, in broad terms:
-		//
-		// Maintain a persistent buffer of current CRT state.
-		//
-		// During each frame, paint to the persistent buffer anything new. Update a stencil buffer to track
-		// every pixel so-far touched.
-		//
-		// At the end of the frame, draw a 'frame cleaner', which is a whole-screen rect that paints over
-		// only those areas that the stencil buffer indicates weren't painted this frame.
-		//
-		// Hence every pixel is touched every frame, regardless of the machine's output.
-		//
+			//
+			// Drawing algorithm used below, in broad terms:
+			//
+			// Maintain a persistent buffer of current CRT state.
+			//
+			// During each frame, paint to the persistent buffer anything new. Update a stencil buffer to track
+			// every pixel so-far touched.
+			//
+			// At the end of the frame, draw a 'frame cleaner', which is a whole-screen rect that paints over
+			// only those areas that the stencil buffer indicates weren't painted this frame.
+			//
+			// Hence every pixel is touched every frame, regardless of the machine's output.
+			//
 
-		switch(_pipeline) {
-			case Pipeline::DirectToDisplay: {
-				// Output scans directly, broken up by frame.
-				size_t line = outputArea.start.line;
-				size_t scan = outputArea.start.scan;
-				while(line != outputArea.end.line) {
-					if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
-						[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
-						[self outputFrameCleanerToCommandBuffer:commandBuffer];
-						scan = _lineMetadataBuffer[line].first_scan;
-					}
-					line = (line + 1) % NumBufferedLines;
-				}
-				[self outputFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
-			} break;
-
-			default:	// TODO: add composite colour pipeline, and eliminate default.
-			case Pipeline::SVideo: {
-				// Build the composition buffer.
-				[self composeOutputArea:outputArea commandBuffer:commandBuffer];
-
-				if(outputArea.end.line != outputArea.start.line) {
-					// Filter to the finalised line texture.
-					id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
-					[computeEncoder setTexture:_compositionTexture atIndex:0];
-					[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
-					[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
-
-					if(outputArea.end.line > outputArea.start.line) {
-						[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
-					} else {
-						[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
-						if(outputArea.end.line) {
-							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+			switch(_pipeline) {
+				case Pipeline::DirectToDisplay: {
+					// Output scans directly, broken up by frame.
+					size_t line = outputArea.start.line;
+					size_t scan = outputArea.start.scan;
+					while(line != outputArea.end.line) {
+						if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+							[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
+							[self outputFrameCleanerToCommandBuffer:commandBuffer];
+							scan = _lineMetadataBuffer[line].first_scan;
 						}
+						line = (line + 1) % NumBufferedLines;
 					}
+					[self outputFrom:scan to:outputArea.end.scan commandBuffer:commandBuffer];
+				} break;
 
-					[computeEncoder endEncoding];
+				case Pipeline::CompositeColour:
+				case Pipeline::SVideo: {
+					// Build the composition buffer.
+					[self composeOutputArea:outputArea commandBuffer:commandBuffer];
+
+					if(_pipeline == Pipeline::SVideo) {
+						// Filter from composition to the finalised line texture.
+						id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+						[computeEncoder setTexture:_compositionTexture atIndex:0];
+						[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
+						[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+						if(outputArea.end.line > outputArea.start.line) {
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+						} else {
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							if(outputArea.end.line) {
+								[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+							}
+						}
+
+						[computeEncoder endEncoding];
+					} else {
+						// Separate luma and then filter.
+						id<MTLComputeCommandEncoder> separateComputeEncoder = [commandBuffer computeCommandEncoder];
+						[separateComputeEncoder setTexture:_compositionTexture atIndex:0];
+						[separateComputeEncoder setTexture:_separatedLumaTexture atIndex:1];
+						[separateComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+						if(outputArea.end.line > outputArea.start.line) {
+							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+						} else {
+							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							if(outputArea.end.line) {
+								[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+							}
+						}
+
+						[separateComputeEncoder endEncoding];
+
+						id<MTLComputeCommandEncoder> filterComputeEncoder = [commandBuffer computeCommandEncoder];
+						[filterComputeEncoder setTexture:_separatedLumaTexture atIndex:0];
+						[filterComputeEncoder setTexture:_finalisedLineTexture atIndex:1];
+						[filterComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+
+						if(outputArea.end.line > outputArea.start.line) {
+							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+						} else {
+							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							if(outputArea.end.line) {
+								[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+							}
+						}
+
+						[filterComputeEncoder endEncoding];
+					}
 
 					// Output lines, broken up by frame.
 					size_t startLine = outputArea.start.line;
@@ -788,15 +825,18 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 						line = (line + 1) % NumBufferedLines;
 					}
 					[self outputFrom:startLine to:outputArea.end.line commandBuffer:commandBuffer];
-				}
-			} break;
-		}
+				} break;
+			}
 
-		// Add a callback to update the scan target buffer and commit the drawing.
-		[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+			// Add a callback to update the scan target buffer and commit the drawing.
+			[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+				self->_scanTarget.complete_output_area(outputArea);
+			}];
+			[commandBuffer commit];
+		} else {
+			// There was no work, but to be contractually correct:
 			self->_scanTarget.complete_output_area(outputArea);
-		}];
-		[commandBuffer commit];
+		}
 	}
 }
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e0d04f9c2..af86c6318 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -307,8 +307,8 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return float4(	\
 			level,	\
-			float2(0.5f) + level*colourSubcarrier*0.5f,	\
-			1.0		\
+			float2(0.5f) + quadrature(vert.colourPhase)*0.5f,	\
+			vert.colourPhase		\
 		);	\
 	}
 
@@ -352,52 +352,16 @@ fragment float4 clearFragment() {
 	return float4(0.0, 0.0, 0.0, 0.64);
 }
 
-// MARK: - Conversion fragment shaders
-
-template <bool applyCompositeAmplitude> float4 applyFilter(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-#define Sample(x)	texture.sample(standardSampler, vert.textureCoordinates + float2(x, 0.0f)) - float4(0.0f, 0.5f, 0.5f, 0.0f)
-	float4 rawSamples[] = {
-		Sample(-7),	Sample(-6),	Sample(-5),	Sample(-4),	Sample(-3),	Sample(-2),	Sample(-1),
-		Sample(0),
-		Sample(1),	Sample(2),	Sample(3),	Sample(4),	Sample(5),	Sample(6),	Sample(7),
-	};
-#undef Sample
-
-#define Sample(c, o, a)	uniforms.firCoefficients[c] * rawSamples[o].rgb
-
-	const float3 colour =
-		Sample(0, 0, -7) +	Sample(1, 1, -6) +	Sample(2, 2, -5) +	Sample(3, 3, -4) +
-		Sample(4, 4, -3) +	Sample(5, 5, -2) +	Sample(6, 6, -1) +
-		Sample(7, 7, 0) +
-		Sample(6, 8, 1) +	Sample(5, 9, 2) +	Sample(4, 10, 3) +
-		Sample(3, 11, 4) +	Sample(2, 12, 5) +	Sample(1, 13, 6) +	Sample(0, 14, 7);
-
-#undef Sample
-
-	// This would be `if constexpr`, were this C++17; the compiler should do compile-time selection here regardless.
-	if(applyCompositeAmplitude) {
-		return float4(uniforms.toRGB * (colour * float3(1.0f, 1.0f / vert.colourAmplitude, 1.0f / vert.colourAmplitude)), 1.0f);
-	} else {
-		return float4(uniforms.toRGB * colour, 1.0f);
-	}
-}
-
-fragment float4 filterSVideoFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	return applyFilter<false>(vert, texture, uniforms);
-}
-
-fragment float4 filterCompositeFragment(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	return applyFilter<true>(vert, texture, uniforms);
-}
+// MARK: -
 
 fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	return texture.sample(linearSampler, vert.textureCoordinates);
 }
 
-
 // MARK: - Kernel functions
 
-// TEST FUNCTION. Just copies from input to output.
+/// Given input pixels of the form (luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase)), applies a lowpass
+/// filter to the two chrominance parts, then uses the toRGB matrix to convert to RGB and stores.
 kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
 								texture2d<float, access::write> outTexture [[texture(1)]],
 								uint2 gid [[thread_position_in_grid]],
@@ -431,3 +395,48 @@ kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[textu
 
 	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, offset));
 }
+
+/// Given input pixels of the form:
+///
+///	(composite sample, cos(phase), sin(phase), colour amplitude), applies a lowpass
+///
+/// Filters to separate luminance, subtracts that and scales and maps the remaining chrominance in order to output
+/// pixels in the form:
+///
+///	(luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase))
+///
+/// i.e. the input form for the filterChromaKernel, above].
+kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
+								texture2d<float, access::write> outTexture [[texture(1)]],
+								uint2 gid [[thread_position_in_grid]],
+								constant Uniforms &uniforms [[buffer(0)]],
+								constant int &offset [[buffer(1)]]) {
+	// TODO!
+	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
+	const float4 rawSamples[] = {
+		inTexture.read(gid + uint2(0, offset))  - moveToZero,
+		inTexture.read(gid + uint2(1, offset)) - moveToZero,
+		inTexture.read(gid + uint2(2, offset)) - moveToZero,
+		inTexture.read(gid + uint2(3, offset)) - moveToZero,
+		inTexture.read(gid + uint2(4, offset)) - moveToZero,
+		inTexture.read(gid + uint2(5, offset)) - moveToZero,
+		inTexture.read(gid + uint2(6, offset)) - moveToZero,
+		inTexture.read(gid + uint2(7, offset)) - moveToZero,
+		inTexture.read(gid + uint2(8, offset)) - moveToZero,
+		inTexture.read(gid + uint2(9, offset)) - moveToZero,
+		inTexture.read(gid + uint2(10, offset)) - moveToZero,
+		inTexture.read(gid + uint2(11, offset)) - moveToZero,
+		inTexture.read(gid + uint2(12, offset)) - moveToZero,
+		inTexture.read(gid + uint2(13, offset)) - moveToZero,
+		inTexture.read(gid + uint2(14, offset)) - moveToZero,
+	};
+
+#define Sample(x, y) uniforms.firCoefficients[y] * rawSamples[x].rgb
+	const float3 colour =
+		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
+		Sample(7, 7) +
+		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
+#undef Sample
+
+	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, offset));
+}

From c36247b609ee69cab5664a184f478c80a8c84d93 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 1 Sep 2020 22:11:48 -0400
Subject: [PATCH 076/131] Ensures reuse of offset buffers.

There seems to be some sort of epic race condition as the drawing pipeline lags though. Will need to investigate.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 34 ++++++++++++-------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index b4721a7c4..40dc5fb53 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -680,11 +680,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[encoder endEncoding];
 }
 
-- (void)dispatchComputeCommandEncoder:(id<MTLComputeCommandEncoder>)encoder pipelineState:(id<MTLComputePipelineState>)pipelineState width:(NSUInteger)width height:(NSUInteger)height offset:(size_t)offset {
+- (id<MTLBuffer>)bufferForOffset:(size_t)offset {
 	// Store and apply the offset.
+	const auto buffer = _lineOffsetBuffers[_lineOffsetBuffer];
 	*(reinterpret_cast<int *>(_lineOffsetBuffers[_lineOffsetBuffer].contents)) = int(offset);
-	[encoder setBuffer:_lineOffsetBuffers[_lineOffsetBuffer] offset:0 atIndex:1];
 	_lineOffsetBuffer = (_lineOffsetBuffer + 1) % NumBufferedLines;
+	return buffer;
+}
+
+- (void)dispatchComputeCommandEncoder:(id<MTLComputeCommandEncoder>)encoder pipelineState:(id<MTLComputePipelineState>)pipelineState width:(NSUInteger)width height:(NSUInteger)height offsetBuffer:(id<MTLBuffer>)offsetBuffer {
+	[encoder setBuffer:offsetBuffer offset:0 atIndex:1];
 
 	// This follows the recommendations at https://developer.apple.com/documentation/metal/calculating_threadgroup_and_grid_sizes ;
 	// I currently have no independent opinion whatsoever.
@@ -769,44 +774,49 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 						[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 						if(outputArea.end.line > outputArea.start.line) {
-							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:[self bufferForOffset:outputArea.start.line]];
 						} else {
-							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:[self bufferForOffset:outputArea.start.line]];
 							if(outputArea.end.line) {
-								[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+								[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:[self bufferForOffset:0]];
 							}
 						}
 
 						[computeEncoder endEncoding];
 					} else {
-						// Separate luma and then filter.
+						// Separate luminance.
 						id<MTLComputeCommandEncoder> separateComputeEncoder = [commandBuffer computeCommandEncoder];
 						[separateComputeEncoder setTexture:_compositionTexture atIndex:0];
 						[separateComputeEncoder setTexture:_separatedLumaTexture atIndex:1];
 						[separateComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
+						__unsafe_unretained id<MTLBuffer> offsetBuffers[2] = {nil, nil};
+						offsetBuffers[0] = [self bufferForOffset:outputArea.start.line];
+
 						if(outputArea.end.line > outputArea.start.line) {
-							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 						} else {
-							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 							if(outputArea.end.line) {
-								[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+								offsetBuffers[1] = [self bufferForOffset:0];
+								[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
 							}
 						}
 
 						[separateComputeEncoder endEncoding];
 
+						// Filter resulting chrominance.
 						id<MTLComputeCommandEncoder> filterComputeEncoder = [commandBuffer computeCommandEncoder];
 						[filterComputeEncoder setTexture:_separatedLumaTexture atIndex:0];
 						[filterComputeEncoder setTexture:_finalisedLineTexture atIndex:1];
 						[filterComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 						if(outputArea.end.line > outputArea.start.line) {
-							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 						} else {
-							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offset:outputArea.start.line];
+							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 							if(outputArea.end.line) {
-								[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offset:0];
+								[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
 							}
 						}
 

From c7ce65ea4c26af2f8c7a10a725e868f2865d8842 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 08:03:10 -0400
Subject: [PATCH 077/131] Attempts fully to restore composite video.

Subject to some sort of nasty race condition for the time being.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 37 ++++++------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 56 +++++++++++--------
 2 files changed, 50 insertions(+), 43 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 40dc5fb53..eaa34017b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -98,7 +98,8 @@ struct Uniforms {
 	simd::float3x3 fromRGB;
 	float zoom;
 	simd::float2 offset;
-	simd::float3 firCoefficients[8];
+	simd::float3 chromaCoefficients[8];
+	float lumaCoefficients[8];
 	float radiansPerPixel;
 	float cyclesMultiplier;
 };
@@ -560,32 +561,30 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
 
 		// Create suitable FIR filters.
-		auto *const firCoefficients = uniforms()->firCoefficients;
 		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
-		if(isSVideoOutput) {
-			// In S-Video, don't filter luminance.
-			for(size_t c = 0; c < 7; ++c) {
-				firCoefficients[c].x = 0.0f;
+		// Generate the chrominance filter.
+		{
+			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
+			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 1.0f));
+			const auto calculatedCoefficients = chrominancefilter.get_coefficients();
+			for(size_t c = 0; c < 8; ++c) {
+				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 8.0f);
+				chromaCoefficients[c].x = 0.0f;
 			}
-			firCoefficients[7].x = 1.0f;
-		} else {
-			// In composite, filter luminance gently.
+			chromaCoefficients[7].x = 1.0f;
+		}
+
+		// Generate the luminance filter.
+		{
+			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
 			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
-			for(size_t c = 0; c < 8; ++c) {
-				firCoefficients[c].x = calculatedCoefficients[c];
-			}
-		}
-
-		// Whether S-Video or composite, apply the same relatively strong filter to colour channels.
-		SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 0.25f));
-		const auto calculatedCoefficients = chrominancefilter.get_coefficients();
-		for(size_t c = 0; c < 8; ++c) {
-			firCoefficients[c].y = firCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
+			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
 		}
 
+		// Store radians per pixel. TODO: is this now orphaned? Should I keep it anyway?
 		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
 	}
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index af86c6318..5e5020a61 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -32,9 +32,13 @@ struct Uniforms {
 	float zoom;
 	float2 offset;
 
-	// Describes the FIR filter in use; it'll be 15 coefficients but they're
+	// Describes the FIR filter in use for chroma filtering; it'll be
+	// 15 coefficients but they're symmetrical around the centre.
+	float3 chromaCoefficients[8];
+
+	// Describes the FIR filter in use for luma filtering; also 15 coefficients
 	// symmetrical around the centre.
-	float3 firCoefficients[8];
+	float lumaCoefficients[8];
 
 	// Maps from pixel offsets into the composition buffer to angular difference.
 	float radiansPerPixel;
@@ -386,7 +390,7 @@ kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[textu
 		inTexture.read(gid + uint2(14, offset)) - moveToZero,
 	};
 
-#define Sample(x, y) uniforms.firCoefficients[y] * rawSamples[x].rgb
+#define Sample(x, y) uniforms.chromaCoefficients[y] * rawSamples[x].rgb
 	const float3 colour =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
@@ -411,32 +415,36 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 								uint2 gid [[thread_position_in_grid]],
 								constant Uniforms &uniforms [[buffer(0)]],
 								constant int &offset [[buffer(1)]]) {
-	// TODO!
-	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
-	const float4 rawSamples[] = {
-		inTexture.read(gid + uint2(0, offset))  - moveToZero,
-		inTexture.read(gid + uint2(1, offset)) - moveToZero,
-		inTexture.read(gid + uint2(2, offset)) - moveToZero,
-		inTexture.read(gid + uint2(3, offset)) - moveToZero,
-		inTexture.read(gid + uint2(4, offset)) - moveToZero,
-		inTexture.read(gid + uint2(5, offset)) - moveToZero,
-		inTexture.read(gid + uint2(6, offset)) - moveToZero,
-		inTexture.read(gid + uint2(7, offset)) - moveToZero,
-		inTexture.read(gid + uint2(8, offset)) - moveToZero,
-		inTexture.read(gid + uint2(9, offset)) - moveToZero,
-		inTexture.read(gid + uint2(10, offset)) - moveToZero,
-		inTexture.read(gid + uint2(11, offset)) - moveToZero,
-		inTexture.read(gid + uint2(12, offset)) - moveToZero,
-		inTexture.read(gid + uint2(13, offset)) - moveToZero,
-		inTexture.read(gid + uint2(14, offset)) - moveToZero,
+	const float4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const float rawSamples[] = {
+		inTexture.read(gid + uint2(0, offset)).r,
+		inTexture.read(gid + uint2(1, offset)).r,
+		inTexture.read(gid + uint2(2, offset)).r,
+		inTexture.read(gid + uint2(3, offset)).r,
+		inTexture.read(gid + uint2(4, offset)).r,
+		inTexture.read(gid + uint2(5, offset)).r,
+		inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,
+		inTexture.read(gid + uint2(9, offset)).r,
+		inTexture.read(gid + uint2(10, offset)).r,
+		inTexture.read(gid + uint2(11, offset)).r,
+		inTexture.read(gid + uint2(12, offset)).r,
+		inTexture.read(gid + uint2(13, offset)).r,
+		inTexture.read(gid + uint2(14, offset)).r,
 	};
 
-#define Sample(x, y) uniforms.firCoefficients[y] * rawSamples[x].rgb
-	const float3 colour =
+#define Sample(x, y) uniforms.lumaCoefficients[y] * rawSamples[x]
+	const float luminance =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, offset));
+	outTexture.write(float4(
+			luminance,
+			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) + float2(0.5f),
+			1.0f
+		),
+		gid + uint2(7, offset));
 }

From 0f0c3e616d09b1769fa19b22f88df9912becb5b4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 08:17:01 -0400
Subject: [PATCH 078/131] Tweaks some numbers.

I'm largely treading water here. Probably time to think about the race.
---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm  | 6 +++---
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 6 ++++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index eaa34017b..00c163fa4 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -567,10 +567,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the chrominance filter.
 		{
 			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
-			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * (isSVideoOutput ? 1.0f : 1.0f));
+			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);	//  * (isSVideoOutput ? 1.0f : 0.25f)
 			const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
-				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 8.0f);
+				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
 				chromaCoefficients[c].x = 0.0f;
 			}
 			chromaCoefficients[7].x = 1.0f;
@@ -579,7 +579,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the luminance filter.
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
+			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.85f);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
 		}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 5e5020a61..b25368e45 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -441,9 +441,11 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
+	// TODO: determine why centreSample.a doesn't seem to be giving the real composite amplitude, and stop
+	// hard-coding 0.3f below.
 	outTexture.write(float4(
-			luminance,
-			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) + float2(0.5f),
+			luminance / (1.0f - 0.3f),
+			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) * 1.0f / 0.3f + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From 7e58648743c0faf3d5db106fd467e11847b1c1fe Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 15:51:48 -0400
Subject: [PATCH 079/131] Corrects front-running bug, plays further with colour
 amplitude.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 54 +++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  6 +--
 Outputs/ScanTargets/BufferingScanTarget.cpp   |  2 +
 3 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 00c163fa4..2f5faedf2 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -567,7 +567,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the chrominance filter.
 		{
 			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
-			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);	//  * (isSVideoOutput ? 1.0f : 0.25f)
+			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.25f);	//  * (isSVideoOutput ? 1.0f : 0.25f)
 			const auto calculatedCoefficients = chrominancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
 				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
@@ -579,7 +579,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the luminance filter.
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.85f);
+			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
 		}
@@ -613,6 +613,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (void)outputFrom:(size_t)start to:(size_t)end commandBuffer:(id<MTLCommandBuffer>)commandBuffer {
+	if(start == end) return;
+
 	// Generate a command encoder for the view.
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
 
@@ -784,42 +786,39 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 						[computeEncoder endEncoding];
 					} else {
 						// Separate luminance.
-						id<MTLComputeCommandEncoder> separateComputeEncoder = [commandBuffer computeCommandEncoder];
-						[separateComputeEncoder setTexture:_compositionTexture atIndex:0];
-						[separateComputeEncoder setTexture:_separatedLumaTexture atIndex:1];
-						[separateComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+						id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+						[computeEncoder setTexture:_compositionTexture atIndex:0];
+						[computeEncoder setTexture:_separatedLumaTexture atIndex:1];
+						[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 						__unsafe_unretained id<MTLBuffer> offsetBuffers[2] = {nil, nil};
 						offsetBuffers[0] = [self bufferForOffset:outputArea.start.line];
 
 						if(outputArea.end.line > outputArea.start.line) {
-							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 						} else {
-							[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 							if(outputArea.end.line) {
 								offsetBuffers[1] = [self bufferForOffset:0];
-								[self dispatchComputeCommandEncoder:separateComputeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
+								[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_separatedLumaState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
 							}
 						}
 
-						[separateComputeEncoder endEncoding];
-
 						// Filter resulting chrominance.
-						id<MTLComputeCommandEncoder> filterComputeEncoder = [commandBuffer computeCommandEncoder];
-						[filterComputeEncoder setTexture:_separatedLumaTexture atIndex:0];
-						[filterComputeEncoder setTexture:_finalisedLineTexture atIndex:1];
-						[filterComputeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
+						[computeEncoder setTexture:_separatedLumaTexture atIndex:0];
+						[computeEncoder setTexture:_finalisedLineTexture atIndex:1];
+						[computeEncoder setBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 						if(outputArea.end.line > outputArea.start.line) {
-							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 						} else {
-							[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
+							[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:NumBufferedLines - outputArea.start.line offsetBuffer:offsetBuffers[0]];
 							if(outputArea.end.line) {
-								[self dispatchComputeCommandEncoder:filterComputeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
+								[self dispatchComputeCommandEncoder:computeEncoder pipelineState:_finalisedLineState width:_lineBufferPixelsPerLine height:outputArea.end.line offsetBuffer:offsetBuffers[1]];
 							}
 						}
 
-						[filterComputeEncoder endEncoding];
+						[computeEncoder endEncoding];
 					}
 
 					// Output lines, broken up by frame.
@@ -843,8 +842,21 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			}];
 			[commandBuffer commit];
 		} else {
-			// There was no work, but to be contractually correct:
-			self->_scanTarget.complete_output_area(outputArea);
+			// There was no work, but to be contractually correct, remember to announce completion,
+			// and do it after finishing an empty command queue, as a cheap way to ensure this doen't
+			// front run any actual processing. TODO: can I do a better job of that?
+			id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+			[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
+				self->_scanTarget.complete_output_area(outputArea);
+			}];
+			[commandBuffer commit];
+
+			// TODO: reenable these and work out how on earth the Master System + Alex Kidd (US) is managing
+			// to provide write_area_y = 0, start_x = 0, end_x = 1.
+//			assert(outputArea.end.line == outputArea.start.line);
+//			assert(outputArea.end.scan == outputArea.start.scan);
+//			assert(outputArea.end.write_area_y == outputArea.start.write_area_y);
+//			assert(outputArea.end.write_area_x == outputArea.start.write_area_x);
 		}
 	}
 }
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index b25368e45..c98c7c8b2 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -442,10 +442,10 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 #undef Sample
 
 	// TODO: determine why centreSample.a doesn't seem to be giving the real composite amplitude, and stop
-	// hard-coding 0.3f below.
+	// hard-coding 0.15f below.
 	outTexture.write(float4(
-			luminance / (1.0f - 0.3f),
-			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) * 1.0f / 0.3f + float2(0.5f),
+			luminance / (1.0f - 0.15f),
+			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));
diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 3ee12e682..d48bb9c08 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -323,6 +323,8 @@ BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 }
 
 void BufferingScanTarget::complete_output_area(const OutputArea &area) {
+	// TODO: check that this is the expected next area if in DEBUG mode.
+
 	PointerSet new_read_pointers;
 	new_read_pointers.line = uint16_t(area.end.line);
 	new_read_pointers.scan = uint16_t(area.end.scan);

From 6ef1dfd8be4f0ee9a11300b616756b94d9bf7840 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 15:52:05 -0400
Subject: [PATCH 080/131] Sets a more realistic colour subcarrier amplitude.

---
 Outputs/CRT/CRT.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Outputs/CRT/CRT.hpp b/Outputs/CRT/CRT.hpp
index 8c9a79f5d..7ab9dbcf5 100644
--- a/Outputs/CRT/CRT.hpp
+++ b/Outputs/CRT/CRT.hpp
@@ -81,7 +81,7 @@ class CRT {
 
 		Outputs::Display::ScanTarget *scan_target_ = &Outputs::Display::NullScanTarget::singleton;
 		Outputs::Display::ScanTarget::Modals scan_target_modals_;
-		static constexpr uint8_t DefaultAmplitude = 80;
+		static constexpr uint8_t DefaultAmplitude = 41;	// Based upon a black level to maximum excursion and positive burst peak of: NTSC: 882 & 143; PAL: 933 & 150.
 
 #ifndef NDEBUG
 		size_t allocated_data_length_ = std::numeric_limits<size_t>::min();

From 8bab9d5d60de2d272e6918038ef57dcc03651c14 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 19:13:54 -0400
Subject: [PATCH 081/131] Corrects S-Video and composite generation for
 RGB[1/2/4] sources.

Also toys with a double luminance filter in order to try to sharpen chrominance. But maybe I should be looking at other convolutions entirely?
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 20 ++++++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  8 ++++----
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 2f5faedf2..fd6afff8b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -540,7 +540,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	uniforms()->cyclesMultiplier = 1.0f;
 	if(_pipeline != Pipeline::DirectToDisplay) {
-		// Pick a suitable cycle multiplier.
+		// Pick a suitable cycle multiplier. TODO: can I reduce this from a multiple of 4?
 		const float minimumSize = 4.0f * float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 		while(uniforms()->cyclesMultiplier * modals.cycles_per_line < minimumSize) {
 			uniforms()->cyclesMultiplier += 1.0f;
@@ -568,18 +568,28 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		{
 			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
 			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.25f);	//  * (isSVideoOutput ? 1.0f : 0.25f)
-			const auto calculatedCoefficients = chrominancefilter.get_coefficients();
+			const auto calculatedChromaCoefficients = chrominancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
-				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
+				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
 				chromaCoefficients[c].x = 0.0f;
 			}
 			chromaCoefficients[7].x = 1.0f;
+
+			// Luminance is under-filtered during the separation phase in order not to subtract too much from chrominance;
+			// therefore an additional filtering is applied here.
+			if(!isSVideoOutput) {
+				SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
+				const auto calculatedLumaCoefficients = luminancefilter.get_coefficients();
+				for(size_t c = 0; c < 8; ++c) {
+					chromaCoefficients[c].x = calculatedLumaCoefficients[c];
+				}
+			}
 		}
 
-		// Generate the luminance filter.
+		// Generate the luminance separation filter.
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
+			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.25f);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
 		}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index c98c7c8b2..ac67ff1d8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -295,7 +295,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	}	\
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
+		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), float(0.0f), float(1.0f));	\
 		const float2 qam = quadrature(vert.colourPhase);	\
 		const float chroma = dot(colour.gb, qam);	\
 		return float4(	\
@@ -306,7 +306,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	}	\
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
+		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), float3(0.0f), float3(1.0f));	\
 		const float2 colourSubcarrier = quadrature(vert.colourPhase);	\
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return float4(	\
@@ -442,10 +442,10 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 #undef Sample
 
 	// TODO: determine why centreSample.a doesn't seem to be giving the real composite amplitude, and stop
-	// hard-coding 0.15f below.
+	// hard-coding 0.15f and 7.0f below.
 	outTexture.write(float4(
 			luminance / (1.0f - 0.15f),
-			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) + float2(0.5f),
+			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) * 28.0f + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From 6efd8782fef5ef0bbaeab6b0e7706d23b7dbfa4d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 2 Sep 2020 20:14:41 -0400
Subject: [PATCH 082/131] Tweaks coefficients some more; makes sure that data
 is never larger than the intermediate buffers.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm     | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index fd6afff8b..de8eb60be 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -544,6 +544,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		const float minimumSize = 4.0f * float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 		while(uniforms()->cyclesMultiplier * modals.cycles_per_line < minimumSize) {
 			uniforms()->cyclesMultiplier += 1.0f;
+
+			if(uniforms()->cyclesMultiplier * modals.cycles_per_line > 2048) {
+				uniforms()->cyclesMultiplier -= 1.0f;
+				break;
+			}
 		}
 
 		// Create the composition render pass.
@@ -567,10 +572,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the chrominance filter.
 		{
 			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
-			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.25f);	//  * (isSVideoOutput ? 1.0f : 0.25f)
+			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.01f);
 			const auto calculatedChromaCoefficients = chrominancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
-				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 4.0f);
+				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 2.0f);
 				chromaCoefficients[c].x = 0.0f;
 			}
 			chromaCoefficients[7].x = 1.0f;
@@ -578,7 +583,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			// Luminance is under-filtered during the separation phase in order not to subtract too much from chrominance;
 			// therefore an additional filtering is applied here.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
+				SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.8f);
 				const auto calculatedLumaCoefficients = luminancefilter.get_coefficients();
 				for(size_t c = 0; c < 8; ++c) {
 					chromaCoefficients[c].x = calculatedLumaCoefficients[c];
@@ -589,7 +594,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the luminance separation filter.
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.25f);
+			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
 			const auto calculatedCoefficients = luminancefilter.get_coefficients();
 			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
 		}

From 0288a1974ba933723ddf5edd6963bb94a5e70bf6 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 13:18:21 -0400
Subject: [PATCH 083/131] Tries: separate filters for chroma and luma, plus a
 post-separation sharpen filter on the latter.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 34 +++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 40 +++++++++----------
 2 files changed, 45 insertions(+), 29 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index de8eb60be..86ef39bb8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -99,7 +99,7 @@ struct Uniforms {
 	float zoom;
 	simd::float2 offset;
 	simd::float3 chromaCoefficients[8];
-	float lumaCoefficients[8];
+	simd::float2 lumaCoefficients[8];
 	float radiansPerPixel;
 	float cyclesMultiplier;
 };
@@ -580,23 +580,39 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			}
 			chromaCoefficients[7].x = 1.0f;
 
-			// Luminance is under-filtered during the separation phase in order not to subtract too much from chrominance;
-			// therefore an additional filtering is applied here.
+			// Luminance will be very soft as a result of the separation phase; apply a sharpen filter to try to undo that.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.8f);
-				const auto calculatedLumaCoefficients = luminancefilter.get_coefficients();
+				constexpr float sharpen[] = {
+					0.0042115543f,
+					0.0f,
+					-0.0641804263f,
+					-0.252418578f,
+					-0.589709163f,
+					0.987914681f,
+					0.627704679f,
+					-0.426862389f,
+					0.627704679f
+				};
 				for(size_t c = 0; c < 8; ++c) {
-					chromaCoefficients[c].x = calculatedLumaCoefficients[c];
+					chromaCoefficients[c].x = sharpen[c];
 				}
 			}
 		}
 
 		// Generate the luminance separation filter.
 		{
+			// TODO: support separate high-low filters for chroma and luma, rather than treating that as purely subtractive.
+
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter luminancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
-			const auto calculatedCoefficients = luminancefilter.get_coefficients();
-			memcpy(luminanceCoefficients, calculatedCoefficients.data(), sizeof(float)*8);
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
+			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.1f);
+
+			const auto lumaCoefficients = lumaPart.get_coefficients();
+			const auto chromaCoefficients = chromaPart.get_coefficients();
+			for(size_t c = 0; c < 8; ++c) {
+				luminanceCoefficients[c].x = lumaCoefficients[c];
+				luminanceCoefficients[c].y = chromaCoefficients[c];
+			}
 		}
 
 		// Store radians per pixel. TODO: is this now orphaned? Should I keep it anyway?
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index ac67ff1d8..9f0ee701b 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -38,7 +38,7 @@ struct Uniforms {
 
 	// Describes the FIR filter in use for luma filtering; also 15 coefficients
 	// symmetrical around the centre.
-	float lumaCoefficients[8];
+	float2 lumaCoefficients[8];
 
 	// Maps from pixel offsets into the composition buffer to angular difference.
 	float radiansPerPixel;
@@ -416,26 +416,26 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 								constant Uniforms &uniforms [[buffer(0)]],
 								constant int &offset [[buffer(1)]]) {
 	const float4 centreSample = inTexture.read(gid + uint2(7, offset));
-	const float rawSamples[] = {
-		inTexture.read(gid + uint2(0, offset)).r,
-		inTexture.read(gid + uint2(1, offset)).r,
-		inTexture.read(gid + uint2(2, offset)).r,
-		inTexture.read(gid + uint2(3, offset)).r,
-		inTexture.read(gid + uint2(4, offset)).r,
-		inTexture.read(gid + uint2(5, offset)).r,
-		inTexture.read(gid + uint2(6, offset)).r,
-		centreSample.r,
-		inTexture.read(gid + uint2(8, offset)).r,
-		inTexture.read(gid + uint2(9, offset)).r,
-		inTexture.read(gid + uint2(10, offset)).r,
-		inTexture.read(gid + uint2(11, offset)).r,
-		inTexture.read(gid + uint2(12, offset)).r,
-		inTexture.read(gid + uint2(13, offset)).r,
-		inTexture.read(gid + uint2(14, offset)).r,
+	const float2 rawSamples[] = {
+		inTexture.read(gid + uint2(0, offset)).rr,
+		inTexture.read(gid + uint2(1, offset)).rr,
+		inTexture.read(gid + uint2(2, offset)).rr,
+		inTexture.read(gid + uint2(3, offset)).rr,
+		inTexture.read(gid + uint2(4, offset)).rr,
+		inTexture.read(gid + uint2(5, offset)).rr,
+		inTexture.read(gid + uint2(6, offset)).rr,
+		centreSample.rr,
+		inTexture.read(gid + uint2(8, offset)).rr,
+		inTexture.read(gid + uint2(9, offset)).rr,
+		inTexture.read(gid + uint2(10, offset)).rr,
+		inTexture.read(gid + uint2(11, offset)).rr,
+		inTexture.read(gid + uint2(12, offset)).rr,
+		inTexture.read(gid + uint2(13, offset)).rr,
+		inTexture.read(gid + uint2(14, offset)).rr,
 	};
 
 #define Sample(x, y) uniforms.lumaCoefficients[y] * rawSamples[x]
-	const float luminance =
+	const float2 luminance =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
@@ -444,8 +444,8 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 	// TODO: determine why centreSample.a doesn't seem to be giving the real composite amplitude, and stop
 	// hard-coding 0.15f and 7.0f below.
 	outTexture.write(float4(
-			luminance / (1.0f - 0.15f),
-			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance) * 28.0f + float2(0.5f),
+			luminance.r / (1.0f - 0.15f),
+			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance.g) * 28.0f + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From 74d0acdaecb1342eb6befc57339ed2b36fd490a3 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 19:04:17 -0400
Subject: [PATCH 084/131] Fixes non-RGB colour composite generation.

The hard-coded sharpen filter proves to be a really bad fit for the Apple II though.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  4 +-
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 98 +++++++++----------
 2 files changed, 48 insertions(+), 54 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 86ef39bb8..b1b404848 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -604,8 +604,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			// TODO: support separate high-low filters for chroma and luma, rather than treating that as purely subtractive.
 
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
-			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.1f);
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.75f);
+			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.0f);
 
 			const auto lumaCoefficients = lumaPart.get_coefficients();
 			const auto chromaCoefficients = chromaPart.get_coefficients();
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 9f0ee701b..1bb8ea326 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -96,6 +96,11 @@ struct SourceInterpolator {
 	float colourAmplitude [[flat]];
 };
 
+struct CopyInterpolator {
+	float4 position [[position]];
+	float2 textureCoordinates;
+};
+
 // MARK: - Vertex shaders.
 
 float2 textureLocation(constant Line *line, float offset, constant Uniforms &uniforms) {
@@ -210,6 +215,25 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	return result;
 }
 
+vertex CopyInterpolator copyVertex(uint vertexID [[vertex_id]], texture2d<float> texture [[texture(0)]]) {
+	CopyInterpolator vert;
+
+	const uint x = vertexID & 1;
+	const uint y = (vertexID >> 1) & 1;
+
+	vert.textureCoordinates = float2(
+		x * texture.get_width(),
+		y * texture.get_height()
+	);
+	vert.position = float4(
+		float(x) * 2.0 - 1.0,
+		1.0 - float(y) * 2.0,
+		0.0,
+		1.0
+	);
+
+	return vert;
+}
 
 // MARK: - Various input format conversion samplers.
 
@@ -217,20 +241,28 @@ float2 quadrature(float phase) {
 	return float2(cos(phase), sin(phase));
 }
 
+float4 composite(float level, float2 quadrature, float amplitude) {
+	return float4(
+		level,
+		float2(0.5f) + quadrature*0.5f,
+		amplitude
+	);
+}
+
 // There's only one meaningful way to sample the luminance formats.
 
 fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
-	return float4(float3(texture.sample(standardSampler, vert.textureCoordinates).r), 1.0);
+	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
 fragment float4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return float4(float3(texture.sample(standardSampler, vert.textureCoordinates).r), 1.0);
+	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
 fragment float4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	const int offset = int(vert.colourPhase * 4.0);
 	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
-	return float4(float3(sample[offset]), 1.0);
+	return composite(sample[offset], quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
 // The luminance/phase format can produce either composite or S-Video.
@@ -254,12 +286,7 @@ fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], tex
 fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	const float2 luminanceChroma = convertLuminance8Phase8(vert, texture);
 	const float level = mix(luminanceChroma.r, luminanceChroma.g, vert.colourAmplitude);
-	return float4(
-		level,
-		0.5 + 0.5*level*cos(vert.colourPhase),
-		0.5 + 0.5*level*sin(vert.colourPhase),
-		1.0
-	);
+	return composite(level, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
 // All the RGB formats can produce RGB, composite or S-Video.
@@ -309,11 +336,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), float3(0.0f), float3(1.0f));	\
 		const float2 colourSubcarrier = quadrature(vert.colourPhase);	\
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
-		return float4(	\
-			level,	\
-			float2(0.5f) + quadrature(vert.colourPhase)*0.5f,	\
-			vert.colourPhase		\
-		);	\
+		return composite(level, colourSubcarrier, vert.colourAmplitude);	\
 	}
 
 DeclareShaders(Red8Green8Blue8, float)
@@ -321,48 +344,19 @@ DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
 DeclareShaders(Red1Green1Blue1, ushort)
 
-// MARK: - Shaders for copying from a same-sized texture to an MTKView's frame buffer.
-
-struct CopyInterpolator {
-	float4 position [[position]];
-	float2 textureCoordinates;
-};
-
-vertex CopyInterpolator copyVertex(uint vertexID [[vertex_id]], texture2d<float> texture [[texture(0)]]) {
-	CopyInterpolator vert;
-
-	const uint x = vertexID & 1;
-	const uint y = (vertexID >> 1) & 1;
-
-	vert.textureCoordinates = float2(
-		x * texture.get_width(),
-		y * texture.get_height()
-	);
-	vert.position = float4(
-		float(x) * 2.0 - 1.0,
-		1.0 - float(y) * 2.0,
-		0.0,
-		1.0
-	);
-
-	return vert;
-}
-
 fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }
 
+fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+	return texture.sample(linearSampler, vert.textureCoordinates);
+}
+
 fragment float4 clearFragment() {
 	return float4(0.0, 0.0, 0.0, 0.64);
 }
 
-// MARK: -
-
-fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	return texture.sample(linearSampler, vert.textureCoordinates);
-}
-
-// MARK: - Kernel functions
+// MARK: - Compute kernels
 
 /// Given input pixels of the form (luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase)), applies a lowpass
 /// filter to the two chrominance parts, then uses the toRGB matrix to convert to RGB and stores.
@@ -441,11 +435,11 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	// TODO: determine why centreSample.a doesn't seem to be giving the real composite amplitude, and stop
-	// hard-coding 0.15f and 7.0f below.
+	// The mix/steps below ensures that the absence of a colour burst leads the colour subcarrier to be discarded.
+	const float isColour = step(0.01, centreSample.a);
 	outTexture.write(float4(
-			luminance.r / (1.0f - 0.15f),
-			(centreSample.gb - float2(0.5f)) * (centreSample.r - luminance.g) * 28.0f + float2(0.5f),
+			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
+			isColour * (centreSample.gb - float2(0.5f)) * (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour) + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From 5cd8d86eef7cc34485b6a1017a7a666cab629d84 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 20:48:44 -0400
Subject: [PATCH 085/131] Switches to dynamic generation of the 'sharpness'
 filter, correcting issues with the Apple II (amongst others).

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 26 +++++++------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index b1b404848..84e4bbc6c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -575,24 +575,20 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.01f);
 			const auto calculatedChromaCoefficients = chrominancefilter.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
-				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 2.0f);
+				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 3.0f);
 				chromaCoefficients[c].x = 0.0f;
 			}
 			chromaCoefficients[7].x = 1.0f;
 
 			// Luminance will be very soft as a result of the separation phase; apply a sharpen filter to try to undo that.
+			// This is applied separately because the first composite processing step is going to select between the nominal
+			// chroma and luma parts to take the place of luminance depending on whether a colour burst was found, and high-pass
+			// filtering the chrominance channel would be visually detrimental.
+			//
+			// The 30 ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-				constexpr float sharpen[] = {
-					0.0042115543f,
-					0.0f,
-					-0.0641804263f,
-					-0.252418578f,
-					-0.589709163f,
-					0.987914681f,
-					0.627704679f,
-					-0.426862389f,
-					0.627704679f
-				};
+				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 20.0f, colourCyclesPerLine);
+				const auto sharpen = sharpenFilter.get_coefficients();
 				for(size_t c = 0; c < 8; ++c) {
 					chromaCoefficients[c].x = sharpen[c];
 				}
@@ -601,11 +597,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Generate the luminance separation filter.
 		{
-			// TODO: support separate high-low filters for chroma and luma, rather than treating that as purely subtractive.
-
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.75f);
-			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.0f);
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.6f);
+			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.25f);
 
 			const auto lumaCoefficients = lumaPart.get_coefficients();
 			const auto chromaCoefficients = chromaPart.get_coefficients();

From 6bd8ec9545584332820aff8d31c996193124469b Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 20:53:45 -0400
Subject: [PATCH 086/131] Alas, 1.0 seems to be the limit for proper artefact
 colour.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 84e4bbc6c..02ef4f556 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -599,7 +599,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
 			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.6f);
-			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.25f);
+			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.0f);
 
 			const auto lumaCoefficients = lumaPart.get_coefficients();
 			const auto chromaCoefficients = chromaPart.get_coefficients();

From 55e576cc57d1820ef04ab64f11ae09d05c14bab4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 21:10:30 -0400
Subject: [PATCH 087/131] Ensures unpainted areas in composite displays have a
 non-asymptotic effect on luminance calculations.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 02ef4f556..e27306a2a 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -563,7 +563,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_compositionRenderPass.colorAttachments[0].texture = _compositionTexture;
 		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
 		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
-		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 1.0);
+		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 0.3);
 
 		// Create suitable FIR filters.
 		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
@@ -587,7 +587,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The 30 ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 20.0f, colourCyclesPerLine);
+				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
 				const auto sharpen = sharpenFilter.get_coefficients();
 				for(size_t c = 0; c < 8; ++c) {
 					chromaCoefficients[c].x = sharpen[c];

From 489701afcb2516738e701777973e0988bb03f464 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 3 Sep 2020 21:28:39 -0400
Subject: [PATCH 088/131] Fixes window resizing.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 49 +++++++++++++++----
 1 file changed, 39 insertions(+), 10 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index e27306a2a..00dc93bed 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -162,6 +162,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// single buffer. This texture is complete 2d data, copied directly to the display.
 	id<MTLTexture> _frameBuffer;
 	MTLRenderPassDescriptor *_frameBufferRenderPass;	// The render pass for _drawing to_ the frame buffer.
+	BOOL _dontClearFrameBuffer;
 
 	// Textures: the stencil.
 	//
@@ -225,6 +226,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 - (nonnull instancetype)initWithView:(nonnull MTKView *)view {
 	self = [super init];
 	if(self) {
+		_view = view;
 		_commandQueue = [view.device newCommandQueue];
 
 		// Allocate space for uniforms.
@@ -248,10 +250,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_scanTarget.set_line_buffer(reinterpret_cast<BufferingScanTarget::Line *>(_linesBuffer.contents), _lineMetadataBuffer, NumBufferedLines);
 		_scanTarget.set_scan_buffer(reinterpret_cast<BufferingScanTarget::Scan *>(_scansBuffer.contents), NumBufferedScans);
 
-		// Set initial aspect-ratio multiplier.
-		_view = view;
-		[self mtkView:view drawableSizeWillChange:view.drawableSize];
-
 		// Generate copy and clear pipelines.
 		id<MTLLibrary> library = [_view.device newDefaultLibrary];
 		MTLRenderPipelineDescriptor *const pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
@@ -281,6 +279,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Ensure the is-drawing flag is initially clear.
 		_isDrawing.clear();
+
+		// Set initial aspect-ratio multiplier and generate buffers.
+		[self mtkView:view drawableSizeWillChange:view.drawableSize];
 	}
 
 	return self;
@@ -315,6 +316,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		mipmapped:NO];
 	textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
 	textureDescriptor.resourceOptions = MTLResourceStorageModePrivate;
+	id<MTLTexture> _oldFrameBuffer = _frameBuffer;
 	_frameBuffer = [_view.device newTextureWithDescriptor:textureDescriptor];
 
 	MTLTextureDescriptor *const stencilTextureDescriptor = [MTLTextureDescriptor
@@ -345,7 +347,27 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	depthStencilDescriptor.frontFaceStencil.depthStencilPassOperation = MTLStencilOperationReplace;
 	_drawStencilState = [_view.device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
 
-	// TODO: old framebuffer should be resized onto the new one.
+	// Draw from _oldFrameBuffer to _frameBuffer.
+	if(_oldFrameBuffer) {
+		MTLRenderPassDescriptor *const resizeFrameBufferDescriptor = [[MTLRenderPassDescriptor alloc] init];
+		resizeFrameBufferDescriptor.colorAttachments[0].texture = _frameBuffer;
+		resizeFrameBufferDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
+		resizeFrameBufferDescriptor.colorAttachments[0].storeAction = MTLStoreActionStore;
+
+		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+		id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:resizeFrameBufferDescriptor];
+
+		[encoder setRenderPipelineState:_copyPipeline];
+		[encoder setVertexTexture:_oldFrameBuffer atIndex:0];
+		[encoder setFragmentTexture:_oldFrameBuffer atIndex:0];
+
+		[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+		[encoder endEncoding];
+		[commandBuffer commit];
+
+		// Don't clear the framebuffer at the end of this frame.
+		_dontClearFrameBuffer = YES;
+	}
 }
 
 - (void)updateModalBuffers {
@@ -676,7 +698,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// Generate a command encoder for the view.
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:_frameBufferRenderPass];
 
-	// Drawing. Just scans.
 	[encoder setRenderPipelineState:_clearPipeline];
 	[encoder setDepthStencilState:_clearStencilState];
 	[encoder setStencilReferenceValue:0];
@@ -777,10 +798,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 					size_t line = outputArea.start.line;
 					size_t scan = outputArea.start.scan;
 					while(line != outputArea.end.line) {
-						if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+						if(_lineMetadataBuffer[line].is_first_in_frame) {
 							[self outputFrom:scan to:_lineMetadataBuffer[line].first_scan commandBuffer:commandBuffer];
-							[self outputFrameCleanerToCommandBuffer:commandBuffer];
 							scan = _lineMetadataBuffer[line].first_scan;
+
+							if(_lineMetadataBuffer[line].previous_frame_was_complete && !_dontClearFrameBuffer) {
+								[self outputFrameCleanerToCommandBuffer:commandBuffer];
+							}
+							_dontClearFrameBuffer = NO;
 						}
 						line = (line + 1) % NumBufferedLines;
 					}
@@ -850,10 +875,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 					size_t startLine = outputArea.start.line;
 					size_t line = outputArea.start.line;
 					while(line != outputArea.end.line) {
-						if(_lineMetadataBuffer[line].is_first_in_frame && _lineMetadataBuffer[line].previous_frame_was_complete) {
+						if(_lineMetadataBuffer[line].is_first_in_frame) {
 							[self outputFrom:startLine to:line commandBuffer:commandBuffer];
-							[self outputFrameCleanerToCommandBuffer:commandBuffer];
 							startLine = line;
+
+							if(_lineMetadataBuffer[line].previous_frame_was_complete && !_dontClearFrameBuffer) {
+								[self outputFrameCleanerToCommandBuffer:commandBuffer];
+							}
+							_dontClearFrameBuffer = NO;
 						}
 						line = (line + 1) % NumBufferedLines;
 					}

From e99896eadc48dcc95136d9d695a5d2375223cc3f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Fri, 4 Sep 2020 16:07:58 -0400
Subject: [PATCH 089/131] At least nominates alpha, gamma and brightness to
 metal.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 20 +++++++++++++++++--
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  9 +++++++++
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 00dc93bed..3b1316120 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -48,8 +48,12 @@
 	recorded at this point. Format within the composition buffer is:
 
 		.r = composite value
-		.g = phase
-		.b = amplitude
+		.g = 0.5 + 0.5 * cos(phase)
+		.b = 0.5 + 0.5 * sin(phase)
+		.a = amplitude
+
+	[aside: upfront calculation of cos/sin is just because it'll need to be calculated at this precision anyway,
+	and doing it here avoids having to do unit<->radian conversions on phase alone]
 
 	Contents of the composition buffer are transferred to the separated-luma buffer, subject to a low-paass filter
 	that has sought to separate luminance and chrominance, and with phase and amplitude now baked into the latter:
@@ -90,6 +94,7 @@
 
 namespace {
 
+// Tracks the Uniforms struct declared in ScanTarget.metal; see there for field definitions.
 struct Uniforms {
 	int32_t scale[2];
 	float lineWidth;
@@ -102,6 +107,9 @@ struct Uniforms {
 	simd::float2 lumaCoefficients[8];
 	float radiansPerPixel;
 	float cyclesMultiplier;
+	float outputAlpha;
+	float outputGamma;
+	float outputMultiplier;
 };
 
 constexpr size_t NumBufferedLines = 500;
@@ -458,6 +466,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		simd::float3{fromRGB[6], fromRGB[7], fromRGB[8]}
 	);
 
+	// This is fixed for now; consider making it a function of frame rate and/or of whether frame syncing
+	// is ongoing (which would require a way to signal that to this scan target).
+	uniforms()->outputAlpha = 0.64f;
+	uniforms()->outputMultiplier = modals.brightness;
+
+	const float displayGamma = 2.2f;	// This is assumed.
+	uniforms()->outputGamma = displayGamma / modals.intended_gamma;
+
 
 
 	//
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 1bb8ea326..e8958ecef 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -45,6 +45,15 @@ struct Uniforms {
 
 	// Applies a multiplication to all cyclesSinceRetrace values.
 	float cycleMultiplier;
+
+	// Sets the opacity at which output strips are drawn.
+	float outputAlpha;
+
+	// Sets the gamma power to which output colours are raised.
+	float outputGamma;
+
+	// Sets a brightness multiplier for output colours.
+	float outputMultiplier;
 };
 
 namespace {

From 07dcb4dbb1ad10d6179fb31074b9af9b3baf9722 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 7 Sep 2020 18:19:13 -0400
Subject: [PATCH 090/131] Starts reintroducing brightness, gamma and
 transparency for composite and S-Video pipelines.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 57 ++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 60 +++++++++++++++----
 2 files changed, 80 insertions(+), 37 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 3b1316120..aeb9a1ef3 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -378,6 +378,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	}
 }
 
+- (BOOL)shouldApplyGamma {
+	return fabsf(uniforms()->outputGamma - 1.0f) > 0.01f;
+}
+
 - (void)updateModalBuffers {
 	// Build a descriptor for any intermediate line texture.
 	MTLTextureDescriptor *const lineTextureDescriptor = [MTLTextureDescriptor
@@ -409,10 +413,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLLibrary> library = [_view.device newDefaultLibrary];
 	lineTextureDescriptor.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
 
-	// The finalised texture will definitely exist.
+	// The finalised texture will definitely exist, and may or may not require a gamma conversion when written to.
 	if(!_finalisedLineTexture) {
 		_finalisedLineTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
-		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"filterChromaKernel"] error:nil];
+
+		NSString *const kernelFunction = [self shouldApplyGamma] ? @"filterChromaKernelWithGamma" : @"filterChromaKernelNoGamma";
+		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:kernelFunction] error:nil];
 	}
 
 	// A luma separation texture will exist only for composite colour.
@@ -551,29 +557,32 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		/// Fragment shader that outputs directly as monochrome composite.
 		NSString *const directComposite;
+		/// Fragment shader that outputs directly as monochrome composite, with gamma correction.
+		NSString *const directCompositeWithGamma;
 		/// Fragment shader that outputs directly as RGB.
 		NSString *const directRGB;
+		/// Fragment shader that outputs directly as RGB, with gamma correction.
+		NSString *const directRGBWithGamma;
 	};
 	const FragmentSamplerDictionary samplerDictionary[8] = {
-		// Luminance1
-		{@"sampleLuminance1", nullptr, @"sampleLuminance1", nullptr},
-		{@"sampleLuminance8", nullptr, @"sampleLuminance8", nullptr},
-		{@"samplePhaseLinkedLuminance8", nullptr, @"samplePhaseLinkedLuminance8", nullptr},
-		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"compositeSampleLuminance8Phase8", nullptr},
-		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"compositeSampleRed1Green1Blue1", @"sampleRed1Green1Blue1"},
-		{@"compositeSampleRed2Green2Blue2", @"svideoSampleRed2Green2Blue2", @"compositeSampleRed2Green2Blue2", @"sampleRed2Green2Blue2"},
-		{@"compositeSampleRed4Green4Blue4", @"svideoSampleRed4Green4Blue4", @"compositeSampleRed4Green4Blue4", @"sampleRed4Green4Blue4"},
-		{@"compositeSampleRed8Green8Blue8", @"svideoSampleRed8Green8Blue8", @"compositeSampleRed8Green8Blue8", @"sampleRed8Green8Blue8"},
+		{@"compositeSampleLuminance1", nullptr, @"sampleLuminance1", @"sampleLuminance1", nullptr, nullptr},
+		{@"compositeSampleLuminance8", nullptr, @"sampleLuminance8", nullptr},
+		{@"compositeSamplePhaseLinkedLuminance8", nullptr, @"samplePhaseLinkedLuminance8", nullptr},
+		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"compositeSampleLuminance8Phase8", nullptr, nullptr, nullptr},
+		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"compositeSampleRed1Green1Blue1", nullptr, @"sampleRed1Green1Blue1", nullptr},
+		{@"compositeSampleRed2Green2Blue2", @"svideoSampleRed2Green2Blue2", @"compositeSampleRed2Green2Blue2", nullptr, @"sampleRed2Green2Blue2", nullptr},
+		{@"compositeSampleRed4Green4Blue4", @"svideoSampleRed4Green4Blue4", @"compositeSampleRed4Green4Blue4", nullptr, @"sampleRed4Green4Blue4", nullptr},
+		{@"compositeSampleRed8Green8Blue8", @"svideoSampleRed8Green8Blue8", @"compositeSampleRed8Green8Blue8", nullptr, @"sampleRed8Green8Blue8", nullptr},
 	};
 
 #ifndef NDEBUG
 	// Do a quick check of the names entered above. I don't think this is possible at compile time.
-	for(int c = 0; c < 8; ++c) {
-		if(samplerDictionary[c].compositionComposite)	assert([library newFunctionWithName:samplerDictionary[c].compositionComposite]);
-		if(samplerDictionary[c].compositionSVideo)		assert([library newFunctionWithName:samplerDictionary[c].compositionSVideo]);
-		if(samplerDictionary[c].directComposite)		assert([library newFunctionWithName:samplerDictionary[c].directComposite]);
-		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
-	}
+//	for(int c = 0; c < 8; ++c) {
+//		if(samplerDictionary[c].compositionComposite)	assert([library newFunctionWithName:samplerDictionary[c].compositionComposite]);
+//		if(samplerDictionary[c].compositionSVideo)		assert([library newFunctionWithName:samplerDictionary[c].compositionSVideo]);
+//		if(samplerDictionary[c].directComposite)		assert([library newFunctionWithName:samplerDictionary[c].directComposite]);
+//		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
+//	}
 #endif
 
 	uniforms()->cyclesMultiplier = 1.0f;
@@ -625,19 +634,19 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The 30 ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
-				const auto sharpen = sharpenFilter.get_coefficients();
-				for(size_t c = 0; c < 8; ++c) {
-					chromaCoefficients[c].x = sharpen[c];
-				}
+//				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
+//				const auto sharpen = sharpenFilter.get_coefficients();
+//				for(size_t c = 0; c < 8; ++c) {
+//					chromaCoefficients[c].x = sharpen[c];
+//				}
 			}
 		}
 
 		// Generate the luminance separation filter.
 		{
 			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.6f);
-			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 1.0f);
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 80.0f, colourCyclesPerLine * 0.6f);
+			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
 
 			const auto lumaCoefficients = lumaPart.get_coefficients();
 			const auto chromaCoefficients = chromaPart.get_coefficients();
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index e8958ecef..462e2f304 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -258,17 +258,28 @@ float4 composite(float level, float2 quadrature, float amplitude) {
 	);
 }
 
-// There's only one meaningful way to sample the luminance formats.
+// The luminance formats can be sampled either in their natural format, or to the intermediate
+// composite format used for composition. Direct sampling is always for final output, so the two
+// 8-bit formats also provide a gamma option.
 
-fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	const float luminance = clamp(float(texture.sample(standardSampler, vert.textureCoordinates).r), 0.0f, 1.0f) * uniforms.outputMultiplier;
+	return float4(float3(luminance), uniforms.outputAlpha);
+}
+
+fragment float4 compositeSampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
 	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
-fragment float4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment float4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	return float4(texture.sample(standardSampler, vert.textureCoordinates).rrr * uniforms.outputMultiplier, uniforms.outputAlpha);
+}
+
+fragment float4 compositeSampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
-fragment float4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment float4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
 	const int offset = int(vert.colourPhase * 4.0);
 	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
 	return composite(sample[offset], quadrature(vert.colourPhase), vert.colourAmplitude);
@@ -369,14 +380,14 @@ fragment float4 clearFragment() {
 
 /// Given input pixels of the form (luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase)), applies a lowpass
 /// filter to the two chrominance parts, then uses the toRGB matrix to convert to RGB and stores.
-kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
-								texture2d<float, access::write> outTexture [[texture(1)]],
-								uint2 gid [[thread_position_in_grid]],
-								constant Uniforms &uniforms [[buffer(0)]],
-								constant int &offset [[buffer(1)]]) {
+template <bool applyGamma> void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
+													texture2d<float, access::write> outTexture [[texture(1)]],
+													uint2 gid [[thread_position_in_grid]],
+													constant Uniforms &uniforms [[buffer(0)]],
+													constant int &offset [[buffer(1)]]) {
 	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
 	const float4 rawSamples[] = {
-		inTexture.read(gid + uint2(0, offset))  - moveToZero,
+		inTexture.read(gid + uint2(0, offset)) - moveToZero,
 		inTexture.read(gid + uint2(1, offset)) - moveToZero,
 		inTexture.read(gid + uint2(2, offset)) - moveToZero,
 		inTexture.read(gid + uint2(3, offset)) - moveToZero,
@@ -400,7 +411,28 @@ kernel void filterChromaKernel(	texture2d<float, access::read> inTexture [[textu
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	outTexture.write(float4(uniforms.toRGB * colour, 1.0f), gid + uint2(7, offset));
+	const float4 output = float4(uniforms.toRGB * colour * uniforms.outputMultiplier, uniforms.outputAlpha);
+	if(applyGamma) {
+		outTexture.write(pow(output, uniforms.outputGamma), gid + uint2(7, offset));
+	} else {
+		outTexture.write(output, gid + uint2(7, offset));
+	}
+}
+
+kernel void filterChromaKernelNoGamma(texture2d<float, access::read> inTexture [[texture(0)]],
+													texture2d<float, access::write> outTexture [[texture(1)]],
+													uint2 gid [[thread_position_in_grid]],
+													constant Uniforms &uniforms [[buffer(0)]],
+													constant int &offset [[buffer(1)]]) {
+	filterChromaKernel<false>(inTexture, outTexture, gid, uniforms, offset);
+}
+
+kernel void filterChromaKernelWithGamma(texture2d<float, access::read> inTexture [[texture(0)]],
+													texture2d<float, access::write> outTexture [[texture(1)]],
+													uint2 gid [[thread_position_in_grid]],
+													constant Uniforms &uniforms [[buffer(0)]],
+													constant int &offset [[buffer(1)]]) {
+	filterChromaKernel<true>(inTexture, outTexture, gid, uniforms, offset);
 }
 
 /// Given input pixels of the form:
@@ -446,9 +478,11 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 
 	// The mix/steps below ensures that the absence of a colour burst leads the colour subcarrier to be discarded.
 	const float isColour = step(0.01, centreSample.a);
+	const float chroma = (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour);
 	outTexture.write(float4(
-			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
-			isColour * (centreSample.gb - float2(0.5f)) * (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour) + float2(0.5f),
+//			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
+			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
+			isColour * (centreSample.gb - float2(0.5f)) * chroma + float2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From de6ed7b61501c335018320a6b2621b2bb0c14808 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 7 Sep 2020 20:53:28 -0400
Subject: [PATCH 091/131] Corrects phase-linked luminance support.

---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 462e2f304..86fca8550 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -101,7 +101,8 @@ struct Line {
 struct SourceInterpolator {
 	float4 position [[position]];
 	float2 textureCoordinates;
-	float colourPhase;
+	float unitColourPhase;		// i.e. one unit per circle.
+	float colourPhase;			// i.e. 2*pi units per circle, just regular radians.
 	float colourAmplitude [[flat]];
 };
 
@@ -147,11 +148,12 @@ template <typename Input> SourceInterpolator toDisplay(
 
 	// Load up the colour details.
 	output.colourAmplitude = float(inputs[instanceID].compositeAmplitude) / 255.0f;
-	output.colourPhase = 3.141592654f * mix(
+	output.unitColourPhase = mix(
 		float(inputs[instanceID].endPoints[0].compositeAngle),
 		float(inputs[instanceID].endPoints[1].compositeAngle),
 		float((vertexID&2) >> 1)
-	) / 32.0f;
+	) / 64.0f;
+	output.colourPhase = 2.0f * 3.141592654f * output.unitColourPhase;
 
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
 
@@ -208,11 +210,12 @@ vertex SourceInterpolator scanToComposition(	constant Uniforms &uniforms [[buffe
 	result.textureCoordinates.x = mix(scans[instanceID].endPoints[0].dataOffset, scans[instanceID].endPoints[1].dataOffset, float(vertexID));
 	result.textureCoordinates.y = scans[instanceID].dataY;
 
-	result.colourPhase = 3.141592654f * mix(
+	result.unitColourPhase = mix(
 		float(scans[instanceID].endPoints[0].compositeAngle),
 		float(scans[instanceID].endPoints[1].compositeAngle),
 		float(vertexID)
-	) / 32.0f;
+	) / 64.0f;
+	result.colourPhase = 2.0f * 3.141592654f * result.unitColourPhase;
 	result.colourAmplitude = float(scans[instanceID].compositeAmplitude) / 255.0f;
 
 	// Map position into eye space, allowing for target texture dimensions.
@@ -280,9 +283,10 @@ fragment float4 compositeSampleLuminance8(SourceInterpolator vert [[stage_in]],
 }
 
 fragment float4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	const int offset = int(vert.colourPhase * 4.0);
+	const int offset = int(vert.unitColourPhase * 4.0f) & 3;
+	const float snappedColourPhase = float(offset) * (0.5f * 3.141592654f);	// TODO: plus machine-supplied offset.
 	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
-	return composite(sample[offset], quadrature(vert.colourPhase), vert.colourAmplitude);
+	return composite(sample[offset], quadrature(snappedColourPhase), vert.colourAmplitude);
 }
 
 // The luminance/phase format can produce either composite or S-Video.
@@ -480,8 +484,8 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 	const float isColour = step(0.01, centreSample.a);
 	const float chroma = (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour);
 	outTexture.write(float4(
-//			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
-			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
+			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
+//			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
 			isColour * (centreSample.gb - float2(0.5f)) * chroma + float2(0.5f),
 			1.0f
 		),

From 6adad7fbf54792dce8b66b9532abd5ac88b49e41 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 7 Sep 2020 22:47:49 -0400
Subject: [PATCH 092/131] Starts experimenting again with box filters.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 62 ++++++++++++++-----
 1 file changed, 45 insertions(+), 17 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index aeb9a1ef3..0c731be88 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -135,6 +135,35 @@ constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheM
 		}	\
 	}
 
+std::array<float, 8> boxCoefficients(float radiansPerPixel, float cutoff) {
+	std::array<float, 8> filter;
+	float total = 0.0f;
+
+	for(size_t c = 0; c < 8; ++c) {
+		// This coefficient occupies the angular window [6.5-c, 7.5-c]*radiansPerPixel.
+		const float startAngle = (6.5f - float(c)) * radiansPerPixel;
+		const float endAngle = (7.5f - float(c)) * radiansPerPixel;
+
+		float coefficient = 0.0f;
+		if(endAngle < cutoff) {
+			coefficient = 1.0f;
+		} else if(startAngle >= cutoff) {
+			coefficient = 0.0f;
+		} else {
+			coefficient = (cutoff - startAngle) / radiansPerPixel;
+		}
+		total += 2.0f * coefficient;	// All but the centre coefficient will be used twice.
+		filter[c] = coefficient;
+	}
+	total = (total - filter[7]) / 2.0f;	// As per above; ensure the centre coefficient is counted only once.
+
+	for(size_t c = 0; c < 8; ++c) {
+		filter[c] /= total;
+	}
+
+	return filter;
+}
+
 }
 
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
@@ -616,23 +645,25 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
+		// Store radians per pixel. TODO: is this now orphaned as a uniform? Should I keep it anyway?
+		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
+
 		// Generate the chrominance filter.
 		{
-			auto *const chromaCoefficients = uniforms()->chromaCoefficients;
-			SignalProcessing::FIRFilter chrominancefilter(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.01f);
-			const auto calculatedChromaCoefficients = chrominancefilter.get_coefficients();
+			auto *const firCoefficients = uniforms()->chromaCoefficients;
+			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
 			for(size_t c = 0; c < 8; ++c) {
-				chromaCoefficients[c].y = chromaCoefficients[c].z = calculatedChromaCoefficients[c] * (isSVideoOutput ? 4.0f : 3.0f);
-				chromaCoefficients[c].x = 0.0f;
+				firCoefficients[c].y = firCoefficients[c].z = chromaCoefficients[c] / 2.0f;
+				firCoefficients[c].x = 0.0f;
 			}
-			chromaCoefficients[7].x = 1.0f;
+			firCoefficients[7].x = 1.0f;
 
 			// Luminance will be very soft as a result of the separation phase; apply a sharpen filter to try to undo that.
 			// This is applied separately because the first composite processing step is going to select between the nominal
 			// chroma and luma parts to take the place of luminance depending on whether a colour burst was found, and high-pass
 			// filtering the chrominance channel would be visually detrimental.
 			//
-			// The 30 ['Hz' but per line, not per second] is somewhat arbitrary.
+			// The low cut off ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
 //				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
 //				const auto sharpen = sharpenFilter.get_coefficients();
@@ -644,20 +675,17 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Generate the luminance separation filter.
 		{
-			auto *const luminanceCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 80.0f, colourCyclesPerLine * 0.6f);
-			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine);
+			auto *const firCoefficients = uniforms()->lumaCoefficients;
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.6f);
+//			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
 
-			const auto lumaCoefficients = lumaPart.get_coefficients();
-			const auto chromaCoefficients = chromaPart.get_coefficients();
+			const auto chromaCoefficients = lumaPart.get_coefficients();
+			const auto lumaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);//chromaPart.get_coefficients();
 			for(size_t c = 0; c < 8; ++c) {
-				luminanceCoefficients[c].x = lumaCoefficients[c];
-				luminanceCoefficients[c].y = chromaCoefficients[c];
+				firCoefficients[c].x = lumaCoefficients[c];
+				firCoefficients[c].y = chromaCoefficients[c];
 			}
 		}
-
-		// Store radians per pixel. TODO: is this now orphaned? Should I keep it anyway?
-		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
 	}
 
 	// Build the output pipeline.

From 0e44d6d2146aa6e52a1c5f8de79da73f6a9aa080 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 16:19:08 -0400
Subject: [PATCH 093/131] Experiments with an all-box filter.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 24 ++++++++++++-------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  5 ++--
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 0c731be88..510bc9717 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -135,6 +135,8 @@ constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheM
 		}	\
 	}
 
+/// @returns the proper 1d kernel to apply a box filter around a certain point a pixel density of @c radiansPerPixel and applying an
+///		angular limit of @c cutoff. The values returned will be the first eight of a fifteen-point filter that is symmetrical around its centre.
 std::array<float, 8> boxCoefficients(float radiansPerPixel, float cutoff) {
 	std::array<float, 8> filter;
 	float total = 0.0f;
@@ -155,7 +157,7 @@ std::array<float, 8> boxCoefficients(float radiansPerPixel, float cutoff) {
 		total += 2.0f * coefficient;	// All but the centre coefficient will be used twice.
 		filter[c] = coefficient;
 	}
-	total = (total - filter[7]) / 2.0f;	// As per above; ensure the centre coefficient is counted only once.
+	total = total - filter[7];			// As per above; ensure the centre coefficient is counted only once.
 
 	for(size_t c = 0; c < 8; ++c) {
 		filter[c] /= total;
@@ -651,9 +653,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the chrominance filter.
 		{
 			auto *const firCoefficients = uniforms()->chromaCoefficients;
-			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
+			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f * 0.5f);
 			for(size_t c = 0; c < 8; ++c) {
-				firCoefficients[c].y = firCoefficients[c].z = chromaCoefficients[c] / 2.0f;
+				firCoefficients[c].y = firCoefficients[c].z = (isSVideoOutput ? 2.0f : 1.0f) * chromaCoefficients[c];
 				firCoefficients[c].x = 0.0f;
 			}
 			firCoefficients[7].x = 1.0f;
@@ -665,10 +667,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The low cut off ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-//				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
+//				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 80.0f, colourCyclesPerLine * 0.5f);
 //				const auto sharpen = sharpenFilter.get_coefficients();
 //				for(size_t c = 0; c < 8; ++c) {
-//					chromaCoefficients[c].x = sharpen[c];
+//					firCoefficients[c].x = firCoefficients[c].y;
+//					firCoefficients[c].x = sharpen[c];
 //				}
 			}
 		}
@@ -676,13 +679,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the luminance separation filter.
 		{
 			auto *const firCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.6f);
+			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
 //			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
 
-			const auto chromaCoefficients = lumaPart.get_coefficients();
-			const auto lumaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);//chromaPart.get_coefficients();
+//			const auto chromaCoefficients = lumaPart.get_coefficients();
+//			const auto lumaCoefficients = lumaPart.get_coefficients();
+			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);//chromaPart.get_coefficients();
+			const auto lumaCoefficients = lumaPart.get_coefficients();
+//			const auto chromaCoefficients = lumaCoefficients;
 			for(size_t c = 0; c < 8; ++c) {
-				firCoefficients[c].x = lumaCoefficients[c];
+				firCoefficients[c].x = //lumaCoefficients[c];
 				firCoefficients[c].y = chromaCoefficients[c];
 			}
 		}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 86fca8550..98f6df2f0 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -484,8 +484,9 @@ kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[textu
 	const float isColour = step(0.01, centreSample.a);
 	const float chroma = (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour);
 	outTexture.write(float4(
-			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
-//			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
+//			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
+			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
+//			luminance.r,
 			isColour * (centreSample.gb - float2(0.5f)) * chroma + float2(0.5f),
 			1.0f
 		),

From c49fcb9ec90bc79b2d67edc1c760c1dfc9355ce0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 16:35:05 -0400
Subject: [PATCH 094/131] Based on further play: one box filter to separate
 luma/chroma, another to filter chroma, plus a FIR sharpen on luma.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm       | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 510bc9717..3e6f858b8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -667,12 +667,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The low cut off ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-//				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 80.0f, colourCyclesPerLine * 0.5f);
-//				const auto sharpen = sharpenFilter.get_coefficients();
-//				for(size_t c = 0; c < 8; ++c) {
-//					firCoefficients[c].x = firCoefficients[c].y;
-//					firCoefficients[c].x = sharpen[c];
-//				}
+				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
+				const auto sharpen = sharpenFilter.get_coefficients();
+				for(size_t c = 0; c < 8; ++c) {
+					firCoefficients[c].x = sharpen[c];
+				}
 			}
 		}
 

From 06b7ea5a6e55bd01a6dcfb36076255936b32b6ae Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 19:15:19 -0400
Subject: [PATCH 095/131] Strips the luma kernel back to 1d.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 54 ++++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 58 +++++++++----------
 2 files changed, 67 insertions(+), 45 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 3e6f858b8..1b320a09d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -12,6 +12,7 @@
 
 #include <algorithm>
 #include <atomic>
+#include <cmath>
 
 #include "BufferingScanTarget.hpp"
 #include "FIRFilter.hpp"
@@ -104,7 +105,7 @@ struct Uniforms {
 	float zoom;
 	simd::float2 offset;
 	simd::float3 chromaCoefficients[8];
-	simd::float2 lumaCoefficients[8];
+	float lumaKernel[8];
 	float radiansPerPixel;
 	float cyclesMultiplier;
 	float outputAlpha;
@@ -166,6 +167,30 @@ std::array<float, 8> boxCoefficients(float radiansPerPixel, float cutoff) {
 	return filter;
 }
 
+/// @returns the IEEE 754 binary16 conversion of @c value, stored in a 16-bit int.
+uint16_t half(float value) {
+	uint16_t result = 0;
+
+	if(value < 0) {
+		result |= 0x8000;
+		value = -value;
+	}
+
+	int exponent;
+	const float mantissa = frexpf(value, &exponent);
+
+	// There is a bias of 15 on the exponent; given that the value given by frexp doesn't have the
+	// implicit first bit — that'll be masked off below — that's like a bias of 14 versus the output
+	// of frexp.
+	exponent += 14;
+	result |= (exponent & 31) << 10;
+
+	// Also store the mantissa.
+	result |= uint16_t(mantissa * 2048.0f) & 0x3ff;
+
+	return result;
+}
+
 }
 
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
@@ -258,6 +283,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	BufferingScanTarget::LineMetadata _lineMetadataBuffer[NumBufferedLines];
 	std::atomic_flag _isDrawing;
 
+	// Additional pipeline information.
+	size_t _lumaKernelSize;
+
 	// The output view.
 	__weak MTKView *_view;
 }
@@ -653,7 +681,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the chrominance filter.
 		{
 			auto *const firCoefficients = uniforms()->chromaCoefficients;
-			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f * 0.5f);
+			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
 			for(size_t c = 0; c < 8; ++c) {
 				firCoefficients[c].y = firCoefficients[c].z = (isSVideoOutput ? 2.0f : 1.0f) * chromaCoefficients[c];
 				firCoefficients[c].x = 0.0f;
@@ -667,7 +695,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The low cut off ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
+				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 20.0f, colourCyclesPerLine);
 				const auto sharpen = sharpenFilter.get_coefficients();
 				for(size_t c = 0; c < 8; ++c) {
 					firCoefficients[c].x = sharpen[c];
@@ -675,20 +703,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			}
 		}
 
-		// Generate the luminance separation filter.
+		// Generate the luminance separation filter and determine its required size.
 		{
-			auto *const firCoefficients = uniforms()->lumaCoefficients;
-			SignalProcessing::FIRFilter lumaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
-//			SignalProcessing::FIRFilter chromaPart(15, float(_lineBufferPixelsPerLine), 0.0f, colourCyclesPerLine * 0.5f);
-
-//			const auto chromaCoefficients = lumaPart.get_coefficients();
-//			const auto lumaCoefficients = lumaPart.get_coefficients();
-			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);//chromaPart.get_coefficients();
-			const auto lumaCoefficients = lumaPart.get_coefficients();
-//			const auto chromaCoefficients = lumaCoefficients;
+			auto *const filter = uniforms()->lumaKernel;
+			const auto coefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
+			_lumaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
-				firCoefficients[c].x = //lumaCoefficients[c];
-				firCoefficients[c].y = chromaCoefficients[c];
+				filter[c] = coefficients[c];
+				if(coefficients[c] < 0.01f) {
+					_lumaKernelSize -= 2;
+				}
 			}
 		}
 	}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 98f6df2f0..70e6eb5f2 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -36,9 +36,9 @@ struct Uniforms {
 	// 15 coefficients but they're symmetrical around the centre.
 	float3 chromaCoefficients[8];
 
-	// Describes the FIR filter in use for luma filtering; also 15 coefficients
+	// Describes the filter in use for luma filtering; 15 coefficients
 	// symmetrical around the centre.
-	float2 lumaCoefficients[8];
+	float lumaKernel[8];
 
 	// Maps from pixel offsets into the composition buffer to angular difference.
 	float radiansPerPixel;
@@ -449,45 +449,43 @@ kernel void filterChromaKernelWithGamma(texture2d<float, access::read> inTexture
 ///	(luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase))
 ///
 /// i.e. the input form for the filterChromaKernel, above].
-kernel void separateLumaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
-								texture2d<float, access::write> outTexture [[texture(1)]],
+kernel void separateLumaKernel(	texture2d<half, access::read> inTexture [[texture(0)]],
+								texture2d<half, access::write> outTexture [[texture(1)]],
 								uint2 gid [[thread_position_in_grid]],
 								constant Uniforms &uniforms [[buffer(0)]],
 								constant int &offset [[buffer(1)]]) {
-	const float4 centreSample = inTexture.read(gid + uint2(7, offset));
-	const float2 rawSamples[] = {
-		inTexture.read(gid + uint2(0, offset)).rr,
-		inTexture.read(gid + uint2(1, offset)).rr,
-		inTexture.read(gid + uint2(2, offset)).rr,
-		inTexture.read(gid + uint2(3, offset)).rr,
-		inTexture.read(gid + uint2(4, offset)).rr,
-		inTexture.read(gid + uint2(5, offset)).rr,
-		inTexture.read(gid + uint2(6, offset)).rr,
-		centreSample.rr,
-		inTexture.read(gid + uint2(8, offset)).rr,
-		inTexture.read(gid + uint2(9, offset)).rr,
-		inTexture.read(gid + uint2(10, offset)).rr,
-		inTexture.read(gid + uint2(11, offset)).rr,
-		inTexture.read(gid + uint2(12, offset)).rr,
-		inTexture.read(gid + uint2(13, offset)).rr,
-		inTexture.read(gid + uint2(14, offset)).rr,
+	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const half rawSamples[] = {
+		inTexture.read(gid + uint2(0, offset)).r,
+		inTexture.read(gid + uint2(1, offset)).r,
+		inTexture.read(gid + uint2(2, offset)).r,
+		inTexture.read(gid + uint2(3, offset)).r,
+		inTexture.read(gid + uint2(4, offset)).r,
+		inTexture.read(gid + uint2(5, offset)).r,
+		inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,
+		inTexture.read(gid + uint2(9, offset)).r,
+		inTexture.read(gid + uint2(10, offset)).r,
+		inTexture.read(gid + uint2(11, offset)).r,
+		inTexture.read(gid + uint2(12, offset)).r,
+		inTexture.read(gid + uint2(13, offset)).r,
+		inTexture.read(gid + uint2(14, offset)).r,
 	};
 
-#define Sample(x, y) uniforms.lumaCoefficients[y] * rawSamples[x]
-	const float2 luminance =
+#define Sample(x, y) half(uniforms.lumaKernel[y]) * rawSamples[x]
+	const half luminance =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
 	// The mix/steps below ensures that the absence of a colour burst leads the colour subcarrier to be discarded.
-	const float isColour = step(0.01, centreSample.a);
-	const float chroma = (centreSample.r - luminance.g) / mix(1.0f, centreSample.a, isColour);
-	outTexture.write(float4(
-//			mix(luminance.g, luminance.r / (1.0f - centreSample.a), isColour),
-			luminance.r / mix(1.0f, (1.0f - centreSample.a), isColour),
-//			luminance.r,
-			isColour * (centreSample.gb - float2(0.5f)) * chroma + float2(0.5f),
+	const half isColour = step(half(0.01f), centreSample.a);
+	const half chroma = (centreSample.r - luminance) / mix(half(1.0f), centreSample.a, isColour);
+	outTexture.write(half4(
+			luminance / mix(half(1.0f), (half(1.0f) - centreSample.a), isColour),
+			isColour * (centreSample.gb - half2(0.5f)) * chroma + half2(0.5f),
 			1.0f
 		),
 		gid + uint2(7, offset));

From c82e0df0715cee6c9f8653c99ccf723db80b188b Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 19:37:36 -0400
Subject: [PATCH 096/131] Starts a transition towards half-precision
 arithmetic.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 28 +-------------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 38 +++++++++----------
 2 files changed, 21 insertions(+), 45 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 1b320a09d..0c74d79da 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -105,7 +105,7 @@ struct Uniforms {
 	float zoom;
 	simd::float2 offset;
 	simd::float3 chromaCoefficients[8];
-	float lumaKernel[8];
+	__fp16 lumaKernel[8];
 	float radiansPerPixel;
 	float cyclesMultiplier;
 	float outputAlpha;
@@ -167,30 +167,6 @@ std::array<float, 8> boxCoefficients(float radiansPerPixel, float cutoff) {
 	return filter;
 }
 
-/// @returns the IEEE 754 binary16 conversion of @c value, stored in a 16-bit int.
-uint16_t half(float value) {
-	uint16_t result = 0;
-
-	if(value < 0) {
-		result |= 0x8000;
-		value = -value;
-	}
-
-	int exponent;
-	const float mantissa = frexpf(value, &exponent);
-
-	// There is a bias of 15 on the exponent; given that the value given by frexp doesn't have the
-	// implicit first bit — that'll be masked off below — that's like a bias of 14 versus the output
-	// of frexp.
-	exponent += 14;
-	result |= (exponent & 31) << 10;
-
-	// Also store the mantissa.
-	result |= uint16_t(mantissa * 2048.0f) & 0x3ff;
-
-	return result;
-}
-
 }
 
 using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
@@ -709,7 +685,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			const auto coefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
 			_lumaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
-				filter[c] = coefficients[c];
+				filter[c] = __fp16(coefficients[c]);
 				if(coefficients[c] < 0.01f) {
 					_lumaKernelSize -= 2;
 				}
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 70e6eb5f2..72622e15c 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -38,7 +38,7 @@ struct Uniforms {
 
 	// Describes the filter in use for luma filtering; 15 coefficients
 	// symmetrical around the centre.
-	float lumaKernel[8];
+	half lumaKernel[8];
 
 	// Maps from pixel offsets into the composition buffer to angular difference.
 	float radiansPerPixel;
@@ -384,13 +384,13 @@ fragment float4 clearFragment() {
 
 /// Given input pixels of the form (luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase)), applies a lowpass
 /// filter to the two chrominance parts, then uses the toRGB matrix to convert to RGB and stores.
-template <bool applyGamma> void filterChromaKernel(	texture2d<float, access::read> inTexture [[texture(0)]],
-													texture2d<float, access::write> outTexture [[texture(1)]],
+template <bool applyGamma> void filterChromaKernel(	texture2d<half, access::read> inTexture [[texture(0)]],
+													texture2d<half, access::write> outTexture [[texture(1)]],
 													uint2 gid [[thread_position_in_grid]],
 													constant Uniforms &uniforms [[buffer(0)]],
 													constant int &offset [[buffer(1)]]) {
-	constexpr float4 moveToZero = float4(0.0f, 0.5f, 0.5f, 0.0f);
-	const float4 rawSamples[] = {
+	constexpr half4 moveToZero(0.0f, 0.5f, 0.5f, 0.0f);
+	const half4 rawSamples[] = {
 		inTexture.read(gid + uint2(0, offset)) - moveToZero,
 		inTexture.read(gid + uint2(1, offset)) - moveToZero,
 		inTexture.read(gid + uint2(2, offset)) - moveToZero,
@@ -408,14 +408,14 @@ template <bool applyGamma> void filterChromaKernel(	texture2d<float, access::rea
 		inTexture.read(gid + uint2(14, offset)) - moveToZero,
 	};
 
-#define Sample(x, y) uniforms.chromaCoefficients[y] * rawSamples[x].rgb
-	const float3 colour =
+#define Sample(x, y) half3(uniforms.chromaCoefficients[y]) * rawSamples[x].rgb
+	const half3 colour =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	const float4 output = float4(uniforms.toRGB * colour * uniforms.outputMultiplier, uniforms.outputAlpha);
+	const half4 output = half4(half3x3(uniforms.toRGB) * colour * half(uniforms.outputMultiplier), half(uniforms.outputAlpha));
 	if(applyGamma) {
 		outTexture.write(pow(output, uniforms.outputGamma), gid + uint2(7, offset));
 	} else {
@@ -423,19 +423,19 @@ template <bool applyGamma> void filterChromaKernel(	texture2d<float, access::rea
 	}
 }
 
-kernel void filterChromaKernelNoGamma(texture2d<float, access::read> inTexture [[texture(0)]],
-													texture2d<float, access::write> outTexture [[texture(1)]],
-													uint2 gid [[thread_position_in_grid]],
-													constant Uniforms &uniforms [[buffer(0)]],
-													constant int &offset [[buffer(1)]]) {
+kernel void filterChromaKernelNoGamma(	texture2d<half, access::read> inTexture [[texture(0)]],
+										texture2d<half, access::write> outTexture [[texture(1)]],
+										uint2 gid [[thread_position_in_grid]],
+										constant Uniforms &uniforms [[buffer(0)]],
+										constant int &offset [[buffer(1)]]) {
 	filterChromaKernel<false>(inTexture, outTexture, gid, uniforms, offset);
 }
 
-kernel void filterChromaKernelWithGamma(texture2d<float, access::read> inTexture [[texture(0)]],
-													texture2d<float, access::write> outTexture [[texture(1)]],
-													uint2 gid [[thread_position_in_grid]],
-													constant Uniforms &uniforms [[buffer(0)]],
-													constant int &offset [[buffer(1)]]) {
+kernel void filterChromaKernelWithGamma(	texture2d<half, access::read> inTexture [[texture(0)]],
+											texture2d<half, access::write> outTexture [[texture(1)]],
+											uint2 gid [[thread_position_in_grid]],
+											constant Uniforms &uniforms [[buffer(0)]],
+											constant int &offset [[buffer(1)]]) {
 	filterChromaKernel<true>(inTexture, outTexture, gid, uniforms, offset);
 }
 
@@ -473,7 +473,7 @@ kernel void separateLumaKernel(	texture2d<half, access::read> inTexture [[textur
 		inTexture.read(gid + uint2(14, offset)).r,
 	};
 
-#define Sample(x, y) half(uniforms.lumaKernel[y]) * rawSamples[x]
+#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
 	const half luminance =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +

From dda1649ab7b9614e8c8a1f575985f205fc6b9a6c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 19:55:37 -0400
Subject: [PATCH 097/131] Introduces smaller luma kernel functions where
 useable.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  51 +++---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 151 +++++++++++++-----
 2 files changed, 142 insertions(+), 60 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 0c74d79da..259a386ae 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -460,7 +460,18 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	if(_pipeline == Pipeline::CompositeColour) {
 		if(!_separatedLumaTexture) {
 			_separatedLumaTexture = [_view.device newTextureWithDescriptor:lineTextureDescriptor];
-			_separatedLumaState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"separateLumaKernel"] error:nil];
+
+			NSString *kernelFunction;
+			switch(_lumaKernelSize) {
+				default:	kernelFunction = @"separateLumaKernel15";	break;
+				case 9:		kernelFunction = @"separateLumaKernel9";	break;
+				case 7:		kernelFunction = @"separateLumaKernel7";	break;
+				case 1:
+				case 3:
+				case 5:		kernelFunction = @"separateLumaKernel5";	break;
+			}
+
+			_separatedLumaState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:kernelFunction] error:nil];
 		}
 	} else {
 		_separatedLumaTexture = nil;
@@ -580,9 +591,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_pipeline = isSVideoOutput ? Pipeline::SVideo : Pipeline::CompositeColour;
 	}
 
-	// Update intermediate storage.
-	[self updateModalBuffers];
-
 	// TODO: factor in gamma, which may or may not be a factor (it isn't for 1-bit formats).
 	struct FragmentSamplerDictionary {
 		/// Fragment shader that outputs to the composition buffer for composite processing.
@@ -633,21 +641,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			}
 		}
 
-		// Create the composition render pass.
- 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
-		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
-		pipelineDescriptor.fragmentFunction =
-			[library newFunctionWithName:isSVideoOutput ? samplerDictionary[int(modals.input_data_type)].compositionSVideo : samplerDictionary[int(modals.input_data_type)].compositionComposite];
-
-		_composePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
-
-		_compositionRenderPass = [[MTLRenderPassDescriptor alloc] init];
-		_compositionRenderPass.colorAttachments[0].texture = _compositionTexture;
-		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
-		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
-		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 0.3);
-
-		// Create suitable FIR filters.
+		// Create suitable filters.
 		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
@@ -693,6 +687,25 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		}
 	}
 
+	// Update intermediate storage.
+	[self updateModalBuffers];
+
+	if(_pipeline != Pipeline::DirectToDisplay) {
+		// Create the composition render pass.
+ 		pipelineDescriptor.colorAttachments[0].pixelFormat = _compositionTexture.pixelFormat;
+		pipelineDescriptor.vertexFunction = [library newFunctionWithName:@"scanToComposition"];
+		pipelineDescriptor.fragmentFunction =
+			[library newFunctionWithName:isSVideoOutput ? samplerDictionary[int(modals.input_data_type)].compositionSVideo : samplerDictionary[int(modals.input_data_type)].compositionComposite];
+
+		_composePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
+		_compositionRenderPass = [[MTLRenderPassDescriptor alloc] init];
+		_compositionRenderPass.colorAttachments[0].texture = _compositionTexture;
+		_compositionRenderPass.colorAttachments[0].loadAction = MTLLoadActionClear;
+		_compositionRenderPass.colorAttachments[0].storeAction = MTLStoreActionStore;
+		_compositionRenderPass.colorAttachments[0].clearColor = MTLClearColorMake(0.0, 0.5, 0.5, 0.3);
+	}
+
 	// Build the output pipeline.
 	pipelineDescriptor.colorAttachments[0].pixelFormat = _view.colorPixelFormat;
 	pipelineDescriptor.vertexFunction = [library newFunctionWithName:_pipeline == Pipeline::DirectToDisplay ? @"scanToDisplay" : @"lineToDisplay"];
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 72622e15c..4faf94527 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -439,47 +439,7 @@ kernel void filterChromaKernelWithGamma(	texture2d<half, access::read> inTexture
 	filterChromaKernel<true>(inTexture, outTexture, gid, uniforms, offset);
 }
 
-/// Given input pixels of the form:
-///
-///	(composite sample, cos(phase), sin(phase), colour amplitude), applies a lowpass
-///
-/// Filters to separate luminance, subtracts that and scales and maps the remaining chrominance in order to output
-/// pixels in the form:
-///
-///	(luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase))
-///
-/// i.e. the input form for the filterChromaKernel, above].
-kernel void separateLumaKernel(	texture2d<half, access::read> inTexture [[texture(0)]],
-								texture2d<half, access::write> outTexture [[texture(1)]],
-								uint2 gid [[thread_position_in_grid]],
-								constant Uniforms &uniforms [[buffer(0)]],
-								constant int &offset [[buffer(1)]]) {
-	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
-	const half rawSamples[] = {
-		inTexture.read(gid + uint2(0, offset)).r,
-		inTexture.read(gid + uint2(1, offset)).r,
-		inTexture.read(gid + uint2(2, offset)).r,
-		inTexture.read(gid + uint2(3, offset)).r,
-		inTexture.read(gid + uint2(4, offset)).r,
-		inTexture.read(gid + uint2(5, offset)).r,
-		inTexture.read(gid + uint2(6, offset)).r,
-		centreSample.r,
-		inTexture.read(gid + uint2(8, offset)).r,
-		inTexture.read(gid + uint2(9, offset)).r,
-		inTexture.read(gid + uint2(10, offset)).r,
-		inTexture.read(gid + uint2(11, offset)).r,
-		inTexture.read(gid + uint2(12, offset)).r,
-		inTexture.read(gid + uint2(13, offset)).r,
-		inTexture.read(gid + uint2(14, offset)).r,
-	};
-
-#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
-	const half luminance =
-		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
-		Sample(7, 7) +
-		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
-#undef Sample
-
+void setSeparatedLumaChroma(half luminance, half4 centreSample, texture2d<half, access::write> outTexture, uint2 gid, int offset) {
 	// The mix/steps below ensures that the absence of a colour burst leads the colour subcarrier to be discarded.
 	const half isColour = step(half(0.01f), centreSample.a);
 	const half chroma = (centreSample.r - luminance) / mix(half(1.0f), centreSample.a, isColour);
@@ -490,3 +450,112 @@ kernel void separateLumaKernel(	texture2d<half, access::read> inTexture [[textur
 		),
 		gid + uint2(7, offset));
 }
+
+
+/// Given input pixels of the form:
+///
+///	(composite sample, cos(phase), sin(phase), colour amplitude), applies a lowpass
+///
+/// Filters to separate luminance, subtracts that and scales and maps the remaining chrominance in order to output
+/// pixels in the form:
+///
+///	(luminance, 0.5 + 0.5*chrominance*cos(phase), 0.5 + 0.5*chrominance*sin(phase))
+///
+/// i.e. the input form for the filterChromaKernel, above].
+kernel void separateLumaKernel15(	texture2d<half, access::read> inTexture [[texture(0)]],
+									texture2d<half, access::write> outTexture [[texture(1)]],
+									uint2 gid [[thread_position_in_grid]],
+									constant Uniforms &uniforms [[buffer(0)]],
+									constant int &offset [[buffer(1)]]) {
+	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const half rawSamples[] = {
+		inTexture.read(gid + uint2(0, offset)).r,	inTexture.read(gid + uint2(1, offset)).r,
+		inTexture.read(gid + uint2(2, offset)).r,	inTexture.read(gid + uint2(3, offset)).r,
+		inTexture.read(gid + uint2(4, offset)).r,	inTexture.read(gid + uint2(5, offset)).r,
+		inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,
+		inTexture.read(gid + uint2(9, offset)).r,	inTexture.read(gid + uint2(10, offset)).r,
+		inTexture.read(gid + uint2(11, offset)).r,	inTexture.read(gid + uint2(12, offset)).r,
+		inTexture.read(gid + uint2(13, offset)).r,	inTexture.read(gid + uint2(14, offset)).r,
+	};
+
+#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
+	const half luminance =
+		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
+		Sample(7, 7) +
+		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
+#undef Sample
+
+	return setSeparatedLumaChroma(luminance, centreSample, outTexture, gid, offset);
+}
+
+kernel void separateLumaKernel9(	texture2d<half, access::read> inTexture [[texture(0)]],
+									texture2d<half, access::write> outTexture [[texture(1)]],
+									uint2 gid [[thread_position_in_grid]],
+									constant Uniforms &uniforms [[buffer(0)]],
+									constant int &offset [[buffer(1)]]) {
+	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const half rawSamples[] = {
+		inTexture.read(gid + uint2(3, offset)).r,	inTexture.read(gid + uint2(4, offset)).r,
+		inTexture.read(gid + uint2(5, offset)).r,	inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,	inTexture.read(gid + uint2(9, offset)).r,
+		inTexture.read(gid + uint2(10, offset)).r,	inTexture.read(gid + uint2(11, offset)).r
+	};
+
+#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
+	const half luminance =
+		Sample(0, 3) + Sample(1, 4) + Sample(2, 5) + Sample(3, 6) +
+		Sample(4, 7) +
+		Sample(5, 6) + Sample(6, 5) + Sample(7, 4) + Sample(8, 3);
+#undef Sample
+
+	return setSeparatedLumaChroma(luminance, centreSample, outTexture, gid, offset);
+}
+
+kernel void separateLumaKernel7(	texture2d<half, access::read> inTexture [[texture(0)]],
+									texture2d<half, access::write> outTexture [[texture(1)]],
+									uint2 gid [[thread_position_in_grid]],
+									constant Uniforms &uniforms [[buffer(0)]],
+									constant int &offset [[buffer(1)]]) {
+	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const half rawSamples[] = {
+		inTexture.read(gid + uint2(4, offset)).r,
+		inTexture.read(gid + uint2(5, offset)).r,	inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,	inTexture.read(gid + uint2(9, offset)).r,
+		inTexture.read(gid + uint2(10, offset)).r
+	};
+
+#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
+	const half luminance =
+		Sample(0, 4) + Sample(1, 5) + Sample(2, 6) +
+		Sample(3, 7) +
+		Sample(4, 6) + Sample(5, 5) + Sample(6, 4);
+#undef Sample
+
+	return setSeparatedLumaChroma(luminance, centreSample, outTexture, gid, offset);
+}
+
+kernel void separateLumaKernel5(	texture2d<half, access::read> inTexture [[texture(0)]],
+									texture2d<half, access::write> outTexture [[texture(1)]],
+									uint2 gid [[thread_position_in_grid]],
+									constant Uniforms &uniforms [[buffer(0)]],
+									constant int &offset [[buffer(1)]]) {
+	const half4 centreSample = inTexture.read(gid + uint2(7, offset));
+	const half rawSamples[] = {
+		inTexture.read(gid + uint2(5, offset)).r,	inTexture.read(gid + uint2(6, offset)).r,
+		centreSample.r,
+		inTexture.read(gid + uint2(8, offset)).r,	inTexture.read(gid + uint2(9, offset)).r,
+	};
+
+#define Sample(x, y) uniforms.lumaKernel[y] * rawSamples[x]
+	const half luminance =
+		Sample(0, 5) + Sample(1, 6) +
+		Sample(2, 7) +
+		Sample(3, 6) + Sample(4, 5);
+#undef Sample
+
+	return setSeparatedLumaChroma(luminance, centreSample, outTexture, gid, offset);
+}

From 18571e83510a16c9c7dcb25e9cc74bacbb6035a9 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 8 Sep 2020 20:08:56 -0400
Subject: [PATCH 098/131] Also calculates a chroma kernel size, though it isn't
 used for anything yet.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm    | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 259a386ae..971ee2256 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -261,6 +261,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Additional pipeline information.
 	size_t _lumaKernelSize;
+	size_t _chromaKernelSize;
 
 	// The output view.
 	__weak MTKView *_view;
@@ -652,9 +653,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		{
 			auto *const firCoefficients = uniforms()->chromaCoefficients;
 			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
+			_chromaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
 				firCoefficients[c].y = firCoefficients[c].z = (isSVideoOutput ? 2.0f : 1.0f) * chromaCoefficients[c];
 				firCoefficients[c].x = 0.0f;
+				if(fabsf(chromaCoefficients[c]) < 0.01f) {
+					_chromaKernelSize -= 2;
+				}
 			}
 			firCoefficients[7].x = 1.0f;
 
@@ -665,11 +670,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			//
 			// The low cut off ['Hz' but per line, not per second] is somewhat arbitrary.
 			if(!isSVideoOutput) {
-				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 20.0f, colourCyclesPerLine);
+				SignalProcessing::FIRFilter sharpenFilter(15, float(_lineBufferPixelsPerLine), 40.0f, colourCyclesPerLine);
 				const auto sharpen = sharpenFilter.get_coefficients();
+				size_t sharpenFilterSize = 15;
+				bool isStart = true;
 				for(size_t c = 0; c < 8; ++c) {
 					firCoefficients[c].x = sharpen[c];
+					if(fabsf(sharpen[c]) > 0.01f) isStart = false;
+					if(isStart) sharpenFilterSize -= 2;
 				}
+				_chromaKernelSize = std::max(_chromaKernelSize, sharpenFilterSize);
 			}
 		}
 
@@ -680,7 +690,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			_lumaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
 				filter[c] = __fp16(coefficients[c]);
-				if(coefficients[c] < 0.01f) {
+				if(fabsf(coefficients[c]) < 0.01f) {
 					_lumaKernelSize -= 2;
 				}
 			}

From 42d810db7f0d04ef5ff2dcd36da846e84e7f085a Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 10:53:09 -0400
Subject: [PATCH 099/131] Switches per-pixel uniforms to halfs.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 35 +++++++++++--------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 23 ++++++------
 2 files changed, 30 insertions(+), 28 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 971ee2256..644670103 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -96,21 +96,26 @@
 namespace {
 
 // Tracks the Uniforms struct declared in ScanTarget.metal; see there for field definitions.
+//
+// __fp16 is a Clang-specific type which I'm using as equivalent to a Metal half, i.e. an IEEE 754 binary16.
 struct Uniforms {
 	int32_t scale[2];
+	float cyclesMultiplier;
 	float lineWidth;
+
 	float aspectRatioMultiplier;
-	simd::float3x3 toRGB;
-	simd::float3x3 fromRGB;
 	float zoom;
 	simd::float2 offset;
+
+	simd::float3x3 toRGB;
+	simd::float3x3 fromRGB;
+
 	simd::float3 chromaCoefficients[8];
 	__fp16 lumaKernel[8];
-	float radiansPerPixel;
-	float cyclesMultiplier;
-	float outputAlpha;
-	float outputGamma;
-	float outputMultiplier;
+
+	__fp16 outputAlpha;
+	__fp16 outputGamma;
+	__fp16 outputMultiplier;
 };
 
 constexpr size_t NumBufferedLines = 500;
@@ -415,7 +420,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (BOOL)shouldApplyGamma {
-	return fabsf(uniforms()->outputGamma - 1.0f) > 0.01f;
+	return fabsf(float(uniforms()->outputGamma) - 1.0f) > 0.01f;
 }
 
 - (void)updateModalBuffers {
@@ -521,11 +526,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// This is fixed for now; consider making it a function of frame rate and/or of whether frame syncing
 	// is ongoing (which would require a way to signal that to this scan target).
-	uniforms()->outputAlpha = 0.64f;
-	uniforms()->outputMultiplier = modals.brightness;
+	uniforms()->outputAlpha = __fp16(0.64f);
+	uniforms()->outputMultiplier = __fp16(modals.brightness);
 
 	const float displayGamma = 2.2f;	// This is assumed.
-	uniforms()->outputGamma = displayGamma / modals.intended_gamma;
+	uniforms()->outputGamma = __fp16(displayGamma / modals.intended_gamma);
 
 
 
@@ -646,13 +651,13 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_lineBufferPixelsPerLine = NSUInteger(modals.cycles_per_line) * NSUInteger(uniforms()->cyclesMultiplier);
 		const float colourCyclesPerLine = float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 
-		// Store radians per pixel. TODO: is this now orphaned as a uniform? Should I keep it anyway?
-		uniforms()->radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
+		// Compute radians per pixel.
+		const float radiansPerPixel = (colourCyclesPerLine * 3.141592654f * 2.0f) / float(_lineBufferPixelsPerLine);
 
 		// Generate the chrominance filter.
 		{
 			auto *const firCoefficients = uniforms()->chromaCoefficients;
-			const auto chromaCoefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
+			const auto chromaCoefficients = boxCoefficients(radiansPerPixel, 3.141592654f);
 			_chromaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
 				firCoefficients[c].y = firCoefficients[c].z = (isSVideoOutput ? 2.0f : 1.0f) * chromaCoefficients[c];
@@ -686,7 +691,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		// Generate the luminance separation filter and determine its required size.
 		{
 			auto *const filter = uniforms()->lumaKernel;
-			const auto coefficients = boxCoefficients(uniforms()->radiansPerPixel, 3.141592654f);
+			const auto coefficients = boxCoefficients(radiansPerPixel, 3.141592654f);
 			_lumaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
 				filter[c] = __fp16(coefficients[c]);
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 4faf94527..6707262ec 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -18,20 +18,23 @@ struct Uniforms {
 	// for mapping from scan-style integer positions into eye space.
 	int2 scale;
 
+	// Applies a multiplication to all cyclesSinceRetrace values.
+	float cycleMultiplier;
+
 	// This provides the intended height of a scan, in eye-coordinate terms.
 	float lineWidth;
 
 	// Provides a scaling factor in order to preserve 4:3 central content.
 	float aspectRatioMultiplier;
 
-	// Provides conversions to and from RGB for the active colour space.
-	float3x3 toRGB;
-	float3x3 fromRGB;
-
 	// Provides zoom and offset to scale the source data.
 	float zoom;
 	float2 offset;
 
+	// Provides conversions to and from RGB for the active colour space.
+	float3x3 toRGB;
+	float3x3 fromRGB;
+
 	// Describes the FIR filter in use for chroma filtering; it'll be
 	// 15 coefficients but they're symmetrical around the centre.
 	float3 chromaCoefficients[8];
@@ -40,20 +43,14 @@ struct Uniforms {
 	// symmetrical around the centre.
 	half lumaKernel[8];
 
-	// Maps from pixel offsets into the composition buffer to angular difference.
-	float radiansPerPixel;
-
-	// Applies a multiplication to all cyclesSinceRetrace values.
-	float cycleMultiplier;
-
 	// Sets the opacity at which output strips are drawn.
-	float outputAlpha;
+	half outputAlpha;
 
 	// Sets the gamma power to which output colours are raised.
-	float outputGamma;
+	half outputGamma;
 
 	// Sets a brightness multiplier for output colours.
-	float outputMultiplier;
+	half outputMultiplier;
 };
 
 namespace {

From 3d392dd81d93530e686f7ee4728491855ab4d927 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 13:02:04 -0400
Subject: [PATCH 100/131] Completes conversion of composite & S-Video per-pixel
 processing to 16-bit floats.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 35 ++++++++++++++++---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 16 ++++-----
 2 files changed, 39 insertions(+), 12 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 644670103..c2cdb1011 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -95,6 +95,18 @@
 
 namespace {
 
+/// Provides a container for __fp16 versions of tightly-packed single-precision plain old data with a copy assignment constructor.
+template <typename NaturalType> struct HalfConverter {
+	__fp16 elements[sizeof(NaturalType) / sizeof(float)];
+
+	void operator =(const NaturalType &rhs) {
+		const float *floatRHS = reinterpret_cast<const float *>(&rhs);
+		for(size_t c = 0; c < sizeof(elements) / sizeof(*elements); ++c) {
+			elements[c] = __fp16(floatRHS[c]);
+		}
+	}
+};
+
 // Tracks the Uniforms struct declared in ScanTarget.metal; see there for field definitions.
 //
 // __fp16 is a Clang-specific type which I'm using as equivalent to a Metal half, i.e. an IEEE 754 binary16.
@@ -107,10 +119,10 @@ struct Uniforms {
 	float zoom;
 	simd::float2 offset;
 
-	simd::float3x3 toRGB;
-	simd::float3x3 fromRGB;
+	HalfConverter<simd::float3x3> toRGB;
+	HalfConverter<simd::float3x3> fromRGB;
 
-	simd::float3 chromaCoefficients[8];
+	HalfConverter<simd::float3> chromaKernel[8];
 	__fp16 lumaKernel[8];
 
 	__fp16 outputAlpha;
@@ -511,6 +523,15 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[self setAspectRatio];
 
 	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
+//	uniforms()->toRGB[0] = toRGB[0];
+//	uniforms()->toRGB[1] = toRGB[1];
+//	uniforms()->toRGB[2] = toRGB[2];
+//	uniforms()->toRGB[4] = toRGB[3];
+//	uniforms()->toRGB[5] = toRGB[4];
+//	uniforms()->toRGB[6] = toRGB[5];
+//	uniforms()->toRGB[8] = toRGB[6];
+//	uniforms()->toRGB[9] = toRGB[7];
+//	uniforms()->toRGB[10] = toRGB[8];
 	uniforms()->toRGB = simd::float3x3(
 		simd::float3{toRGB[0], toRGB[1], toRGB[2]},
 		simd::float3{toRGB[3], toRGB[4], toRGB[5]},
@@ -656,7 +677,8 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Generate the chrominance filter.
 		{
-			auto *const firCoefficients = uniforms()->chromaCoefficients;
+//			auto *const firCoefficients = uniforms()->chromaKernel;
+			simd::float3 firCoefficients[8];
 			const auto chromaCoefficients = boxCoefficients(radiansPerPixel, 3.141592654f);
 			_chromaKernelSize = 15;
 			for(size_t c = 0; c < 8; ++c) {
@@ -686,6 +708,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 				}
 				_chromaKernelSize = std::max(_chromaKernelSize, sharpenFilterSize);
 			}
+
+			// Convert to half-size floats.
+			for(size_t c = 0; c < 8; ++c) {
+				uniforms()->chromaKernel[c] = firCoefficients[c];
+			}
 		}
 
 		// Generate the luminance separation filter and determine its required size.
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 6707262ec..8bf86be47 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -32,12 +32,12 @@ struct Uniforms {
 	float2 offset;
 
 	// Provides conversions to and from RGB for the active colour space.
-	float3x3 toRGB;
-	float3x3 fromRGB;
+	half3x3 toRGB;
+	half3x3 fromRGB;
 
-	// Describes the FIR filter in use for chroma filtering; it'll be
+	// Describes the filter in use for chroma filtering; it'll be
 	// 15 coefficients but they're symmetrical around the centre.
-	float3 chromaCoefficients[8];
+	half3 chromaKernel[8];
 
 	// Describes the filter in use for luma filtering; 15 coefficients
 	// symmetrical around the centre.
@@ -343,7 +343,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	}	\
 	\
 	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), float(0.0f), float(1.0f));	\
+		const auto colour = float3x3(uniforms.fromRGB) * clamp(convert##name(vert, texture), float(0.0f), float(1.0f));	\
 		const float2 qam = quadrature(vert.colourPhase);	\
 		const float chroma = dot(colour.gb, qam);	\
 		return float4(	\
@@ -354,7 +354,7 @@ float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture
 	}	\
 	\
 	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), float3(0.0f), float3(1.0f));	\
+		const auto colour = float3x3(uniforms.fromRGB) * clamp(convert##name(vert, texture), float3(0.0f), float3(1.0f));	\
 		const float2 colourSubcarrier = quadrature(vert.colourPhase);	\
 		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
 		return composite(level, colourSubcarrier, vert.colourAmplitude);	\
@@ -405,14 +405,14 @@ template <bool applyGamma> void filterChromaKernel(	texture2d<half, access::read
 		inTexture.read(gid + uint2(14, offset)) - moveToZero,
 	};
 
-#define Sample(x, y) half3(uniforms.chromaCoefficients[y]) * rawSamples[x].rgb
+#define Sample(x, y) uniforms.chromaKernel[y] * rawSamples[x].rgb
 	const half3 colour =
 		Sample(0, 0) + Sample(1, 1) + Sample(2, 2) + Sample(3, 3) + Sample(4, 4) + Sample(5, 5) + Sample(6, 6) +
 		Sample(7, 7) +
 		Sample(8, 6) + Sample(9, 5) + Sample(10, 4) + Sample(11, 3) + Sample(12, 2) + Sample(13, 1) + Sample(14, 0);
 #undef Sample
 
-	const half4 output = half4(half3x3(uniforms.toRGB) * colour * half(uniforms.outputMultiplier), half(uniforms.outputAlpha));
+	const half4 output = half4(uniforms.toRGB * colour * uniforms.outputMultiplier, uniforms.outputAlpha);
 	if(applyGamma) {
 		outTexture.write(pow(output, uniforms.outputGamma), gid + uint2(7, offset));
 	} else {

From e7ce03c41880989c375f32976ad1a272229117e3 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 13:15:21 -0400
Subject: [PATCH 101/131] Attempts to ensure initial finalised line texture
 state.

This was an attempt to remove the vertical line on the left of a composite display. Obviously the cause is not as suspected.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 21 ++++++++++---------
 .../Clock Signal/ScanTarget/ScanTarget.metal  |  5 +++++
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index c2cdb1011..54521c592 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -472,6 +472,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		NSString *const kernelFunction = [self shouldApplyGamma] ? @"filterChromaKernelWithGamma" : @"filterChromaKernelNoGamma";
 		_finalisedLineState = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:kernelFunction] error:nil];
+
+		// Ensure finalised line texture is initially clear.
+		id<MTLComputePipelineState> clearPipeline = [_view.device newComputePipelineStateWithFunction:[library newFunctionWithName:@"clearKernel"] error:nil];
+		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+		id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
+
+		[self dispatchComputeCommandEncoder:computeEncoder pipelineState:clearPipeline width:lineTextureDescriptor.width height:lineTextureDescriptor.height offsetBuffer:[self bufferForOffset:0]];
+
+		[computeEncoder endEncoding];
+		[commandBuffer commit];
 	}
 
 	// A luma separation texture will exist only for composite colour.
@@ -519,19 +529,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	//
 	uniforms()->scale[0] = modals.output_scale.x;
 	uniforms()->scale[1] = modals.output_scale.y;
-	uniforms()->lineWidth = 1.05f / modals.expected_vertical_lines;	// TODO: return to 1.0 (or slightly more), once happy.
+	uniforms()->lineWidth = 1.05f / modals.expected_vertical_lines;
 	[self setAspectRatio];
 
 	const auto toRGB = to_rgb_matrix(modals.composite_colour_space);
-//	uniforms()->toRGB[0] = toRGB[0];
-//	uniforms()->toRGB[1] = toRGB[1];
-//	uniforms()->toRGB[2] = toRGB[2];
-//	uniforms()->toRGB[4] = toRGB[3];
-//	uniforms()->toRGB[5] = toRGB[4];
-//	uniforms()->toRGB[6] = toRGB[5];
-//	uniforms()->toRGB[8] = toRGB[6];
-//	uniforms()->toRGB[9] = toRGB[7];
-//	uniforms()->toRGB[10] = toRGB[8];
 	uniforms()->toRGB = simd::float3x3(
 		simd::float3{toRGB[0], toRGB[1], toRGB[2]},
 		simd::float3{toRGB[3], toRGB[4], toRGB[5]},
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 8bf86be47..8db7a8ad3 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -556,3 +556,8 @@ kernel void separateLumaKernel5(	texture2d<half, access::read> inTexture [[textu
 
 	return setSeparatedLumaChroma(luminance, centreSample, outTexture, gid, offset);
 }
+
+kernel void clearKernel(	texture2d<half, access::write> outTexture [[texture(1)]],
+							uint2 gid [[thread_position_in_grid]]) {
+	outTexture.write(half4(0.0f, 0.0f, 0.0f, 1.0f), gid);
+}

From 016e96e6f871495a23e88c4a2599f55f6581d55c Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 15:10:19 -0400
Subject: [PATCH 102/131] Extends usage of `half`. Possibly towards its
 conclusion.

---
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 110 +++++++++---------
 1 file changed, 58 insertions(+), 52 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 8db7a8ad3..ad556da97 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -246,14 +246,14 @@ vertex CopyInterpolator copyVertex(uint vertexID [[vertex_id]], texture2d<float>
 
 // MARK: - Various input format conversion samplers.
 
-float2 quadrature(float phase) {
-	return float2(cos(phase), sin(phase));
+half2 quadrature(float phase) {
+	return half2(cos(phase), sin(phase));
 }
 
-float4 composite(float level, float2 quadrature, float amplitude) {
-	return float4(
+half4 composite(half level, half2 quadrature, half amplitude) {
+	return half4(
 		level,
-		float2(0.5f) + quadrature*0.5f,
+		half2(0.5f) + quadrature*half(0.5f),
 		amplitude
 	);
 }
@@ -262,24 +262,30 @@ float4 composite(float level, float2 quadrature, float amplitude) {
 // composite format used for composition. Direct sampling is always for final output, so the two
 // 8-bit formats also provide a gamma option.
 
-fragment float4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	const float luminance = clamp(float(texture.sample(standardSampler, vert.textureCoordinates).r), 0.0f, 1.0f) * uniforms.outputMultiplier;
-	return float4(float3(luminance), uniforms.outputAlpha);
+fragment half4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	const half luminance = clamp(half(texture.sample(standardSampler, vert.textureCoordinates).r), half(0.0f), half(1.0f)) * uniforms.outputMultiplier;
+	return half4(half3(luminance), uniforms.outputAlpha);
 }
 
-fragment float4 compositeSampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+fragment half4 compositeSampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
 	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
-fragment float4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	return float4(texture.sample(standardSampler, vert.textureCoordinates).rrr * uniforms.outputMultiplier, uniforms.outputAlpha);
+fragment half4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	return half4(texture.sample(standardSampler, vert.textureCoordinates).rrr * uniforms.outputMultiplier, uniforms.outputAlpha);
 }
 
-fragment float4 compositeSampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment half4 compositeSampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
-fragment float4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment half4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	const int offset = int(vert.unitColourPhase * 4.0f) & 3;
+	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
+	return half4(half3(sample[offset]), uniforms.outputAlpha);
+}
+
+fragment half4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	const int offset = int(vert.unitColourPhase * 4.0f) & 3;
 	const float snappedColourPhase = float(offset) * (0.5f * 3.141592654f);	// TODO: plus machine-supplied offset.
 	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
@@ -289,24 +295,24 @@ fragment float4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[s
 // The luminance/phase format can produce either composite or S-Video.
 
 /// @returns A 2d vector comprised where .x = luminance; .y = chroma.
-float2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+half2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	const auto luminancePhase = texture.sample(standardSampler, vert.textureCoordinates).rg;
-	const float phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
-	const float rawChroma = step(luminancePhase.g, 0.75) * cos(vert.colourPhase + phaseOffset);
-	return float2(luminancePhase.r, rawChroma);
+	const half phaseOffset = 3.141592654 * 4.0 * luminancePhase.g;
+	const half rawChroma = step(luminancePhase.g, half(0.75f)) * cos(vert.colourPhase + phaseOffset);
+	return half2(luminancePhase.r, rawChroma);
 }
 
-fragment float4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	const float2 luminanceChroma = convertLuminance8Phase8(vert, texture);
-	const float2 qam = quadrature(vert.colourPhase) * 0.5f;
-	return float4(luminanceChroma.r,
-			float2(0.5f) + luminanceChroma.g*qam,
-			1.0);
+fragment half4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const half2 qam = quadrature(vert.colourPhase) * 0.5f;
+	return half4(luminanceChroma.r,
+			half2(0.5f) + luminanceChroma.g*qam,
+			half(1.0f));
 }
 
-fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
-	const float2 luminanceChroma = convertLuminance8Phase8(vert, texture);
-	const float level = mix(luminanceChroma.r, luminanceChroma.g, vert.colourAmplitude);
+fragment half4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const half level = mix(luminanceChroma.r, luminanceChroma.g, half(vert.colourAmplitude));
 	return composite(level, quadrature(vert.colourPhase), vert.colourAmplitude);
 }
 
@@ -317,64 +323,64 @@ fragment float4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_
 // I could avoid the macro mess below.
 
 // TODO: is the calling convention here causing `vert` and `texture` to be copied?
-float3 convertRed8Green8Blue8(SourceInterpolator vert, texture2d<float> texture) {
-	return float3(texture.sample(standardSampler, vert.textureCoordinates));
+half3 convertRed8Green8Blue8(SourceInterpolator vert, texture2d<half> texture) {
+	return texture.sample(standardSampler, vert.textureCoordinates).rgb;
 }
 
-float3 convertRed4Green4Blue4(SourceInterpolator vert, texture2d<ushort> texture) {
+half3 convertRed4Green4Blue4(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).rg;
-	return float3(sample.r&15, (sample.g >> 4)&15, sample.g&15);
+	return half3(sample.r&15, (sample.g >> 4)&15, sample.g&15);
 }
 
-float3 convertRed2Green2Blue2(SourceInterpolator vert, texture2d<ushort> texture) {
+half3 convertRed2Green2Blue2(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return float3((sample >> 4)&3, (sample >> 2)&3, sample&3);
+	return half3((sample >> 4)&3, (sample >> 2)&3, sample&3);
 }
 
-float3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture) {
+half3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return float3(sample&4, sample&2, sample&1);
+	return half3(sample&4, sample&2, sample&1);
 }
 
 // TODO: don't hard code the 0.64 in sample##name.
 #define DeclareShaders(name, pixelType)	\
-	fragment float4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]]) {	\
-		return float4(convert##name(vert, texture), 0.64);	\
+	fragment half4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]]) {	\
+		return half4(convert##name(vert, texture), 0.64);	\
 	}	\
 	\
-	fragment float4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = float3x3(uniforms.fromRGB) * clamp(convert##name(vert, texture), float(0.0f), float(1.0f));	\
-		const float2 qam = quadrature(vert.colourPhase);	\
-		const float chroma = dot(colour.gb, qam);	\
-		return float4(	\
+	fragment half4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), half(0.0f), half(1.0f));	\
+		const half2 qam = quadrature(vert.colourPhase);	\
+		const half chroma = dot(colour.gb, qam);	\
+		return half4(	\
 			colour.r,	\
-			float2(0.5f) + chroma*qam*0.5f,	\
-			1.0f		\
+			half2(0.5f) + chroma*qam*half(0.5f),	\
+			half(1.0f)		\
 		);	\
 	}	\
 	\
-	fragment float4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = float3x3(uniforms.fromRGB) * clamp(convert##name(vert, texture), float3(0.0f), float3(1.0f));	\
-		const float2 colourSubcarrier = quadrature(vert.colourPhase);	\
-		const float level = mix(colour.r, dot(colour.gb, colourSubcarrier), vert.colourAmplitude);	\
+	fragment half4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), half3(0.0f), half3(1.0f));	\
+		const half2 colourSubcarrier = quadrature(vert.colourPhase);	\
+		const half level = mix(colour.r, dot(colour.gb, colourSubcarrier), half(vert.colourAmplitude));	\
 		return composite(level, colourSubcarrier, vert.colourAmplitude);	\
 	}
 
-DeclareShaders(Red8Green8Blue8, float)
+DeclareShaders(Red8Green8Blue8, half)
 DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
 DeclareShaders(Red1Green1Blue1, ushort)
 
-fragment float4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment half4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }
 
-fragment float4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<float> texture [[texture(0)]]) {
+fragment half4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	return texture.sample(linearSampler, vert.textureCoordinates);
 }
 
-fragment float4 clearFragment() {
-	return float4(0.0, 0.0, 0.0, 0.64);
+fragment half4 clearFragment() {
+	return half4(0.0, 0.0, 0.0, 0.64);
 }
 
 // MARK: - Compute kernels

From dfcc8e9822b2c79ec671988352a3464fb10f1fb8 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 18:17:05 -0400
Subject: [PATCH 103/131] Switches some of the interpolated fields to half
 precision.

---
 OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index ad556da97..900880c1e 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -98,9 +98,9 @@ struct Line {
 struct SourceInterpolator {
 	float4 position [[position]];
 	float2 textureCoordinates;
-	float unitColourPhase;		// i.e. one unit per circle.
-	float colourPhase;			// i.e. 2*pi units per circle, just regular radians.
-	float colourAmplitude [[flat]];
+	half unitColourPhase;		// i.e. one unit per circle.
+	half colourPhase;			// i.e. 2*pi units per circle, just regular radians.
+	half colourAmplitude [[flat]];
 };
 
 struct CopyInterpolator {

From edf8cf4dc6ce0fb4e0f98d6a0c439b442f227ef3 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 9 Sep 2020 19:28:38 -0400
Subject: [PATCH 104/131] Completes the set of with/without gamma, and ensures
 correct alpha selection.

Also culls some other repetitive TODOs.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   |  58 +++++----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 120 +++++++++++-------
 2 files changed, 108 insertions(+), 70 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 54521c592..1f64ae8e8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -25,8 +25,6 @@
 	Source data is converted to 32bpp RGB or to composite directly from its input, at output resolution.
 	Gamma correction is applied unless the inputs are 1bpp (e.g. Macintosh-style black/white, TTL-style RGB).
 
-	TODO: filtering when the output size is 'small'.
-
 	S-Video
 	-------
 
@@ -364,8 +362,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (void)updateSizeBuffersToSize:(CGSize)size {
-	// TODO: consider multisampling here? But it seems like you'd need another level of indirection
-	// in order to maintain an ongoing buffer that supersamples only at the end.
 	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale);
 	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale);
 
@@ -619,7 +615,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		_pipeline = isSVideoOutput ? Pipeline::SVideo : Pipeline::CompositeColour;
 	}
 
-	// TODO: factor in gamma, which may or may not be a factor (it isn't for 1-bit formats).
 	struct FragmentSamplerDictionary {
 		/// Fragment shader that outputs to the composition buffer for composite processing.
 		NSString *const compositionComposite;
@@ -636,29 +631,38 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		NSString *const directRGBWithGamma;
 	};
 	const FragmentSamplerDictionary samplerDictionary[8] = {
-		{@"compositeSampleLuminance1", nullptr, @"sampleLuminance1", @"sampleLuminance1", nullptr, nullptr},
-		{@"compositeSampleLuminance8", nullptr, @"sampleLuminance8", nullptr},
-		{@"compositeSamplePhaseLinkedLuminance8", nullptr, @"samplePhaseLinkedLuminance8", nullptr},
-		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"compositeSampleLuminance8Phase8", nullptr, nullptr, nullptr},
-		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"compositeSampleRed1Green1Blue1", nullptr, @"sampleRed1Green1Blue1", nullptr},
-		{@"compositeSampleRed2Green2Blue2", @"svideoSampleRed2Green2Blue2", @"compositeSampleRed2Green2Blue2", nullptr, @"sampleRed2Green2Blue2", nullptr},
-		{@"compositeSampleRed4Green4Blue4", @"svideoSampleRed4Green4Blue4", @"compositeSampleRed4Green4Blue4", nullptr, @"sampleRed4Green4Blue4", nullptr},
-		{@"compositeSampleRed8Green8Blue8", @"svideoSampleRed8Green8Blue8", @"compositeSampleRed8Green8Blue8", nullptr, @"sampleRed8Green8Blue8", nullptr},
+		// Composite formats.
+		{@"compositeSampleLuminance1", 				nil,	@"sampleLuminance1",				@"sampleLuminance1"},
+		{@"compositeSampleLuminance8", 				nil,	@"sampleLuminance8", 				@"sampleLuminance8WithGamma"},
+		{@"compositeSamplePhaseLinkedLuminance8", 	nil,	@"samplePhaseLinkedLuminance8",		@"samplePhaseLinkedLuminance8WithGamma"},
+
+		// S-Video formats.
+		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8WithGamma"},
+
+		// RGB formats.
+		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"directCompositeSampleRed1Green1Blue1", @"directCompositeSampleRed1Green1Blue1WithGamma", @"sampleRed1Green1Blue1", @"sampleRed1Green1Blue1"},
+		{@"compositeSampleRed2Green2Blue2", @"svideoSampleRed2Green2Blue2", @"directCompositeSampleRed2Green2Blue2", @"directCompositeSampleRed2Green2Blue2WithGamma", @"sampleRed2Green2Blue2", @"sampleRed2Green2Blue2WithGamma"},
+		{@"compositeSampleRed4Green4Blue4", @"svideoSampleRed4Green4Blue4", @"directCompositeSampleRed4Green4Blue4", @"directCompositeSampleRed4Green4Blue4WithGamma", @"sampleRed4Green4Blue4", @"sampleRed4Green4Blue4WithGamma"},
+		{@"compositeSampleRed8Green8Blue8", @"svideoSampleRed8Green8Blue8", @"directCompositeSampleRed8Green8Blue8", @"directCompositeSampleRed8Green8Blue8WithGamma", @"sampleRed8Green8Blue8", @"sampleRed8Green8Blue8WithGamma"},
 	};
 
 #ifndef NDEBUG
-	// Do a quick check of the names entered above. I don't think this is possible at compile time.
-//	for(int c = 0; c < 8; ++c) {
-//		if(samplerDictionary[c].compositionComposite)	assert([library newFunctionWithName:samplerDictionary[c].compositionComposite]);
-//		if(samplerDictionary[c].compositionSVideo)		assert([library newFunctionWithName:samplerDictionary[c].compositionSVideo]);
-//		if(samplerDictionary[c].directComposite)		assert([library newFunctionWithName:samplerDictionary[c].directComposite]);
-//		if(samplerDictionary[c].directRGB)				assert([library newFunctionWithName:samplerDictionary[c].directRGB]);
-//	}
+	// Do a quick check that all the shaders named above are defined in the Metal code. I don't think this is possible at compile time.
+	for(int c = 0; c < 8; ++c) {
+#define Test(x)	if(samplerDictionary[c].x)	assert([library newFunctionWithName:samplerDictionary[c].x]);
+		Test(compositionComposite);
+		Test(compositionSVideo);
+		Test(directComposite);
+		Test(directCompositeWithGamma);
+		Test(directRGB);
+		Test(directRGBWithGamma);
+#undef Test
+	}
 #endif
 
 	uniforms()->cyclesMultiplier = 1.0f;
 	if(_pipeline != Pipeline::DirectToDisplay) {
-		// Pick a suitable cycle multiplier. TODO: can I reduce this from a multiple of 4?
+		// Pick a suitable cycle multiplier.
 		const float minimumSize = 4.0f * float(modals.colour_cycle_numerator) / float(modals.colour_cycle_denominator);
 		while(uniforms()->cyclesMultiplier * modals.cycles_per_line < minimumSize) {
 			uniforms()->cyclesMultiplier += 1.0f;
@@ -678,7 +682,6 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 		// Generate the chrominance filter.
 		{
-//			auto *const firCoefficients = uniforms()->chromaKernel;
 			simd::float3 firCoefficients[8];
 			const auto chromaCoefficients = boxCoefficients(radiansPerPixel, 3.141592654f);
 			_chromaKernelSize = 15;
@@ -757,8 +760,14 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"interpolateFragment"];
 	} else {
 		const bool isRGBOutput = modals.display_type == Outputs::Display::DisplayType::RGB;
-		pipelineDescriptor.fragmentFunction =
-			[library newFunctionWithName:isRGBOutput ? samplerDictionary[int(modals.input_data_type)].directRGB : samplerDictionary[int(modals.input_data_type)].directComposite];
+
+		NSString *shaderName;
+		if(isRGBOutput) {
+			shaderName = [self shouldApplyGamma] ? samplerDictionary[int(modals.input_data_type)].directRGBWithGamma : samplerDictionary[int(modals.input_data_type)].directRGB;
+		} else {
+			shaderName = [self shouldApplyGamma] ? samplerDictionary[int(modals.input_data_type)].directCompositeWithGamma : samplerDictionary[int(modals.input_data_type)].directComposite;
+		}
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:shaderName];
 	}
 
 	// Enable blending.
@@ -818,6 +827,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	[encoder setVertexTexture:_frameBuffer atIndex:0];
 	[encoder setFragmentTexture:_frameBuffer atIndex:0];
+	[encoder setFragmentBuffer:_uniformsBuffer offset:0 atIndex:0];
 
 	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
 	[encoder endEncoding];
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 900880c1e..d2c0cbbe9 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -10,9 +10,6 @@
 
 using namespace metal;
 
-// TODO: I'm being very loose, so far, in use of alpha. Sometimes it's 0.64, somtimes its 1.0.
-// Apply some rigour, for crying out loud.
-
 struct Uniforms {
 	// This is used to scale scan positions, i.e. it provides the range
 	// for mapping from scan-style integer positions into eye space.
@@ -262,35 +259,42 @@ half4 composite(half level, half2 quadrature, half amplitude) {
 // composite format used for composition. Direct sampling is always for final output, so the two
 // 8-bit formats also provide a gamma option.
 
-fragment half4 sampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	const half luminance = clamp(half(texture.sample(standardSampler, vert.textureCoordinates).r), half(0.0f), half(1.0f)) * uniforms.outputMultiplier;
-	return half4(half3(luminance), uniforms.outputAlpha);
+half convertLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
+	return clamp(half(texture.sample(standardSampler, vert.textureCoordinates).r), half(0.0f), half(1.0f));
 }
 
-fragment half4 compositeSampleLuminance1(SourceInterpolator vert [[stage_in]], texture2d<ushort> texture [[texture(0)]]) {
-	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
+half convertLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+	return texture.sample(standardSampler, vert.textureCoordinates).r;
 }
 
-fragment half4 sampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
-	return half4(texture.sample(standardSampler, vert.textureCoordinates).rrr * uniforms.outputMultiplier, uniforms.outputAlpha);
-}
-
-fragment half4 compositeSampleLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
-	return composite(texture.sample(standardSampler, vert.textureCoordinates).r, quadrature(vert.colourPhase), vert.colourAmplitude);
-}
-
-fragment half4 samplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+half convertPhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	const int offset = int(vert.unitColourPhase * 4.0f) & 3;
 	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
-	return half4(half3(sample[offset]), uniforms.outputAlpha);
+	return sample[offset];
 }
 
-fragment half4 compositeSamplePhaseLinkedLuminance8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
-	const int offset = int(vert.unitColourPhase * 4.0f) & 3;
-	const float snappedColourPhase = float(offset) * (0.5f * 3.141592654f);	// TODO: plus machine-supplied offset.
-	auto sample = texture.sample(standardSampler, vert.textureCoordinates);
-	return composite(sample[offset], quadrature(snappedColourPhase), vert.colourAmplitude);
-}
+
+#define CompositeSet(name, type)	\
+	fragment half4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<type> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const half luminance = convert##name(vert, texture) * uniforms.outputMultiplier;	\
+		return half4(half3(luminance), uniforms.outputAlpha);	\
+	}	\
+	\
+	fragment half4 sample##name##WithGamma(SourceInterpolator vert [[stage_in]], texture2d<type> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const half luminance = pow(convert##name(vert, texture) * uniforms.outputMultiplier, uniforms.outputGamma);	\
+		return half4(half3(luminance), uniforms.outputAlpha);	\
+	}	\
+	\
+	fragment half4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<type> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const half luminance = convert##name(vert, texture) * uniforms.outputMultiplier;	\
+		return composite(luminance, quadrature(vert.colourPhase), vert.colourAmplitude);	\
+	}
+
+CompositeSet(Luminance1, ushort);
+CompositeSet(Luminance8, half);
+CompositeSet(PhaseLinkedLuminance8, half);
+
+#undef CompositeSet
 
 // The luminance/phase format can produce either composite or S-Video.
 
@@ -302,54 +306,65 @@ half2 convertLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<ha
 	return half2(luminancePhase.r, rawChroma);
 }
 
+fragment half4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const half luminance = mix(luminanceChroma.r, luminanceChroma.g, vert.colourAmplitude);
+	return composite(luminance, quadrature(vert.colourPhase), vert.colourAmplitude);
+}
+
 fragment half4 sampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
-	const half2 qam = quadrature(vert.colourPhase) * 0.5f;
+	const half2 qam = quadrature(vert.colourPhase) * half(0.5f);
 	return half4(luminanceChroma.r,
 			half2(0.5f) + luminanceChroma.g*qam,
 			half(1.0f));
 }
 
-fragment half4 compositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+fragment half4 directCompositeSampleLuminance8Phase8(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
 	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
-	const half level = mix(luminanceChroma.r, luminanceChroma.g, half(vert.colourAmplitude));
-	return composite(level, quadrature(vert.colourPhase), vert.colourAmplitude);
+	const half luminance = mix(luminanceChroma.r * uniforms.outputMultiplier, luminanceChroma.g, vert.colourAmplitude);
+	return half4(half3(luminance), uniforms.outputAlpha);
 }
 
-// All the RGB formats can produce RGB, composite or S-Video.
-//
-// Note on the below: in Metal you may not call a fragment function (so e.g. svideoSampleX can't just cann sampleX).
-// Also I can find no functioning way to offer a templated fragment function. So I don't currently know how
-// I could avoid the macro mess below.
+fragment half4 directCompositeSampleLuminance8Phase8WithGamma(SourceInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {
+	const half2 luminanceChroma = convertLuminance8Phase8(vert, texture);
+	const half luminance = mix(pow(luminanceChroma.r * uniforms.outputMultiplier, uniforms.outputGamma), luminanceChroma.g, vert.colourAmplitude);
+	return half4(half3(luminance), uniforms.outputAlpha);
+}
+
+
+// All the RGB formats can produce RGB, composite or S-Video.
 
-// TODO: is the calling convention here causing `vert` and `texture` to be copied?
 half3 convertRed8Green8Blue8(SourceInterpolator vert, texture2d<half> texture) {
 	return texture.sample(standardSampler, vert.textureCoordinates).rgb;
 }
 
 half3 convertRed4Green4Blue4(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).rg;
-	return half3(sample.r&15, (sample.g >> 4)&15, sample.g&15);
+	return clamp(half3(sample.r&15, (sample.g >> 4)&15, sample.g&15), half(0.0f), half(1.0f));
 }
 
 half3 convertRed2Green2Blue2(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return half3((sample >> 4)&3, (sample >> 2)&3, sample&3);
+	return clamp(half3((sample >> 4)&3, (sample >> 2)&3, sample&3), half(0.0f), half(1.0f));
 }
 
 half3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture) {
 	const auto sample = texture.sample(standardSampler, vert.textureCoordinates).r;
-	return half3(sample&4, sample&2, sample&1);
+	return clamp(half3(sample&4, sample&2, sample&1), half(0.0f), half(1.0f));
 }
 
-// TODO: don't hard code the 0.64 in sample##name.
 #define DeclareShaders(name, pixelType)	\
-	fragment half4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]]) {	\
-		return half4(convert##name(vert, texture), 0.64);	\
+	fragment half4 sample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		return half4(convert##name(vert, texture), uniforms.outputAlpha);	\
+	}	\
+	\
+	fragment half4 sample##name##WithGamma(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		return half4(pow(convert##name(vert, texture), uniforms.outputGamma), uniforms.outputAlpha);	\
 	}	\
 	\
 	fragment half4 svideoSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), half(0.0f), half(1.0f));	\
+		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
 		const half2 qam = quadrature(vert.colourPhase);	\
 		const half chroma = dot(colour.gb, qam);	\
 		return half4(	\
@@ -359,11 +374,24 @@ half3 convertRed1Green1Blue1(SourceInterpolator vert, texture2d<ushort> texture)
 		);	\
 	}	\
 	\
+	half composite##name(SourceInterpolator vert, texture2d<pixelType> texture, constant Uniforms &uniforms, half2 colourSubcarrier) {	\
+		const auto colour = uniforms.fromRGB * convert##name(vert, texture);	\
+		return mix(colour.r, dot(colour.gb, colourSubcarrier), half(vert.colourAmplitude));	\
+	}	\
+	\
 	fragment half4 compositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
-		const auto colour = uniforms.fromRGB * clamp(convert##name(vert, texture), half3(0.0f), half3(1.0f));	\
 		const half2 colourSubcarrier = quadrature(vert.colourPhase);	\
-		const half level = mix(colour.r, dot(colour.gb, colourSubcarrier), half(vert.colourAmplitude));	\
-		return composite(level, colourSubcarrier, vert.colourAmplitude);	\
+		return composite(composite##name(vert, texture, uniforms, colourSubcarrier), colourSubcarrier, vert.colourAmplitude);	\
+	}	\
+	\
+	fragment half4 directCompositeSample##name(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const half level = composite##name(vert, texture, uniforms, quadrature(vert.colourPhase)); 	\
+		return half4(half3(level), uniforms.outputAlpha);	\
+	}	\
+	\
+	fragment half4 directCompositeSample##name##WithGamma(SourceInterpolator vert [[stage_in]], texture2d<pixelType> texture [[texture(0)]], constant Uniforms &uniforms [[buffer(0)]]) {	\
+		const half level = pow(composite##name(vert, texture, uniforms, quadrature(vert.colourPhase)), uniforms.outputGamma); 	\
+		return half4(half3(level), uniforms.outputAlpha);	\
 	}
 
 DeclareShaders(Red8Green8Blue8, half)
@@ -379,8 +407,8 @@ fragment half4 interpolateFragment(CopyInterpolator vert [[stage_in]], texture2d
 	return texture.sample(linearSampler, vert.textureCoordinates);
 }
 
-fragment half4 clearFragment() {
-	return half4(0.0, 0.0, 0.0, 0.64);
+fragment half4 clearFragment(constant Uniforms &uniforms [[buffer(0)]]) {
+	return half4(0.0, 0.0, 0.0, uniforms.outputAlpha);
 }
 
 // MARK: - Compute kernels

From d7b405c6f8f469c1dca1a162d8437452c71fc1cd Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 10 Sep 2020 13:20:40 -0400
Subject: [PATCH 105/131] Ensures direct luminance -> 'RGB' video doesn't go
 down the composition pipeline.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 1f64ae8e8..cef6f5e57 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -598,15 +598,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLLibrary> library = [_view.device newDefaultLibrary];
 	MTLRenderPipelineDescriptor *pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
 
-	// Occasions when the composition buffer isn't required are slender:
-	//
-	//	(i) input and output are both RGB; or
-	//	(i) output is composite monochrome.
+	// Occasions when the composition buffer isn't required are slender: the output must be neither RGB nor composite monochrome.
 	const bool isComposition =
-		(
-			(natural_display_type_for_data_type(modals.input_data_type) != Outputs::Display::DisplayType::RGB) ||
-			(modals.display_type != Outputs::Display::DisplayType::RGB)
-		) && modals.display_type != Outputs::Display::DisplayType::CompositeMonochrome;
+		modals.display_type != Outputs::Display::DisplayType::RGB &&
+		modals.display_type != Outputs::Display::DisplayType::CompositeMonochrome;
 	const bool isSVideoOutput = modals.display_type == Outputs::Display::DisplayType::SVideo;
 
 	if(!isComposition) {
@@ -632,12 +627,12 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	};
 	const FragmentSamplerDictionary samplerDictionary[8] = {
 		// Composite formats.
-		{@"compositeSampleLuminance1", 				nil,	@"sampleLuminance1",				@"sampleLuminance1"},
-		{@"compositeSampleLuminance8", 				nil,	@"sampleLuminance8", 				@"sampleLuminance8WithGamma"},
-		{@"compositeSamplePhaseLinkedLuminance8", 	nil,	@"samplePhaseLinkedLuminance8",		@"samplePhaseLinkedLuminance8WithGamma"},
+		{@"compositeSampleLuminance1", 				nil,	@"sampleLuminance1",				@"sampleLuminance1",						@"sampleLuminance1",				@"sampleLuminance1"},
+		{@"compositeSampleLuminance8", 				nil,	@"sampleLuminance8", 				@"sampleLuminance8WithGamma",				@"sampleLuminance8", 				@"sampleLuminance8WithGamma"},
+		{@"compositeSamplePhaseLinkedLuminance8", 	nil,	@"samplePhaseLinkedLuminance8",		@"samplePhaseLinkedLuminance8WithGamma",	@"samplePhaseLinkedLuminance8",		@"samplePhaseLinkedLuminance8WithGamma"},
 
 		// S-Video formats.
-		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8WithGamma"},
+		{@"compositeSampleLuminance8Phase8", @"sampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8WithGamma", @"directCompositeSampleLuminance8Phase8", @"directCompositeSampleLuminance8Phase8WithGamma"},
 
 		// RGB formats.
 		{@"compositeSampleRed1Green1Blue1", @"svideoSampleRed1Green1Blue1", @"directCompositeSampleRed1Green1Blue1", @"directCompositeSampleRed1Green1Blue1WithGamma", @"sampleRed1Green1Blue1", @"sampleRed1Green1Blue1"},

From bcaceff3780221e001fb04c3a28698905754506e Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 10 Sep 2020 20:32:58 -0400
Subject: [PATCH 106/131] Simplifies in-Metal transform logic, loading
 responsibility for setup onto the CPU.

I think I've also finally excised whatever order-of-operations issue I was having with regard to non-4:3 displays.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 53 ++++++++++++++-----
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 15 ++----
 2 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index cef6f5e57..f757c18c4 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -113,9 +113,7 @@ struct Uniforms {
 	float cyclesMultiplier;
 	float lineWidth;
 
-	float aspectRatioMultiplier;
-	float zoom;
-	simd::float2 offset;
+	simd::float3x3 sourcetoDisplay;
 
 	HalfConverter<simd::float3x3> toRGB;
 	HalfConverter<simd::float3x3> fromRGB;
@@ -505,18 +503,49 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 - (void)setAspectRatio {
 	const auto modals = _scanTarget.modals();
 	const auto viewAspectRatio = (_view.bounds.size.width / _view.bounds.size.height);
+	simd::float3x3 sourceToDisplay{1.0f};
 
-	// Set the aspect ratio multiplier.
-	uniforms()->aspectRatioMultiplier = float(modals.aspect_ratio / viewAspectRatio);
+	// The starting coordinate space is [0, 1].
 
-	// Also work out the proper zoom.
-	const double fitWidthZoom = (viewAspectRatio / modals.aspect_ratio) / modals.visible_area.size.width;
-	const double fitHeightZoom = 1.0 / modals.visible_area.size.height;
-	uniforms()->zoom = float(std::min(fitWidthZoom, fitHeightZoom));
+	// Move the centre of the cropping rectangle to the centre of the display.
+	{
+		simd::float3x3 recentre{1.0f};
+		recentre.columns[2][0] = 0.5f - (modals.visible_area.origin.x + modals.visible_area.size.width * 0.5f);
+		recentre.columns[2][1] = 0.5f - (modals.visible_area.origin.y + modals.visible_area.size.height * 0.5f);
+		sourceToDisplay = recentre * sourceToDisplay;
+	}
 
-	// Store the offset.
-	uniforms()->offset.x = -modals.visible_area.origin.x;
-	uniforms()->offset.y = -modals.visible_area.origin.y;
+	// Convert from the internal [0, 1] to centred [-1, 1] (i.e. Metal's eye coordinates, though also appropriate
+	// for the zooming step that follows).
+	{
+		simd::float3x3 convertToEye;
+		convertToEye.columns[0][0] = 2.0f;
+		convertToEye.columns[1][1] = -2.0f;
+		convertToEye.columns[2][0] = -1.0f;
+		convertToEye.columns[2][1] = 1.0f;
+		convertToEye.columns[2][2] = 1.0f;
+		sourceToDisplay = convertToEye * sourceToDisplay;
+	}
+
+	// Determine the correct zoom level. This is a combination of (i) the necessary horizontal stretch to produce a proper
+	// aspect ratio; and (ii) the necessary zoom from there to either fit the visible area width or height as per a decision
+	// on letterboxing or pillarboxing.
+	const float aspectRatioStretch = float(modals.aspect_ratio / viewAspectRatio);
+	const float fitWidthZoom = 1.0f / (float(modals.visible_area.size.width) * aspectRatioStretch);
+	const float fitHeightZoom = 1.0f / float(modals.visible_area.size.height);
+	const float zoom = std::min(fitWidthZoom, fitHeightZoom);
+
+	// Convert from there to the proper aspect ratio by stretching or compressing width.
+	// After this the output is exactly centred, filling the vertical space and being as wide or slender as it likes.
+	{
+		simd::float3x3 applyAspectRatio{1.0f};
+		applyAspectRatio.columns[0][0] = aspectRatioStretch * zoom;
+		applyAspectRatio.columns[1][1] = zoom;
+		sourceToDisplay = applyAspectRatio * sourceToDisplay;
+	}
+
+	// Store.
+	uniforms()->sourcetoDisplay = sourceToDisplay;
 }
 
 - (void)setModals:(const Outputs::Display::ScanTarget::Modals &)modals {
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index d2c0cbbe9..88b0b5e99 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -21,12 +21,8 @@ struct Uniforms {
 	// This provides the intended height of a scan, in eye-coordinate terms.
 	float lineWidth;
 
-	// Provides a scaling factor in order to preserve 4:3 central content.
-	float aspectRatioMultiplier;
-
 	// Provides zoom and offset to scale the source data.
-	float zoom;
-	float2 offset;
+	float3x3 sourceToDisplay;
 
 	// Provides conversions to and from RGB for the active colour space.
 	half3x3 toRGB;
@@ -152,13 +148,8 @@ template <typename Input> SourceInterpolator toDisplay(
 	// Hence determine this quad's real shape, using vertexID to pick a corner.
 
 	// position2d is now in the range [0, 1].
-	float2 position2d = start + (float(vertexID&2) * 0.5f) * tangent + (float(vertexID&1) - 0.5f) * normal * uniforms.lineWidth;
-
-	// Apply the requested offset and zoom, to map the desired area to the range [0, 1].
-	position2d = (position2d + uniforms.offset) * uniforms.zoom;
-
-	// Remap from [0, 1] to Metal's [-1, 1] and then apply the aspect ratio correction.
-	position2d = (position2d * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f)) * float2(uniforms.aspectRatioMultiplier, 1.0f);
+	const float2 sourcePosition = start + (float(vertexID&2) * 0.5f) * tangent + (float(vertexID&1) - 0.5f) * normal * uniforms.lineWidth;
+	const float2 position2d = (uniforms.sourceToDisplay * float3(sourcePosition, 1.0f)).xy;
 
 	output.position = float4(
 		position2d,

From e32ae6c191e8c05f724c64a4ad53cf0d6a332ba8 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 10 Sep 2020 22:10:24 -0400
Subject: [PATCH 107/131] Adds UGLY HACKs to workaround uncovered issues in the
 OpenGL scan target.

---
 Machines/Apple/AppleII/Video.hpp   | 12 +++++++++++-
 Machines/Apple/Macintosh/Video.cpp | 12 +++++++++++-
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/Machines/Apple/AppleII/Video.hpp b/Machines/Apple/AppleII/Video.hpp
index d75fd3f4e..67124fae4 100644
--- a/Machines/Apple/AppleII/Video.hpp
+++ b/Machines/Apple/AppleII/Video.hpp
@@ -541,7 +541,17 @@ template <class BusHandler, bool is_iie> class Video: public VideoBase {
 						const int colour_burst_start = std::max(first_sync_column + sync_length + 1, column_);
 						const int colour_burst_end = std::min(first_sync_column + sync_length + 4, ending_column);
 						if(colour_burst_end > colour_burst_start) {
-							crt_.output_colour_burst((colour_burst_end - colour_burst_start) * 14, 0);
+							// UGLY HACK AHOY!
+							// The OpenGL scan target introduces a phase error of 1/8th of a wave. The Metal one does not.
+							// Supply the real phase value if this is an Apple build.
+							// TODO: eliminate UGLY HACK.
+#ifdef __APPLE__
+							constexpr int phase = 224;
+#else
+							constexpr int phase = 0;
+#endif
+
+							crt_.output_colour_burst((colour_burst_end - colour_burst_start) * 14, phase);
 						}
 
 						second_blank_start = std::max(first_sync_column + sync_length + 3, column_);
diff --git a/Machines/Apple/Macintosh/Video.cpp b/Machines/Apple/Macintosh/Video.cpp
index 8d1bfcdf1..f0975979e 100644
--- a/Machines/Apple/Macintosh/Video.cpp
+++ b/Machines/Apple/Macintosh/Video.cpp
@@ -29,7 +29,17 @@ Video::Video(DeferredAudio &audio, DriveSpeedAccumulator &drive_speed_accumulato
  	crt_(704, 1, 370, 6, Outputs::Display::InputDataType::Luminance1) {
 
  	crt_.set_display_type(Outputs::Display::DisplayType::RGB);
-//	crt_.set_visible_area(Outputs::Display::Rect(0.08f, -0.025f, 0.82f, 0.82f));
+
+	// UGLY HACK. UGLY, UGLY HACK. UGLY!
+	// The OpenGL scan target fails properly to place visible areas which are not 4:3.
+	// The [newer] Metal scan target has no such issue. So assume that Apple => Metal,
+	// and set a visible area to work around the OpenGL issue if required.
+	// TODO: eliminate UGLY HACK.
+#ifdef __APPLE__
+	crt_.set_visible_area(Outputs::Display::Rect(0.08f, 10.0f / 368.0f, 0.82f, 344.0f / 368.0f));
+#else
+	crt_.set_visible_area(Outputs::Display::Rect(0.08f, -0.025f, 0.82f, 0.82f));
+#endif
 	crt_.set_aspect_ratio(1.73f);	// The Mac uses a non-standard scanning area.
 }
 

From e113780fd1a794ef3cea6becdd7f9589a305efc1 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Thu, 10 Sep 2020 22:13:19 -0400
Subject: [PATCH 108/131] Minor: ensures no possibility of a dangling(-ish)
 pointer within the Mac video.

---
 Machines/Apple/Macintosh/Video.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Machines/Apple/Macintosh/Video.cpp b/Machines/Apple/Macintosh/Video.cpp
index f0975979e..d90672040 100644
--- a/Machines/Apple/Macintosh/Video.cpp
+++ b/Machines/Apple/Macintosh/Video.cpp
@@ -119,6 +119,7 @@ void Video::run_for(HalfCycles duration) {
 
 					if(final_pixel_word == 32) {
 						crt_.output_data(512);
+						pixel_buffer_ = nullptr;
 					}
 				}
 

From 7dd4c67304c321ce5b67f624cc4c2014e44f5a2d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 13 Sep 2020 18:59:27 -0400
Subject: [PATCH 109/131] Corrects access to `data_type_size`, adds sanity
 check on output area return.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 12 ++++++++++++
 Outputs/ScanTargets/BufferingScanTarget.hpp |  8 +++++++-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index d48bb9c08..37521447d 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -319,6 +319,11 @@ BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 	// Update the read-ahead pointers.
 	read_ahead_pointers_.store(submit_pointers, std::memory_order::memory_order_relaxed);
 
+#ifndef NDEBUG
+	area.counter = output_area_counter_;
+	++output_area_counter_;
+#endif
+
 	return area;
 }
 
@@ -330,6 +335,12 @@ void BufferingScanTarget::complete_output_area(const OutputArea &area) {
 	new_read_pointers.scan = uint16_t(area.end.scan);
 	new_read_pointers.write_area = TextureAddress(area.end.write_area_x, area.end.write_area_y);
 	read_pointers_.store(new_read_pointers, std::memory_order::memory_order_relaxed);
+
+#ifndef NDEBUG
+	// This will fire if the caller is announcing completed output areas out of order.
+	assert(area.counter == output_area_next_returned_);
+	++output_area_next_returned_;
+#endif
 }
 
 void BufferingScanTarget::perform(const std::function<void(void)> &function) {
@@ -358,6 +369,7 @@ const Outputs::Display::ScanTarget::Modals *BufferingScanTarget::new_modals() {
 	// MAJOR SHARP EDGE HERE: assume that because the new_modals have been fetched then the caller will
 	// now ensure their texture buffer is appropriate. They might provide a new pointer and might now.
 	// But either way it's now appropriate to start treating the data size as implied by the data type.
+	std::lock_guard lock_guard(producer_mutex_);
 	data_type_size_ = Outputs::Display::size_for_data_type(modals_.input_data_type);
 
 	return &modals_;
diff --git a/Outputs/ScanTargets/BufferingScanTarget.hpp b/Outputs/ScanTargets/BufferingScanTarget.hpp
index a0ceb8bf2..aa74e6579 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.hpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.hpp
@@ -128,6 +128,10 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 			};
 
 			Endpoint start, end;
+
+#ifndef NDEBUG
+			size_t counter;
+#endif
 		};
 
 		/// Gets the current range of content that has been posted but not yet returned by
@@ -252,8 +256,10 @@ class BufferingScanTarget: public Outputs::Display::ScanTarget {
 		bool modals_are_dirty_ = false;
 
 #ifndef NDEBUG
-		// Debug features; these amount to API validate.
+		// Debug features; these amount to API validation.
 		bool scan_is_ongoing_ = false;
+		size_t output_area_counter_ = 0;
+		size_t output_area_next_returned_ = 0;
 #endif
 };
 

From d7972a7b86b3753bc12ce112e27481163b8bc143 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 13 Sep 2020 19:30:26 -0400
Subject: [PATCH 110/131] Enforces across-the-board supersampling.

I'm damned if I can figure out how to talk an MTKView, or Metal in general, into supersampling so as a first effort this does it in software.
---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 19 ++++++++++++-------
 .../Clock Signal/ScanTarget/ScanTarget.metal  | 13 +++++++++++++
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index f757c18c4..9422483fe 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -189,10 +189,11 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	id<MTLCommandQueue> _commandQueue;
 
 	// Pipelines.
-	id<MTLRenderPipelineState> _composePipeline;	// For rendering to the composition texture.
-	id<MTLRenderPipelineState> _outputPipeline;		// For drawing to the frame buffer.
-	id<MTLRenderPipelineState> _copyPipeline;		// For copying the frame buffer to the visible surface.
-	id<MTLRenderPipelineState> _clearPipeline;		// For applying additional inter-frame clearing (cf. the stencil).
+	id<MTLRenderPipelineState> _composePipeline;		// For rendering to the composition texture.
+	id<MTLRenderPipelineState> _outputPipeline;			// For drawing to the frame buffer.
+	id<MTLRenderPipelineState> _copyPipeline;			// For copying from one texture to another.
+	id<MTLRenderPipelineState> _supersamplePipeline;	// For resampling from one texture to one that is 1/4 as large.
+	id<MTLRenderPipelineState> _clearPipeline;			// For applying additional inter-frame clearing (cf. the stencil).
 
 	// Buffers.
 	id<MTLBuffer> _uniformsBuffer;	// A static buffer, containing a copy of the Uniforms struct.
@@ -315,6 +316,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
 		_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"supersampleFragment"];
+		_supersamplePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
+
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"clearFragment"];
 		pipelineDescriptor.stencilAttachmentPixelFormat = MTLPixelFormatStencil8;
 		_clearPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
@@ -360,8 +364,9 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (void)updateSizeBuffersToSize:(CGSize)size {
-	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale);
-	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale);
+	// TODO: above what size threshold is supersampling no longer desired?
+	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale) * 2;
+	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale) * 2;
 
 	// Generate a framebuffer and a stencil.
 	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
@@ -1080,7 +1085,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	view.currentRenderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:view.currentRenderPassDescriptor];
 
-	[encoder setRenderPipelineState:_copyPipeline];
+	[encoder setRenderPipelineState:_supersamplePipeline];
 	[encoder setVertexTexture:_frameBuffer atIndex:0];
 	[encoder setFragmentTexture:_frameBuffer atIndex:0];
 
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 88b0b5e99..42133850d 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -390,6 +390,19 @@ DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
 DeclareShaders(Red1Green1Blue1, ushort)
 
+// Assumes a 2 -> 1 scaling on both axes; if ever I figure out how to get Metal to do hardware supersampling
+// then this fragment shader can be removed.
+fragment half4 supersampleFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
+	// TODO: can't I do better than this by being careful about positioning and using the linearSampler?
+
+	return (
+		texture.sample(standardSampler, vert.textureCoordinates + float2(0.5f, -1.0f)) +
+		texture.sample(standardSampler, vert.textureCoordinates + float2(0.5f, 1.0f)) +
+		texture.sample(standardSampler, vert.textureCoordinates + float2(-1.0f, 0.5f)) +
+		texture.sample(standardSampler, vert.textureCoordinates + float2(1.0f, -0.5f))
+	) * half(0.25f);
+}
+
 fragment half4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }

From c5e9a74c88111b2c2838004a3e8f83e5d72b56e4 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 13 Sep 2020 21:07:59 -0400
Subject: [PATCH 111/131] Uses DisplayMetrics to disable supersampling when too
 slow.

---
 .../xcschemes/Clock Signal.xcscheme           |  2 +-
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 25 ++++++++++++++++---
 Outputs/DisplayMetrics.cpp                    |  6 ++++-
 Outputs/DisplayMetrics.hpp                    |  3 +++
 4 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme
index 63be2c037..a99eb0a5d 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal.xcscheme	
@@ -67,7 +67,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Release"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       enableASanStackUseAfterReturn = "YES"
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9422483fe..e914aaf57 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -276,6 +276,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	// Additional pipeline information.
 	size_t _lumaKernelSize;
 	size_t _chromaKernelSize;
+	std::atomic<bool> _isUsingSupersampling;
 
 	// The output view.
 	__weak MTKView *_view;
@@ -359,14 +360,22 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[self setAspectRatio];
 
 	@synchronized(self) {
+		// Always [re]try multisampling upon a resize.
+		_scanTarget.display_metrics_.announce_did_resize();
+		_isUsingSupersampling = true;
 		[self updateSizeBuffersToSize:size];
 	}
 }
 
+- (void)updateSizeBuffers {
+	@synchronized(self) {
+		[self updateSizeBuffersToSize:_view.drawableSize];
+	}
+}
+
 - (void)updateSizeBuffersToSize:(CGSize)size {
-	// TODO: above what size threshold is supersampling no longer desired?
-	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale) * 2;
-	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale) * 2;
+	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale) * (_isUsingSupersampling ? 2 : 1);
+	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale) * (_isUsingSupersampling ? 2 : 1);
 
 	// Generate a framebuffer and a stencil.
 	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
@@ -1075,9 +1084,16 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
  */
 - (void)drawInMTKView:(nonnull MTKView *)view {
 	if(_isDrawing.test_and_set()) {
+		_scanTarget.display_metrics_.announce_draw_status(false);
 		return;
 	}
 
+	// Disable supersampling if performance requires it.
+	if(_isUsingSupersampling && _scanTarget.display_metrics_.should_lower_resolution()) {
+		_isUsingSupersampling = false;
+		[self updateSizeBuffers];
+	}
+
 	// Schedule a copy from the current framebuffer to the view; blitting is unavailable as the target is a framebuffer texture.
 	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
 
@@ -1085,7 +1101,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	view.currentRenderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
 	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:view.currentRenderPassDescriptor];
 
-	[encoder setRenderPipelineState:_supersamplePipeline];
+	[encoder setRenderPipelineState:_isUsingSupersampling ? _supersamplePipeline : _copyPipeline];
 	[encoder setVertexTexture:_frameBuffer atIndex:0];
 	[encoder setFragmentTexture:_frameBuffer atIndex:0];
 
@@ -1095,6 +1111,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	[commandBuffer presentDrawable:view.currentDrawable];
 	[commandBuffer addCompletedHandler:^(id<MTLCommandBuffer> _Nonnull) {
 		self->_isDrawing.clear();
+		self->_scanTarget.display_metrics_.announce_draw_status(true);
 	}];
 	[commandBuffer commit];
 }
diff --git a/Outputs/DisplayMetrics.cpp b/Outputs/DisplayMetrics.cpp
index 05632b4b1..f238f5065 100644
--- a/Outputs/DisplayMetrics.cpp
+++ b/Outputs/DisplayMetrics.cpp
@@ -50,7 +50,7 @@ void Metrics::announce_did_resize() {
 	frames_missed_ = frames_hit_ = 0;
 }
 
-void Metrics::announce_draw_status(size_t, std::chrono::high_resolution_clock::duration, bool complete) {
+void Metrics::announce_draw_status(bool complete) {
 	if(!complete) {
 		++frames_missed_;
 	} else {
@@ -79,6 +79,10 @@ void Metrics::announce_draw_status(size_t, std::chrono::high_resolution_clock::d
 	}
 }
 
+void Metrics::announce_draw_status(size_t, std::chrono::high_resolution_clock::duration, bool complete) {
+	announce_draw_status(complete);
+}
+
 bool Metrics::should_lower_resolution() const {
 	// If less than 100 frames are on record, return no opinion; otherwise
 	// suggest a lower resolution if more than 10 frames in the last 100-200
diff --git a/Outputs/DisplayMetrics.hpp b/Outputs/DisplayMetrics.hpp
index 9cd4f7889..c8fae3124 100644
--- a/Outputs/DisplayMetrics.hpp
+++ b/Outputs/DisplayMetrics.hpp
@@ -33,6 +33,9 @@ class Metrics {
 		/// Provides Metrics with a new data point for output speed estimation.
 		void announce_draw_status(size_t lines, std::chrono::high_resolution_clock::duration duration, bool complete);
 
+		/// Provides Metrics with a new data point for output speed estimation, albeit without line-specific information.
+		void announce_draw_status(bool complete);
+
 		/// @returns @c true if Metrics thinks a lower output buffer resolution is desirable in the abstract; @c false otherwise.
 		bool should_lower_resolution() const;
 

From 1a2545fdeafeed68181b63bbc25de73f8926972d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 13 Sep 2020 22:11:51 -0400
Subject: [PATCH 112/131] Excises dangling references to `OpenGLView`,
 reinstates display link.

---
 .../Documents/MachineDocument.swift           | 25 ++-----
 .../Mac/Clock Signal/Machine/CSMachine.mm     | 23 ++----
 .../Mac/Clock Signal/Views/CSScanTargetView.h | 44 +++--------
 .../Mac/Clock Signal/Views/CSScanTargetView.m | 74 +++++--------------
 4 files changed, 38 insertions(+), 128 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift
index 643e57d32..fffea8e3a 100644
--- a/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
+++ b/OSBindings/Mac/Clock Signal/Documents/MachineDocument.swift	
@@ -14,7 +14,6 @@ class MachineDocument:
 	NSDocument,
 	NSWindowDelegate,
 	CSMachineDelegate,
-//	CSOpenGLViewDelegate,
 	CSScanTargetViewResponderDelegate,
 	CSAudioQueueDelegate,
 	CSROMReciverViewDelegate
@@ -100,8 +99,6 @@ class MachineDocument:
 		actionLock.lock()
 		drawLock.lock()
 		machine = nil
-//		openGLView.delegate = nil
-//		openGLView.invalidate()
 		scanTargetView.invalidate()
 		actionLock.unlock()
 		drawLock.unlock()
@@ -253,18 +250,6 @@ class MachineDocument:
 	final func audioQueueIsRunningDry(_ audioQueue: CSAudioQueue) {
 	}
 
-	/// Responds to the CSOpenGLViewDelegate redraw message by requesting a machine update if this is a timed
-	/// request, and ordering a redraw regardless of the motivation.
-//	final func openGLViewRedraw(_ view: CSOpenGLView, event redrawEvent: CSOpenGLViewRedrawEvent) {
-//		if drawLock.try() {
-//			if redrawEvent == .timer {
-//				machine.updateView(forPixelSize: view.backingSize)
-//			}
-//			machine.drawView(forPixelSize: view.backingSize)
-//			drawLock.unlock()
-//		}
-//	}
-
 	// MARK: - Pasteboard Forwarding.
 
 	/// Forwards any text currently on the pasteboard into the active machine.
@@ -278,7 +263,7 @@ class MachineDocument:
 	// MARK: - Runtime Media Insertion.
 
 	/// Delegate message to receive drag and drop files.
-	final func openGLView(_ view: CSScanTargetView, didReceiveFileAt URL: URL) {
+	final func scanTargetView(_ view: CSScanTargetView, didReceiveFileAt URL: URL) {
 		let mediaSet = CSMediaSet(fileAt: URL)
 		if let mediaSet = mediaSet {
 			mediaSet.apply(to: self.machine)
@@ -618,11 +603,11 @@ class MachineDocument:
 
 	// MARK: - Window Title Updates.
 	private var unadornedWindowTitle = ""
-	internal func openGLViewDidCaptureMouse(_ view: CSScanTargetView) {
+	internal func scanTargetViewDidCaptureMouse(_ view: CSScanTargetView) {
 		self.windowControllers[0].window?.title = self.unadornedWindowTitle + " (press ⌘+control to release mouse)"
 	}
 
-	internal func openGLViewDidReleaseMouse(_ view: CSScanTargetView) {
+	internal func scanTargetViewDidReleaseMouse(_ view: CSScanTargetView) {
 		self.windowControllers[0].window?.title = self.unadornedWindowTitle
 	}
 
@@ -748,7 +733,7 @@ class MachineDocument:
 	}
 	fileprivate var animationFader: ViewFader? = nil
 
-	internal func openGLViewDidShowOSMouseCursor(_ view: CSScanTargetView) {
+	internal func scanTargetViewDidShowOSMouseCursor(_ view: CSScanTargetView) {
 		// The OS mouse cursor became visible, so show the volume controls.
 		animationFader = nil
 		volumeView.layer?.removeAllAnimations()
@@ -756,7 +741,7 @@ class MachineDocument:
 		volumeView.layer?.opacity = 1.0
 	}
 
-	internal func openGLViewWillHideOSMouseCursor(_ view: CSScanTargetView) {
+	internal func scanTargetViewWillHideOSMouseCursor(_ view: CSScanTargetView) {
 		// The OS mouse cursor will be hidden, so hide the volume controls.
 		if !volumeView.isHidden && volumeView.layer?.animation(forKey: "opacity") == nil {
 			let fadeAnimation = CABasicAnimation(keyPath: "opacity")
diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index a93328811..f10b2d81e 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -149,7 +149,6 @@ struct ActivityObserver: public Activity::Observer {
 	NSMutableArray<NSString *> *_leds;
 
 	CSHighPrecisionTimer *_timer;
-	CGSize _pixelSize;
 	std::atomic_flag _isUpdating;
 	Time::Nanos _syncTime;
 	Time::Nanos _timeDiff;
@@ -725,11 +724,10 @@ struct ActivityObserver: public Activity::Observer {
 
 #pragma mark - Timer
 
-- (void)openGLViewDisplayLinkDidFire:(CSScanTargetView *)view now:(const CVTimeStamp *)now outputTime:(const CVTimeStamp *)outputTime {
+- (void)scanTargetViewDisplayLinkDidFire:(CSScanTargetView *)view now:(const CVTimeStamp *)now outputTime:(const CVTimeStamp *)outputTime {
 	// First order of business: grab a timestamp.
 	const auto timeNow = Time::nanos_now();
 
-	CGSize pixelSize = view.backingSize;
 	BOOL isSyncLocking;
 	@synchronized(self) {
 		// Store a means to map from CVTimeStamp.hostTime to Time::Nanos;
@@ -741,9 +739,6 @@ struct ActivityObserver: public Activity::Observer {
 		// Store the next end-of-frame time. TODO: and start of next and implied visible duration, if raster racing?
 		_syncTime = int64_t(now->hostTime) + _timeDiff;
 
-		// Also crib the current view pixel size.
-		_pixelSize = pixelSize;
-
 		// Set the current refresh period.
 		_refreshPeriod = double(now->videoRefreshPeriod) / double(now->videoTimeScale);
 
@@ -753,9 +748,7 @@ struct ActivityObserver: public Activity::Observer {
 
 	// Draw the current output. (TODO: do this within the timer if either raster racing or, at least, sync matching).
 	if(!isSyncLocking) {
-//		[self.view performWithGLContext:^{
-//			self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
-//		} flushDrawable:YES];
+		[self.view draw];
 	}
 }
 
@@ -771,7 +764,6 @@ struct ActivityObserver: public Activity::Observer {
 		lastTime = std::max(timeNow - Time::Nanos(10'000'000'000 / TICKS), lastTime);
 		const auto duration = timeNow - lastTime;
 
-		CGSize pixelSize;
 		BOOL splitAndSync = NO;
 		@synchronized(self) {
 			// Post on input events.
@@ -802,7 +794,6 @@ struct ActivityObserver: public Activity::Observer {
 			if(!splitAndSync) {
 				self->_machine->timed_machine()->run_for((double)duration / 1e9);
 			}
-			pixelSize = self->_pixelSize;
 		}
 
 		// If this was not a split-and-sync then dispatch the update request asynchronously, unless
@@ -819,13 +810,9 @@ struct ActivityObserver: public Activity::Observer {
 		if(!wasUpdating) {
 			dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
 				[self.view updateBacking];
-//				[self.view performWithGLContext:^{
-//					self->_scanTarget->update((int)pixelSize.width, (int)pixelSize.height);
-
-//					if(splitAndSync) {
-//						self->_scanTarget->draw((int)pixelSize.width, (int)pixelSize.height);
-//					}
-//				} flushDrawable:splitAndSync];
+				if(splitAndSync) {
+					[self.view draw];
+				}
 				self->_isUpdating.clear();
 			});
 		}
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
index a8d3f4ac3..4b1a1c14e 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
@@ -13,28 +13,6 @@
 @class CSScanTargetView;
 @class CSScanTarget;
 
-typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
-	/// Indicates that AppKit requested a redraw for some reason (mostly likely, the window is being resized). So,
-	/// if the delegate doesn't redraw the view, the user is likely to see a graphical flaw.
-	CSScanTargetViewRedrawEventAppKit,
-	/// Indicates that the view's display-linked timer has triggered a redraw request. So, if the delegate doesn't
-	/// redraw the view, the user will just see the previous drawing without interruption.
-	CSScanTargetViewRedrawEventTimer
-};
-
-//@protocol CSScanTargetViewDelegate
-///*!
-//	Requests that the delegate produce an image of its current output state. May be called on
-//	any queue or thread.
-//	@param view The view making the request.
-//	@param redrawEvent If @c YES then the delegate may decline to redraw if its output would be
-//	identical to the previous frame. If @c NO then the delegate must draw.
-//*/
-//- (void)openGLViewRedraw:(nonnull CSScanTargetView *)view event:(CSScanTargetViewRedrawEvent)redrawEvent;
-//
-//
-//@end
-
 @protocol CSScanTargetViewResponderDelegate <NSObject>
 /*!
 	Supplies a keyDown event to the delegate.
@@ -87,32 +65,32 @@ typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 	the window, in order to forward continuous mouse motion.
 	@param view The view making the announcement.
 */
-- (void)openGLViewDidCaptureMouse:(nonnull CSScanTargetView *)view;
+- (void)scanTargetViewDidCaptureMouse:(nonnull CSScanTargetView *)view;
 
 /*!
 	Announces that the mouse is no longer captured.
 	@param view The view making the announcement.
 */
-- (void)openGLViewDidReleaseMouse:(nonnull CSScanTargetView *)view;
+- (void)scanTargetViewDidReleaseMouse:(nonnull CSScanTargetView *)view;
 
 /*!
 	Announces that the OS mouse cursor is now being displayed again, after having been invisible.
 	@param view The view making the announcement.
 */
-- (void)openGLViewDidShowOSMouseCursor:(nonnull CSScanTargetView *)view;
+- (void)scanTargetViewDidShowOSMouseCursor:(nonnull CSScanTargetView *)view;
 
 /*!
 	Announces that the OS mouse cursor will now be hidden.
 	@param view The view making the announcement.
 */
-- (void)openGLViewWillHideOSMouseCursor:(nonnull CSScanTargetView *)view;
+- (void)scanTargetViewWillHideOSMouseCursor:(nonnull CSScanTargetView *)view;
 
 /*!
 	Announces receipt of a file by drag and drop to the delegate.
 	@param view The view making the request.
 	@param URL The file URL of the received file.
 */
-- (void)openGLView:(nonnull CSScanTargetView *)view didReceiveFileAtURL:(nonnull NSURL *)URL;
+- (void)scanTargetView:(nonnull CSScanTargetView *)view didReceiveFileAtURL:(nonnull NSURL *)URL;
 
 @end
 
@@ -129,17 +107,16 @@ typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 /*!
 	Informs the delegate that the display link has fired.
 */
-- (void)openGLViewDisplayLinkDidFire:(nonnull CSScanTargetView *)view now:(nonnull const CVTimeStamp *)now outputTime:(nonnull const CVTimeStamp *)outputTime;
+- (void)scanTargetViewDisplayLinkDidFire:(nonnull CSScanTargetView *)view now:(nonnull const CVTimeStamp *)now outputTime:(nonnull const CVTimeStamp *)outputTime;
 
 @end
 
 /*!
-	Provides an OpenGL canvas with a refresh-linked update timer that can forward a subset
+	Provides a visible scan target with a refresh-linked update timer that can forward a subset
 	of typical first-responder actions.
 */
 @interface CSScanTargetView : MTKView
 
-//@property (atomic, weak, nullable) id <CSOpenGLViewDelegate> delegate;
 @property (nonatomic, weak, nullable) id <CSScanTargetViewResponderDelegate> responderDelegate;
 @property (atomic, weak, nullable) id <CSScanTargetViewDisplayLinkDelegate> displayLinkDelegate;
 
@@ -165,11 +142,10 @@ typedef NS_ENUM(NSInteger, CSScanTargetViewRedrawEvent) {
 */
 - (void)invalidate;
 
-/// The size in pixels of the OpenGL canvas, factoring in screen pixel density and view size in points.
-@property (nonatomic, readonly) CGSize backingSize;
-
+/*!
+	Ensures output begins on all pending scans.
+*/
 - (void)updateBacking;
-//- (void)performWithGLContext:(nonnull dispatch_block_t)action;
 
 /*!
 	Instructs that the mouse cursor, if currently captured, should be released.
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index 4048b2745..4b69fda90 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -19,7 +19,6 @@
 
 @implementation CSScanTargetView {
 	CVDisplayLinkRef _displayLink;
-	CGSize _backingSize;
 	NSNumber *_currentScreenNumber;
 
 	NSTrackingArea *_mouseTrackingArea;
@@ -32,20 +31,6 @@
 	CSScanTarget *_scanTarget;
 }
 
-//- (void)prepareOpenGL {
-//	[super prepareOpenGL];
-//
-//	// Prepare the atomic int.
-//	atomic_init(&_isDrawingFlag, 0);
-//
-//	// Set the clear colour.
-//	[self.openGLContext makeCurrentContext];
-//	glClearColor(0.0, 0.0, 0.0, 1.0);
-//
-//	// Setup the [initial] display link.
-//	[self setupDisplayLink];
-//}
-
 - (void)setupDisplayLink {
 	// Kill the existing link if there is one.
 	if(_displayLink) {
@@ -61,11 +46,6 @@
 	// Set the renderer output callback function.
 	CVDisplayLinkSetOutputCallback(_displayLink, DisplayLinkCallback, (__bridge void * __nullable)(self));
 
-	// Set the display link for the current renderer.
-//	CGLContextObj cglContext = [[self openGLContext] CGLContextObj];
-//	CGLPixelFormatObj cglPixelFormat = [[self pixelFormat] CGLPixelFormatObj];
-//	CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(_displayLink, cglContext, cglPixelFormat);
-
 	// Activate the display link.
 	CVDisplayLinkStart(_displayLink);
 }
@@ -81,7 +61,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	// Ensure _isDrawingFlag has value 1 when drawing, 0 otherwise.
 	atomic_store(&view->_isDrawingFlag, 1);
 
-	[view.displayLinkDelegate openGLViewDisplayLinkDidFire:view now:now outputTime:outputTime];
+	[view.displayLinkDelegate scanTargetViewDisplayLinkDidFire:view now:now outputTime:outputTime];
 	/*
 		Do not touch the display link from after this call; there's a bit of a race condition with setupDisplayLink.
 		Specifically: Apple provides CVDisplayLinkStop but a call to that merely prevents future calls to the callback,
@@ -109,31 +89,12 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	// feels fine.
 	NSNumber *const screenNumber = self.window.screen.deviceDescription[@"NSScreenNumber"];
 	if(![_currentScreenNumber isEqual:screenNumber]) {
-		// Issue a reshape, in case a switch to/from a Retina display has
-		// happened, changing the results of -convertSizeToBacking:, etc.
-//		[self reshape];
-
 		// Also switch display links, to make sure synchronisation is with the display
 		// the window is actually on, and at its rate.
 		[self setupDisplayLink];
 	}
 }
 
-//- (void)drawAtTime:(const CVTimeStamp *)now frequency:(double)frequency {
-//	[self redrawWithEvent:CSScanTargetViewRedrawEventTimer];
-//}
-
-//- (void)drawRect:(NSRect)dirtyRect {
-//	[self redrawWithEvent:CSScanTargetViewRedrawEventAppKit];
-//	NSLog(@"...");
-//}
-
-//- (void)redrawWithEvent:(CSScanTargetViewRedrawEvent)event  {
-//	[self performWithGLContext:^{
-////		[self.delegate openGLViewRedraw:self event:event];
-//	} flushDrawable:YES];
-//}
-
 - (void)invalidate {
 	_isInvalid = YES;
 	[self stopDisplayLink];
@@ -168,12 +129,6 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	return _scanTarget;
 }
 
-- (CGSize)backingSize {
-	@synchronized(self) {
-		return _backingSize;
-	}
-}
-
 - (void)updateBacking {
 	[_scanTarget updateFrameBuffer];
 }
@@ -186,12 +141,19 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		self.device = MTLCreateSystemDefaultDevice();
 	}
 
+	// Configure for explicit drawing.
+	self.paused = YES;
+	self.enableSetNeedsDisplay = NO;
+
 	// Create the scan target.
 	_scanTarget = [[CSScanTarget alloc] initWithView:self];
 	self.delegate = _scanTarget;
 
 	// Register to receive dragged and dropped file URLs.
 	[self registerForDraggedTypes:@[(__bridge NSString *)kUTTypeFileURL]];
+
+	// Setup the [initial] display link.
+	[self setupDisplayLink];
 }
 
 #pragma mark - NSResponder
@@ -237,7 +199,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {
 	for(NSPasteboardItem *item in [[sender draggingPasteboard] pasteboardItems]) {
 		NSURL *URL = [NSURL URLWithString:[item stringForType:(__bridge NSString *)kUTTypeFileURL]];
-		[self.responderDelegate openGLView:self didReceiveFileAtURL:URL];
+		[self.responderDelegate scanTargetView:self didReceiveFileAtURL:URL];
 	}
 	return YES;
 }
@@ -273,13 +235,13 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 
 		_mouseHideTimer = [NSTimer scheduledTimerWithTimeInterval:3.0 repeats:NO block:^(__unused NSTimer * _Nonnull timer) {
 			[NSCursor setHiddenUntilMouseMoves:YES];
-			[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
+			[self.responderDelegate scanTargetViewWillHideOSMouseCursor:self];
 		}];
 	}
 }
 
 - (void)mouseEntered:(NSEvent *)event {
-	[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
+	[self.responderDelegate scanTargetViewDidShowOSMouseCursor:self];
 	[super mouseEntered:event];
 	[self scheduleMouseHide];
 }
@@ -288,7 +250,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	[super mouseExited:event];
 	[_mouseHideTimer invalidate];
 	_mouseHideTimer = nil;
-	[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
+	[self.responderDelegate scanTargetViewWillHideOSMouseCursor:self];
 }
 
 - (void)releaseMouse {
@@ -296,8 +258,8 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		_mouseIsCaptured = NO;
 		CGAssociateMouseAndMouseCursorPosition(true);
 		[NSCursor unhide];
-		[self.responderDelegate openGLViewDidReleaseMouse:self];
-		[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
+		[self.responderDelegate scanTargetViewDidReleaseMouse:self];
+		[self.responderDelegate scanTargetViewDidShowOSMouseCursor:self];
 		((CSApplication *)[NSApplication sharedApplication]).eventDelegate = nil;
 	}
 }
@@ -309,7 +271,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 		// Mouse capture is off, so don't play games with the cursor, just schedule it to
 		// hide in the near future.
 		[self scheduleMouseHide];
-		[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
+		[self.responderDelegate scanTargetViewDidShowOSMouseCursor:self];
 	} else {
 		if(_mouseIsCaptured) {
 			// Mouse capture is on, so move the cursor back to the middle of the window, and
@@ -327,7 +289,7 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 
 			[self.responderDelegate mouseMoved:event];
 		} else {
-			[self.responderDelegate openGLViewDidShowOSMouseCursor:self];
+			[self.responderDelegate scanTargetViewDidShowOSMouseCursor:self];
 		}
 	}
 }
@@ -360,8 +322,8 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 			_mouseIsCaptured = YES;
 			[NSCursor hide];
 			CGAssociateMouseAndMouseCursorPosition(false);
-			[self.responderDelegate openGLViewWillHideOSMouseCursor:self];
-			[self.responderDelegate openGLViewDidCaptureMouse:self];
+			[self.responderDelegate scanTargetViewWillHideOSMouseCursor:self];
+			[self.responderDelegate scanTargetViewDidCaptureMouse:self];
 			if(self.shouldUsurpCommand) {
 				((CSApplication *)[NSApplication sharedApplication]).eventDelegate = self;
 			}

From ceeadd6a33a244839b98ad67a49d96559041b7a0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Sun, 13 Sep 2020 22:30:17 -0400
Subject: [PATCH 113/131] Edges up towards reimplementing screenshots.

---
 .../Mac/Clock Signal/Machine/CSMachine.mm     | 22 +---------------
 .../Clock Signal/ScanTarget/CSScanTarget.h    |  2 ++
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 25 +++++++++++++++++++
 .../Mac/Clock Signal/Views/CSScanTargetView.h |  5 ++++
 .../Mac/Clock Signal/Views/CSScanTargetView.m |  4 +++
 5 files changed, 37 insertions(+), 21 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm
index f10b2d81e..ff5e25265 100644
--- a/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
+++ b/OSBindings/Mac/Clock Signal/Machine/CSMachine.mm	
@@ -364,27 +364,7 @@ struct ActivityObserver: public Activity::Observer {
 }
 
 - (NSBitmapImageRep *)imageRepresentation {
-	// Grab a screenshot.
-/*	Outputs::Display::OpenGL::Screenshot screenshot(4, 3);
-
-	// Generate an NSBitmapImageRep containing the screenshot's data.
-	NSBitmapImageRep *const result =
-		[[NSBitmapImageRep alloc]
-			initWithBitmapDataPlanes:NULL
-			pixelsWide:screenshot.width
-			pixelsHigh:screenshot.height
-			bitsPerSample:8
-			samplesPerPixel:4
-			hasAlpha:YES
-			isPlanar:NO
-			colorSpaceName:NSDeviceRGBColorSpace
-			bytesPerRow:4 * screenshot.width
-			bitsPerPixel:0];
-
-	memcpy(result.bitmapData, screenshot.pixel_data.data(), size_t(screenshot.width*screenshot.height*4));
-
-	return result;*/
-	return nil;
+	return self.view.imageRepresentation;
 }
 
 - (void)applyMedia:(const Analyser::Static::Media &)media {
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h
index e3f021ea3..993e1fd04 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.h	
@@ -20,4 +20,6 @@
 // ready for output when next requested.
 - (void)updateFrameBuffer;
 
+- (nonnull NSBitmapImageRep *)imageRepresentation;
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index e914aaf57..a87624415 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -1120,4 +1120,29 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	return &_scanTarget;
 }
 
+- (NSBitmapImageRep *)imageRepresentation {
+	// TODO: create a temporary texture, copy, and do as below but not re: _frameBuffer.
+
+	NSBitmapImageRep *const result =
+		[[NSBitmapImageRep alloc]
+			initWithBitmapDataPlanes:NULL
+			pixelsWide:(NSInteger)_frameBuffer.width
+			pixelsHigh:(NSInteger)_frameBuffer.height
+			bitsPerSample:8
+			samplesPerPixel:4
+			hasAlpha:YES
+			isPlanar:NO
+			colorSpaceName:NSDeviceRGBColorSpace
+			bytesPerRow:4 * (NSInteger)_frameBuffer.width
+			bitsPerPixel:0];
+
+//	[_frameBuffer
+//		getBytes:result.bitmapData
+//		bytesPerRow:_frameBuffer.width*4
+//		fromRegion:MTLRegionMake2D(0, 0, _frameBuffer.width, _frameBuffer.height)
+//		mipmapLevel:0];
+
+	return result;
+}
+
 @end
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h
index 4b1a1c14e..58917f785 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.h	
@@ -152,6 +152,11 @@
 */
 - (void)releaseMouse;
 
+/*!
+	@returns An image of the view's current contents.
+*/
+- (nonnull NSBitmapImageRep *)imageRepresentation;
+
 /*!
 	@returns The CSScanTarget being used for this display.
 */
diff --git a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m
index 4b69fda90..65ed41fb1 100644
--- a/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
+++ b/OSBindings/Mac/Clock Signal/Views/CSScanTargetView.m	
@@ -194,6 +194,10 @@ static CVReturn DisplayLinkCallback(__unused CVDisplayLinkRef displayLink, const
 	[self.responderDelegate paste:sender];
 }
 
+- (NSBitmapImageRep *)imageRepresentation {
+	return self.scanTarget.imageRepresentation;
+}
+
 #pragma mark - NSDraggingDestination
 
 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender {

From c0c7818d5d4c55626448ec433950ae432eafb8f6 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 20:33:05 -0400
Subject: [PATCH 114/131] Reintroduces screenshots.

---
 .../Clock Signal/ScanTarget/CSScanTarget.mm   | 77 +++++++++++++------
 1 file changed, 55 insertions(+), 22 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index a87624415..94051fb41 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -373,6 +373,26 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 	}
 }
 
+- (id<MTLCommandBuffer>)copyTexture:(id<MTLTexture>)source to:(id<MTLTexture>)destination {
+	MTLRenderPassDescriptor *const copyTextureDescriptor = [[MTLRenderPassDescriptor alloc] init];
+	copyTextureDescriptor.colorAttachments[0].texture = destination;
+	copyTextureDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
+	copyTextureDescriptor.colorAttachments[0].storeAction = MTLStoreActionStore;
+
+	id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
+	id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:copyTextureDescriptor];
+
+	[encoder setRenderPipelineState:_copyPipeline];
+	[encoder setVertexTexture:source atIndex:0];
+	[encoder setFragmentTexture:source atIndex:0];
+
+	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+	[encoder endEncoding];
+	[commandBuffer commit];
+
+	return commandBuffer;
+}
+
 - (void)updateSizeBuffersToSize:(CGSize)size {
 	const NSUInteger frameBufferWidth = NSUInteger(size.width * _view.layer.contentsScale) * (_isUsingSupersampling ? 2 : 1);
 	const NSUInteger frameBufferHeight = NSUInteger(size.height * _view.layer.contentsScale) * (_isUsingSupersampling ? 2 : 1);
@@ -418,21 +438,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Draw from _oldFrameBuffer to _frameBuffer.
 	if(_oldFrameBuffer) {
-		MTLRenderPassDescriptor *const resizeFrameBufferDescriptor = [[MTLRenderPassDescriptor alloc] init];
-		resizeFrameBufferDescriptor.colorAttachments[0].texture = _frameBuffer;
-		resizeFrameBufferDescriptor.colorAttachments[0].loadAction = MTLLoadActionDontCare;
-		resizeFrameBufferDescriptor.colorAttachments[0].storeAction = MTLStoreActionStore;
-
-		id<MTLCommandBuffer> commandBuffer = [_commandQueue commandBuffer];
-		id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:resizeFrameBufferDescriptor];
-
-		[encoder setRenderPipelineState:_copyPipeline];
-		[encoder setVertexTexture:_oldFrameBuffer atIndex:0];
-		[encoder setFragmentTexture:_oldFrameBuffer atIndex:0];
-
-		[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
-		[encoder endEncoding];
-		[commandBuffer commit];
+		[self copyTexture:_oldFrameBuffer to:_frameBuffer];
 
 		// Don't clear the framebuffer at the end of this frame.
 		_dontClearFrameBuffer = YES;
@@ -1121,8 +1127,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 }
 
 - (NSBitmapImageRep *)imageRepresentation {
-	// TODO: create a temporary texture, copy, and do as below but not re: _frameBuffer.
-
+	// Create an NSBitmapRep as somewhere to copy pixel data to.
 	NSBitmapImageRep *const result =
 		[[NSBitmapImageRep alloc]
 			initWithBitmapDataPlanes:NULL
@@ -1136,11 +1141,39 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 			bytesPerRow:4 * (NSInteger)_frameBuffer.width
 			bitsPerPixel:0];
 
-//	[_frameBuffer
-//		getBytes:result.bitmapData
-//		bytesPerRow:_frameBuffer.width*4
-//		fromRegion:MTLRegionMake2D(0, 0, _frameBuffer.width, _frameBuffer.height)
-//		mipmapLevel:0];
+	// Create a CPU-accessible texture and copy the current contents of the _frameBuffer to it.
+	// TODO: supersample rather than directly copy if appropriate?
+	id<MTLTexture> cpuTexture;
+	MTLTextureDescriptor *const textureDescriptor = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:_view.colorPixelFormat
+		width:_frameBuffer.width
+		height:_frameBuffer.height
+		mipmapped:NO];
+	textureDescriptor.usage = MTLTextureUsageRenderTarget | MTLTextureUsageShaderRead;
+	textureDescriptor.resourceOptions = MTLResourceStorageModeManaged;
+	cpuTexture = [_view.device newTextureWithDescriptor:textureDescriptor];
+	[[self copyTexture:_frameBuffer to:cpuTexture] waitUntilCompleted];
+
+	// Copy from the CPU-visible texture to the bitmap image representation.
+	uint8_t *const bitmapData = result.bitmapData;
+	[cpuTexture
+		getBytes:bitmapData
+		bytesPerRow:_frameBuffer.width*4
+		fromRegion:MTLRegionMake2D(0, 0, _frameBuffer.width, _frameBuffer.height)
+		mipmapLevel:0];
+
+	// Set alpha to fully opaque and do some byte shuffling if necessary;
+	// Apple likes BGR for output but RGB is the best I can specify to NSBitmapImageRep.
+	const NSUInteger totalBytes = _frameBuffer.width * _frameBuffer.height * 4;
+	const bool flipRedBlue = _view.colorPixelFormat == MTLPixelFormatBGRA8Unorm;
+	for(NSUInteger offset = 0; offset < totalBytes; offset += 4) {
+		if(flipRedBlue) {
+			const uint8_t red = bitmapData[offset];
+			bitmapData[offset] = bitmapData[offset+2];
+			bitmapData[offset+2] = red;
+		}
+		bitmapData[offset+3] = 0xff;
+	}
 
 	return result;
 }

From 8557bb213657a72ef6e73a53561b25dab8ece162 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 20:39:52 -0400
Subject: [PATCH 115/131] Adds minor exposition.

---
 OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 94051fb41..4c989dbb8 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -1164,6 +1164,10 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 
 	// Set alpha to fully opaque and do some byte shuffling if necessary;
 	// Apple likes BGR for output but RGB is the best I can specify to NSBitmapImageRep.
+	//
+	// I'm not putting my foot down and having the GPU do the conversion I want
+	// because this lets me reuse _copyPipeline and thereby cut down on boilerplate,
+	// especially given that screenshots are not a bottleneck.
 	const NSUInteger totalBytes = _frameBuffer.width * _frameBuffer.height * 4;
 	const bool flipRedBlue = _view.colorPixelFormat == MTLPixelFormatBGRA8Unorm;
 	for(NSUInteger offset = 0; offset < totalBytes; offset += 4) {

From 35476063b7e71a271c96359994ad0f11b5f94b60 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 21:07:50 -0400
Subject: [PATCH 116/131] Resolves potential data races.

---
 Outputs/DisplayMetrics.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Outputs/DisplayMetrics.hpp b/Outputs/DisplayMetrics.hpp
index c8fae3124..1983bdac1 100644
--- a/Outputs/DisplayMetrics.hpp
+++ b/Outputs/DisplayMetrics.hpp
@@ -12,6 +12,7 @@
 #include "ScanTarget.hpp"
 
 #include <array>
+#include <atomic>
 #include <chrono>
 
 namespace Outputs {
@@ -51,8 +52,8 @@ class Metrics {
 		size_t line_total_history_pointer_ = 0;
 		void add_line_total(int);
 
-		int frames_hit_ = 0;
-		int frames_missed_ = 0;
+		std::atomic<int> frames_hit_ = 0;
+		std::atomic<int> frames_missed_ = 0;
 };
 
 }

From 227e98d6d70c34a37d5ec4eea1f9bb85b04a306d Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 22:27:25 -0400
Subject: [PATCH 117/131] Slightly simplifies control flow.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 37521447d..0af58d150 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -184,7 +184,7 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 		// The previous-frame-is-complete flag is subject to a two-slot queue because
 		// measurement for *this* frame needs to begin now, meaning that the previous
 		// result needs to be put somewhere — it'll be attached to the first successful
-		// line output.
+		// line output, whenever that comes.
 		is_first_in_frame_ = true;
 		previous_frame_was_complete_ = frame_is_complete_;
 		frame_is_complete_ = true;
@@ -201,15 +201,11 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 	if(is_visible) {
 		const auto read_pointers = read_pointers_.load(std::memory_order::memory_order_relaxed);
 
-		// Attempt to allocate a new line, noting allocation failure if necessary.
+		// Attempt to allocate a new line, noting allocation success or failure.
 		const auto next_line = uint16_t((write_pointers_.line + 1) % line_buffer_size_);
-		if(next_line == read_pointers.line) {
-			allocation_has_failed_ = true;
-		}
-		provided_scans_ = 0;
-
-		// If there was space for a new line, establish its start.
+		allocation_has_failed_ = next_line == read_pointers.line;
 		if(!allocation_has_failed_) {
+			// If there was space for a new line, establish its start and reset the count of provided scans.
 			Line &active_line = line_buffer_[size_t(write_pointers_.line)];
 			active_line.end_points[0].x = location.x;
 			active_line.end_points[0].y = location.y;
@@ -217,6 +213,8 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 			active_line.end_points[0].composite_angle = location.composite_angle;
 			active_line.line = write_pointers_.line;
 			active_line.composite_amplitude = composite_amplitude;
+
+			provided_scans_ = 0;
 		}
 	} else {
 		// Commit the most recent line only if any scans fell on it and all allocation was successful.
@@ -251,10 +249,6 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 			write_pointers_ = submit_pointers_.load(std::memory_order::memory_order_relaxed);
 			frame_is_complete_ &= !allocation_has_failed_;
 		}
-
-		// Reset the allocation-has-failed flag for the next line
-		// and mark no line as active.
-		allocation_has_failed_ = false;
 	}
 }
 

From eb9903cd108791de7438144f756fd2c98241ecf0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 22:29:05 -0400
Subject: [PATCH 118/131] Defensively disables allocation of anything outside
 of visible lines.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 0af58d150..ac3857a4c 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -249,6 +249,9 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 			write_pointers_ = submit_pointers_.load(std::memory_order::memory_order_relaxed);
 			frame_is_complete_ &= !allocation_has_failed_;
 		}
+
+		// Don't permit anything to be allocated on invisible areas.
+		allocation_has_failed_ = true;
 	}
 }
 

From 82dbdf7dfc73a03a3c502eed60ac2188ee15b3ba Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Mon, 14 Sep 2020 22:36:00 -0400
Subject: [PATCH 119/131] Switches to using regular linear interpolation for
 supersampling.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm     |  2 +-
 .../Mac/Clock Signal/ScanTarget/ScanTarget.metal    | 13 -------------
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 4c989dbb8..9f1093173 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -317,7 +317,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"copyFragment"];
 		_copyPipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 
-		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"supersampleFragment"];
+		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"interpolateFragment"];
 		_supersamplePipeline = [_view.device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:nil];
 
 		pipelineDescriptor.fragmentFunction = [library newFunctionWithName:@"clearFragment"];
diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal
index 42133850d..88b0b5e99 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/ScanTarget.metal	
@@ -390,19 +390,6 @@ DeclareShaders(Red4Green4Blue4, ushort)
 DeclareShaders(Red2Green2Blue2, ushort)
 DeclareShaders(Red1Green1Blue1, ushort)
 
-// Assumes a 2 -> 1 scaling on both axes; if ever I figure out how to get Metal to do hardware supersampling
-// then this fragment shader can be removed.
-fragment half4 supersampleFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
-	// TODO: can't I do better than this by being careful about positioning and using the linearSampler?
-
-	return (
-		texture.sample(standardSampler, vert.textureCoordinates + float2(0.5f, -1.0f)) +
-		texture.sample(standardSampler, vert.textureCoordinates + float2(0.5f, 1.0f)) +
-		texture.sample(standardSampler, vert.textureCoordinates + float2(-1.0f, 0.5f)) +
-		texture.sample(standardSampler, vert.textureCoordinates + float2(1.0f, -0.5f))
-	) * half(0.25f);
-}
-
 fragment half4 copyFragment(CopyInterpolator vert [[stage_in]], texture2d<half> texture [[texture(0)]]) {
 	return texture.sample(standardSampler, vert.textureCoordinates);
 }

From 2fd5cc056c1b945fd42bb9878c90e23262a08f82 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 16:34:34 -0400
Subject: [PATCH 120/131] Adds std::atomic_thread_fences, but these seem not to
 be a magic bullet.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index ac3857a4c..9443b9b02 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -242,6 +242,7 @@ void BufferingScanTarget::announce(Event event, bool is_visible, const Outputs::
 			write_pointers_.line = uint16_t((write_pointers_.line + 1) % line_buffer_size_);
 
 			// Update the submit pointers with all lines, scans and data written during this line.
+			std::atomic_thread_fence(std::memory_order::memory_order_release);
 			submit_pointers_.store(write_pointers_, std::memory_order::memory_order_release);
 		} else {
 			// Something failed, or there was nothing on the line anyway, so reset all pointers to where they
@@ -299,6 +300,7 @@ BufferingScanTarget::OutputArea BufferingScanTarget::get_output_area() {
 	// cleared for submission.
 	const auto submit_pointers = submit_pointers_.load(std::memory_order::memory_order_acquire);
 	const auto read_ahead_pointers = read_ahead_pointers_.load(std::memory_order::memory_order_relaxed);
+	std::atomic_thread_fence(std::memory_order::memory_order_acquire);
 
 	OutputArea area;
 

From b831b313829f24c218c777f258c09f169b10e7ce Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 17:04:04 -0400
Subject: [PATCH 121/131] Adds a further sanity check.

---
 Outputs/ScanTargets/BufferingScanTarget.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Outputs/ScanTargets/BufferingScanTarget.cpp b/Outputs/ScanTargets/BufferingScanTarget.cpp
index 9443b9b02..c2d0286aa 100644
--- a/Outputs/ScanTargets/BufferingScanTarget.cpp
+++ b/Outputs/ScanTargets/BufferingScanTarget.cpp
@@ -58,13 +58,18 @@ uint8_t *BufferingScanTarget::begin_data(size_t required_length, size_t required
 		end_x = aligned_start_x + uint16_t(1 + required_length);
 	}
 
-	// Check whether that steps over the read pointer.
+	// Check whether that steps over the read pointer; if so then the final address will be closer
+	// to the write pointer than the old.
 	const auto end_address = TextureAddress(end_x, output_y);
 	const auto read_pointers = read_pointers_.load(std::memory_order::memory_order_relaxed);
 
 	const auto end_distance = TextureSub(end_address, read_pointers.write_area);
 	const auto previous_distance = TextureSub(write_pointers_.write_area, read_pointers.write_area);
 
+	// Perform a quick sanity check.
+	assert(end_distance >= 0);
+	assert(previous_distance >= 0);
+
 	// If allocating this would somehow make the write pointer back away from the read pointer,
 	// there must not be enough space left.
 	if(end_distance < previous_distance) {

From 5651ef606dc6264128e72e531f06b5d6e3a55858 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 22:20:06 -0400
Subject: [PATCH 122/131] Resolves failure to advance video address when output
 is blocked.

---
 Machines/Apple/Macintosh/Video.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Machines/Apple/Macintosh/Video.cpp b/Machines/Apple/Macintosh/Video.cpp
index d90672040..3c98374f0 100644
--- a/Machines/Apple/Macintosh/Video.cpp
+++ b/Machines/Apple/Macintosh/Video.cpp
@@ -115,6 +115,8 @@ void Video::run_for(HalfCycles duration) {
 
 							pixel_buffer_ += 16;
 						}
+					} else {
+						video_address_ += size_t(final_pixel_word - first_word);
 					}
 
 					if(final_pixel_word == 32) {

From 69d21daaa3c2953bb776a5c3325932f02591ee7f Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 22:21:05 -0400
Subject: [PATCH 123/131] Improves commentary.

---
 Outputs/CRT/CRT.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Outputs/CRT/CRT.cpp b/Outputs/CRT/CRT.cpp
index 637be7021..c7815bdb3 100644
--- a/Outputs/CRT/CRT.cpp
+++ b/Outputs/CRT/CRT.cpp
@@ -194,8 +194,8 @@ Outputs::Display::ScanTarget::Scan::EndPoint CRT::end_point(uint16_t data_offset
 	end_point.y = uint16_t(vertical_flywheel_->get_current_output_position() / vertical_flywheel_output_divider_);
 	end_point.data_offset = data_offset;
 
-	// TODO: this is a workaround for the limited precision that can be posted onwards;
-	// it'd be better to make time_multiplier_ an explicit modal and just not divide by it.
+	// Ensure .composite_angle is sampled at the location indicated by .cycles_since_end_of_horizontal_retrace.
+	// TODO: I could supply time_multiplier_ as a modal and just not round .cycles_since_end_of_horizontal_retrace. Would that be better?
 	const auto lost_precision = cycles_since_horizontal_sync_ % time_multiplier_;
 	end_point.composite_angle = int16_t(((phase_numerator_ - lost_precision * colour_cycle_numerator_) << 6) / phase_denominator_) * (is_alernate_line_ ? -1 : 1);
 	end_point.cycles_since_end_of_horizontal_retrace = uint16_t(cycles_since_horizontal_sync_ / time_multiplier_);

From bc8787ded69ec01da8831cce4e30b3b0eac3c6d0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 22:26:33 -0400
Subject: [PATCH 124/131] Improves macro safety.

---
 .../Mac/Clock Signal/ScanTarget/CSScanTarget.mm      | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm
index 9f1093173..7076afa80 100644
--- a/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
+++ b/OSBindings/Mac/Clock Signal/ScanTarget/CSScanTarget.mm	
@@ -138,13 +138,13 @@ constexpr MTLResourceOptions SharedResourceOptionsTexture = MTLResourceCPUCacheM
 #define uniforms() reinterpret_cast<Uniforms *>(_uniformsBuffer.contents)
 
 #define RangePerform(start, end, size, func)	\
-	if(start != end) {	\
-		if(start < end) {	\
-			func(start, end-start);	\
+	if((start) != (end)) {	\
+		if((start) < (end)) {	\
+			func((start), (end) - (start));	\
 		} else {	\
-			func(start, size-start);	\
+			func((start), (size) - (start));	\
 			if(end) {	\
-				func(0, end);	\
+				func(0, (end));	\
 			}	\
 		}	\
 	}
@@ -854,7 +854,7 @@ using BufferingScanTarget = Outputs::Display::BufferingScanTarget;
 #endif
 
 #define OutputStrips(start, size)	[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4 instanceCount:size baseInstance:start]
-	RangePerform(start, end, (_pipeline != Pipeline::DirectToDisplay ? NumBufferedLines : NumBufferedScans), OutputStrips);
+	RangePerform(start, end, _pipeline != Pipeline::DirectToDisplay ? NumBufferedLines : NumBufferedScans, OutputStrips);
 #undef OutputStrips
 
 	// Complete encoding.

From 0ac2145740834d3d197cae42ae16b75eb6f86bf9 Mon Sep 17 00:00:00 2001
From: Thomas Harte <TomHarte@users.noreply.github.com>
Date: Tue, 15 Sep 2020 22:43:39 -0400
Subject: [PATCH 125/131] Add Metal/OpenGL distinction.

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8f27e6a83..94a38ec1a 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ Clock Signal ('CLK') is an emulator for tourists that seeks to be invisible. Use
 
 macOS and source releases are [hosted on GitHub](https://github.com/TomHarte/CLK/releases). For desktop Linux it is also available as a [Snap](https://snapcraft.io/clock-signal).
 
-On the Mac it is a native Cocoa application; under Linux, BSD and other UNIXes and UNIX-alikes it can be built either with Qt or with SDL; the Qt build should be considered preliminary and is currently closely bound to X11 as Qt doesn't abstract game-like keyboard handling.
+On the Mac it is a native Cocoa and Metal application; under Linux, BSD and other UNIXes and UNIX-alikes it uses OpenGL and can be built either with Qt or with SDL.
 
 So its aims are:
 * single-click load of any piece of source media for any supported platform;

From 18d0fff8dab08a41967f271621d81608ac4b5b1e Mon Sep 17 00:00:00 2001
From: Thomas Harte <TomHarte@users.noreply.github.com>
Date: Tue, 15 Sep 2020 22:46:38 -0400
Subject: [PATCH 126/131] Graduates the Atari ST.

---
 README.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 94a38ec1a..df088a029 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ It currently contains emulations of the:
 * Amstrad CPC;
 * Apple II/II+ and IIe;
 * Atari 2600;
+* Atari ST;
 * ColecoVision;
 * Commodore Vic-20 (and Commodore 1540/1);
 * Macintosh 512ke and Plus;
@@ -25,8 +26,6 @@ It currently contains emulations of the:
 * Sega Master System; and
 * Sinclair ZX80/81.
 
-In addition, emulation of the Atari ST is experimental.
-
 ## Single-click Loading
 
 Through the combination of static analysis and runtime analysis, CLK seeks to be able automatically to select and configure the appropriate machine to run any provided disk, tape or ROM; to issue any commands necessary to run the software contained on the disk, tape or ROM; and to provide accelerated loading where feasible.

From 5a5347453610fb5c61b294c062b88708474ca3bb Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 22:48:44 -0400
Subject: [PATCH 127/131] Ensure MultiKeyboard deconstructs properly.

---
 Inputs/Keyboard.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Inputs/Keyboard.hpp b/Inputs/Keyboard.hpp
index 56105b279..0b4a4120c 100644
--- a/Inputs/Keyboard.hpp
+++ b/Inputs/Keyboard.hpp
@@ -46,6 +46,8 @@ class Keyboard {
 		/// Constructs a Keyboard that declares itself to observe only members of @c observed_keys.
 		Keyboard(const std::set<Key> &observed_keys, const std::set<Key> &essential_modifiers);
 
+		virtual ~Keyboard() {}
+
 		// Host interface.
 
 		/// @returns @c true if the key press affects the machine; @c false otherwise.

From 061288f5a78335dc4e7ec37c5c27278054ce83c8 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 22:49:00 -0400
Subject: [PATCH 128/131] Add the Macintosh to the Mac kiosk mode informal test
 set.

---
 .../xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme    | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme
index 5a7adbb97..a98a6ccfd 100644
--- a/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme	
+++ b/OSBindings/Mac/Clock Signal.xcodeproj/xcshareddata/xcschemes/Clock Signal Kiosk.xcscheme	
@@ -31,7 +31,7 @@
       </Testables>
    </TestAction>
    <LaunchAction
-      buildConfiguration = "Debug"
+      buildConfiguration = "Release"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
       disableMainThreadChecker = "YES"
@@ -56,6 +56,10 @@
             argument = "/Users/thomasharte/Downloads/test-dsk-for-rw-and-50-60-hz/TEST-RW-60Hz.DSK"
             isEnabled = "NO">
          </CommandLineArgument>
+         <CommandLineArgument
+            argument = "&quot;/Users/thomasharte/Library/Mobile Documents/com~apple~CloudDocs/Desktop/Soft/Macintosh/MusicWorks 0.42.image&quot;"
+            isEnabled = "YES">
+         </CommandLineArgument>
          <CommandLineArgument
             argument = "--volume=0.001"
             isEnabled = "NO">
@@ -86,7 +90,7 @@
          </CommandLineArgument>
          <CommandLineArgument
             argument = "&quot;/Users/thomasharte/Library/Mobile Documents/com~apple~CloudDocs/Desktop/Soft/Amstrad CPC/Robocop.dsk&quot;"
-            isEnabled = "YES">
+            isEnabled = "NO">
          </CommandLineArgument>
          <CommandLineArgument
             argument = "--speed=5"

From b1aefbfe8517d9901eb52332797f43c567768490 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Tue, 15 Sep 2020 23:24:06 -0400
Subject: [PATCH 129/131] Separates asserts.

---
 Outputs/CRT/CRT.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Outputs/CRT/CRT.cpp b/Outputs/CRT/CRT.cpp
index c7815bdb3..7d9acee7d 100644
--- a/Outputs/CRT/CRT.cpp
+++ b/Outputs/CRT/CRT.cpp
@@ -427,7 +427,8 @@ void CRT::set_immediate_default_phase(float phase) {
 
 void CRT::output_data(int number_of_cycles, size_t number_of_samples) {
 #ifndef NDEBUG
-	assert(number_of_samples > 0 && number_of_samples <= allocated_data_length_);
+	assert(number_of_samples > 0);
+	assert(number_of_samples <= allocated_data_length_);
 	allocated_data_length_ = std::numeric_limits<size_t>::min();
 #endif
 	scan_target_->end_data(number_of_samples);

From bb57f0bcc7f94379220ca363a966a81eccd1e2c0 Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 16 Sep 2020 17:24:18 -0400
Subject: [PATCH 130/131] Ensures all 6560 properties have a valid default
 value.

---
 Components/6560/6560.hpp | 42 ++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Components/6560/6560.hpp b/Components/6560/6560.hpp
index 76f2c7d4d..fbc61bf94 100644
--- a/Components/6560/6560.hpp
+++ b/Components/6560/6560.hpp
@@ -445,20 +445,20 @@ template <class BusHandler> class MOS6560 {
 		// register state
 		struct {
 			bool interlaced = false, tall_characters = false;
-			uint8_t first_column_location, first_row_location;
-			uint8_t number_of_columns, number_of_rows;
-			uint16_t character_cell_start_address, video_matrix_start_address;
-			uint16_t backgroundColour, borderColour, auxiliary_colour;
+			uint8_t first_column_location = 0, first_row_location = 0;
+			uint8_t number_of_columns = 0, number_of_rows = 0;
+			uint16_t character_cell_start_address = 0, video_matrix_start_address = 0;
+			uint16_t backgroundColour = 0, borderColour = 0, auxiliary_colour = 0;
 			bool invertedCells = false;
 
-			uint8_t direct_values[16];
+			uint8_t direct_values[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 		} registers_;
 
 		// output state
 		enum State {
 			Sync, ColourBurst, Border, Pixels
-		} this_state_, output_state_;
-		int cycles_in_state_;
+		} this_state_ = State::Sync, output_state_ = State::Sync;
+		int cycles_in_state_ = 0;
 
 		// counters that cover an entire field
 		int horizontal_counter_ = 0, vertical_counter_ = 0;
@@ -487,23 +487,23 @@ template <class BusHandler> class MOS6560 {
 
 		// latches dictating start and length of drawing
 		bool vertical_drawing_latch_ = false, horizontal_drawing_latch_ = false;
-		int rows_this_field_, columns_this_line_;
+		int rows_this_field_ = 0, columns_this_line_ = 0;
 
 		// current drawing position counter
-		int pixel_line_cycle_, column_counter_;
-		int current_row_;
-		uint16_t current_character_row_;
-		uint16_t video_matrix_address_counter_, base_video_matrix_address_counter_;
+		int pixel_line_cycle_ = 0, column_counter_ = 0;
+		int current_row_ = 0;
+		uint16_t current_character_row_ = 0;
+		uint16_t video_matrix_address_counter_ = 0, base_video_matrix_address_counter_ = 0;
 
 		// data latched from the bus
-		uint8_t character_code_, character_colour_, character_value_;
+		uint8_t character_code_ = 0, character_colour_ = 0, character_value_ = 0;
 
 		bool is_odd_frame_ = false, is_odd_line_ = false;
 
 		// lookup table from 6560 colour index to appropriate PAL/NTSC value
-		uint16_t colours_[16];
+		uint16_t colours_[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-		uint16_t *pixel_pointer;
+		uint16_t *pixel_pointer = nullptr;
 		void output_border(int number_of_cycles) {
 			uint16_t *colour_pointer = reinterpret_cast<uint16_t *>(crt_.begin_data(1));
 			if(colour_pointer) *colour_pointer = registers_.borderColour;
@@ -511,13 +511,13 @@ template <class BusHandler> class MOS6560 {
 		}
 
 		struct {
-			int cycles_per_line;
-			int line_counter_increment_offset;
-			int final_line_increment_position;
-			int lines_per_progressive_field;
-			bool supports_interlacing;
+			int cycles_per_line = 0;
+			int line_counter_increment_offset = 0;
+			int final_line_increment_position = 0;
+			int lines_per_progressive_field = 0;
+			bool supports_interlacing = 0;
 		} timing_;
-		OutputMode output_mode_;
+		OutputMode output_mode_ = OutputMode::NTSC;
 };
 
 }

From a17d0e428ff66111b6a97893aa6be67c7f61839a Mon Sep 17 00:00:00 2001
From: Thomas Harte <thomas.harte@gmail.com>
Date: Wed, 16 Sep 2020 18:15:57 -0400
Subject: [PATCH 131/131] Protects against some further uninitialised values.

---
 Components/9918/9918.cpp |  4 ++++
 Outputs/ScanTarget.hpp   | 12 ++++++------
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/Components/9918/9918.cpp b/Components/9918/9918.cpp
index 11512c7ae..07ff15c8f 100644
--- a/Components/9918/9918.cpp
+++ b/Components/9918/9918.cpp
@@ -190,7 +190,9 @@ void TMS9918::run_for(const HalfCycles cycles) {
 	int read_cycles_pool = int_cycles;
 
 	while(write_cycles_pool || read_cycles_pool) {
+#ifndef NDEBUG
 		LineBufferPointer backup = read_pointer_;
+#endif
 
 		if(write_cycles_pool) {
 			// Determine how much writing to do.
@@ -329,8 +331,10 @@ void TMS9918::run_for(const HalfCycles cycles) {
 		}
 
 
+#ifndef NDEBUG
 		assert(backup.row == read_pointer_.row && backup.column == read_pointer_.column);
 		backup = write_pointer_;
+#endif
 
 
 		if(read_cycles_pool) {
diff --git a/Outputs/ScanTarget.hpp b/Outputs/ScanTarget.hpp
index 92899e0c3..0860af010 100644
--- a/Outputs/ScanTarget.hpp
+++ b/Outputs/ScanTarget.hpp
@@ -381,22 +381,22 @@ struct ScanTarget {
 
 struct ScanStatus {
 	/// The current (prediced) length of a field (including retrace).
-	Time::Seconds field_duration;
+	Time::Seconds field_duration = 0.0;
 	/// The difference applied to the field_duration estimate during the last field.
-	Time::Seconds field_duration_gradient;
+	Time::Seconds field_duration_gradient = 0.0;
 	/// The amount of time this device spends in retrace.
-	Time::Seconds retrace_duration;
+	Time::Seconds retrace_duration = 0.0;
 	/// The distance into the current field, from a small negative amount (in retrace) through
 	/// 0 (start of visible area field) to 1 (end of field).
 	///
 	/// This will increase monotonically, being a measure
 	/// of the current vertical position — i.e. if current_position = 0.8 then a caller can
 	/// conclude that the top 80% of the visible part of the display has been painted.
-	float current_position;
+	float current_position = 0.0f;
 	/// The total number of hsyncs so far encountered;
-	int hsync_count;
+	int hsync_count = 0;
 	/// @c true if retrace is currently going on; @c false otherwise.
-	bool is_in_retrace;
+	bool is_in_retrace = false;
 
 	/*!
 		@returns this ScanStatus, with time-relative fields scaled by dividing them by @c dividend.