if let controller = try? Controller(ipAddress: "10.0.1.50") {
	print("Before sending message")
	controller.send(message: ChangeTransitionPosition(to: 5000))
}

NIO-ELT-1-#0 (10): Fatal error: BUG DETECTED: syncShutdownGracefully() must not be called when on an EventLoop.
Calling syncShutdownGracefully() on any EventLoop can lead to deadlocks.
Current eventLoop: SelectableEventLoop { selector = Selector { descriptor = 3 }, thread = NIOThread(name = NIO-ELT-1-#0) }

.../SourcePackages/checkouts/Swift-Atem/Sources/Atem/Connection.swift:101:33: error: 'random()' is unavailable in Swift: Use arc4random instead.
                let randomNumber = UInt32(Int(random()) % Int(UInt16.max))
                                              ^~~~~~
Darwin.random:2:13: note: 'random()' has been explicitly marked unavailable here
public func random() -> Int
            ^

func uploadStill(at index: Int?, image: UIImage) {
	guard let slot = index,
		let resizedImage = self.resizeImage(image: image, targetSize: CGSize(width: 1920, height: 1080)),
		let pngData = resizedImage.pngData()
	else { return }

	let imageSize: CGSize = resizedImage.size
	let width = imageSize.width
	let height = imageSize.height
		
	let numBytes = UInt32(pngData.count)
		
	let yuvData = Media.encodeRunLength(rgbData: pngData)
	let numYuvDataBytes = yuvData.count
				
	let size: UInt32 = UInt32(width * height * 4 * resizedImage.scale)

	// controller should be defined outside of this method. Neither of these two methods work.

	controller.uploadStill(slot: UInt16(slot), data: yuvData, uncompressedSize: numBytes)

//	controller.uploadStill(slot: UInt16(slot), data: yuvData, uncompressedSize: size)
}

public struct VideoOutput: Serializable {
    public enum Output {
        case in1
        case in2
        case in3
        case in4
        case multiview
        case program
        case preview
    }
    let output: Output
    
    public static var title = MessageTitle(string: "CAuS")
        
    public init(with bytes: ArraySlice<UInt8>) throws {
        throw AtemMessageError.notImplemented
    }
    
    public init(output: Output) {
        self.output = output
    }

    public var dataBytes: [UInt8] {
        return switch output {
        case .in1: [1, 0, 0, 1]
        case .in2: [1, 0, 0, 2]
        case .in3: [1, 0, 0, 3]
        case .in4: [1, 0, 0, 4]
        case .multiview: [1, 0, 35, 41]
        case .program: [1, 0, 39, 26]
        case .preview: [1, 0, 39, 27]
        }
    }
    
    public var debugDescription: String {
        return "Video output set to \(output)"
    }
}

init(from slice: ArraySlice<UInt8>) {
	self.init(bigEndian: slice.withUnsafeBufferPointer {
		$0.baseAddress!.withMemoryRebound(to: Self.self, capacity: 1) {$0.pointee}
	})
}

extension Message.Did {
	/// Informs a controller that a source's equalizer settings have changed
	public struct ChangeFairlightMixerSourceEqualizerBand: SerializableMessage {
		public static let title = Message.Title(string: "AEBP")

		public let index: AudioSource
		public let sourceId: Int64
		public let band: UInt8
		public let bandEnabled: Bool
		public let supportedShapes: FairlightEqualizerBandShape
		public let shape: FairlightEqualizerBandShape
		public let supportedFrequencyRanges: FairlightEqualizerFrequencyRange
		public let frequencyRange: FairlightEqualizerFrequencyRange
		public let frequency: UInt32
		public let gain: Int32
		public let qFactor: Int16

		public init(with bytes: ArraySlice<UInt8>) throws {
			self.index = AudioSource(rawValue: UInt16(from: bytes[relative: Position.index]))
			self.sourceId = Int64(from: bytes[relative: Position.sourceId])
			self.band = bytes[relative: Position.band]
			self.bandEnabled = bytes[relative: Position.bandEnabled].firstBit
			self.supportedShapes = FairlightEqualizerBandShape(rawValue: bytes[relative: Position.supportedShapes])
			self.shape = FairlightEqualizerBandShape(rawValue: bytes[relative: Position.shape])
			self.supportedFrequencyRanges = FairlightEqualizerFrequencyRange(rawValue: bytes[relative: Position.supportedFrequencyRanges])
			self.frequencyRange = FairlightEqualizerFrequencyRange(rawValue: bytes[relative: Position.frequencyRange])
			self.frequency = UInt32(from: bytes[relative: Position.frequency])
			self.gain = Int32(from: bytes[relative: Position.gain])
			self.qFactor = Int16(from: bytes[relative: Position.qFactor])
		}

		public init(index: AudioSource, sourceId: Int64, band: UInt8, bandEnabled: Bool, supportedShapes: FairlightEqualizerBandShape, shape: FairlightEqualizerBandShape, supportedFrequencyRanges: FairlightEqualizerFrequencyRange, frequencyRange: FairlightEqualizerFrequencyRange, frequency: UInt32, gain: Int32, qFactor: Int16) {
			self.index = index
			self.sourceId = sourceId
			self.band = band
			self.bandEnabled = bandEnabled
			self.supportedShapes = supportedShapes
			self.shape = shape
			self.supportedFrequencyRanges = supportedFrequencyRanges
			self.frequencyRange = frequencyRange
			self.frequency = frequency
			self.gain = gain
			self.qFactor = qFactor
		}

		public var dataBytes: [UInt8] {
			.init(unsafeUninitializedCapacity: 36) { (buffer, count) in
				buffer.write(index.rawValue.bigEndian, at: Position.index.lowerBound)
				buffer.write(sourceId.bigEndian, at: Position.sourceId.lowerBound)
				buffer[Position.band] = band
				buffer[Position.bandEnabled] = bandEnabled ? 1 : 0
				buffer[Position.supportedShapes] = supportedShapes.rawValue
				buffer[Position.shape] = shape.rawValue
				buffer[Position.supportedFrequencyRanges] = supportedFrequencyRanges.rawValue
				buffer[Position.frequencyRange] = frequencyRange.rawValue
				buffer.write(frequency.bigEndian, at: Position.frequency.lowerBound)
				buffer.write(gain.bigEndian, at: Position.gain.lowerBound)
				buffer.write(qFactor.bigEndian, at: Position.qFactor.lowerBound)
				count = 36
			}
		}

		public var debugDescription: String { return """
Did.ChangeFairlightMixerSourceEqualizerBand {
	index: \(index),
	sourceId: \(sourceId),
	band: \(band),
	bandEnabled: \(bandEnabled),
	supportedShapes: \(supportedShapes),
	shape: \(shape),
	supportedFrequencyRanges: \(supportedFrequencyRanges),
	frequencyRange: \(frequencyRange),
	frequency: \(frequency),
	gain: \(gain),
	qFactor: \(qFactor),
}
"""
		}
		
		enum Position {
			static let index = 0..<2
			static let sourceId = 8..<16
			static let band = 16
			static let bandEnabled = 17
			static let supportedShapes = 18
			static let shape = 19
			static let supportedFrequencyRanges = 20
			static let frequencyRange = 21
			static let frequency = 24..<28
			static let gain = 28..<32
			static let qFactor = 32..<34
		}
	}
}

import Foundation
import Atem

var enabled: Bool = false

let address: String
if CommandLine.arguments.count > 1 {
	address = CommandLine.arguments[1]
} else {
	print("Enter switcher IP address: ", terminator: "")
	address = readLine() ?? "10.1.0.210"
}
print("Trying to connect to switcher with IP address", address)

let controller = try Controller(ipAddress: address) { connection in
	connection.when { (change: Did.ChangeFairlightMixerSourceEqualizerBand) in
		print(change)
	}

	connection.when { (connected: Config.InitiationComplete) in
		print(connected)
		print("Type 0 or 1 and <enter> to change the Audio Follow Video setting.")
	}
	
	connection.whenDisconnected = {
		print("Disconnected")
	}
}

while true {
	_ = readLine() ?? "1"
}

        let controller = try? Controller(ipAddress: "192.168.68.240") { connection in
            connection.when { (connected: Config.InitiationComplete) in
                print(connected)
                print("Type a number and press <enter> to change the current preview")
            }
            connection.whenDisconnected = {
                print("Disconnected")
            }
        }
        
        controller?.send(message: Do.ChangeProgramBus(to:VideoSource.input(2)))

channel active
👹 Not sending because connectionstate is nil
🛑 Shutting down connection [IPv4]192.168.68.240:9910
channel inactive
Disconnected
lost connection due to channel inactive