libatem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc36e2d5444044ba6b674c2cb93c3779497b59cb
+  data.tar.gz: 7d977b1f3cee724021e8c38c0a3b82df6cbf3bfc
+SHA512:
+  metadata.gz: 73624d5e7736f99017e16d2d843f2dbeaeb8a77346ebde9d3880498e5c2d0d51e5a5277d33d915f89192530a9a7b95c693a678f3dd6123c3076cf00cd1793d14
+  data.tar.gz: 1c2e7bb4cdacba2e24cb2827465f02f84205915a80018b82362610a960b37cbec2b64f028c2c1d660153f5906e49ca060883405ef919a37115f3992fe2b11239

data/README.md

@@ -0,0 +1,39 @@
+# <img src="https://raw.githubusercontent.com/InsanityRadio/OnAirController/master/doc/headphones_dark.png" align="left" height=48 /> libatem
+
+libatem is a Ruby library that can control ATEM switchers.
+
+# Basic usage
+
+```
+switcher = ATEM.connect("10.32.0.199")
+
+switcher.inputs
+
+=> []
+
+switcher.inputs[1]
+switcher.inputs['Camera 1']
+
+switcher.inputs[0].preview
+switcher.inputs[1].program
+
+
+```
+
+## Audio! 
+
+```
+
+# Just a warning: this generates quite a bit of traffic from the ATEM
+switcher.use_audio_levels = true
+
+switcher.inputs['Camera 1'].audio.level
+
+```
+
+# TODO:
+
+- Add more features/command support!
+- Smoke & unit test, improve stability
+- Audio
+- Create Gem

data/lib/atem.rb

@@ -0,0 +1,18 @@
+require_relative 'atem/network'
+require_relative 'atem/switcher'
+require_relative 'atem/switcher/input'
+require_relative 'atem/switcher/input_collection'
+require_relative 'atem/switcher/input/audio'
+
+module ATEM
+
+	def self.connect ip, port = 9910
+
+		s = Switcher.new({ :ip => ip, :port => port, :uid => 0x1337 })
+		s.connect
+
+		s
+
+	end
+
+end

data/lib/atem/network.rb

@@ -0,0 +1,186 @@
+require 'socket'
+
+class String
+
+	def to_hex
+		self.bytes.map{|a|"0x" + a.to_s(16)}.join(" ")
+	end
+
+end
+
+
+module ATEM
+
+	class Network
+
+		module Packet
+			NOP = 0x00
+			ACK_REQ = 0x01
+			HELLO = 0x02
+			RESEND = 0x04
+			UNDEFINED = 0x08
+			ACK = 0x10
+		end
+
+		class Retry < StandardError
+		end
+
+		@@SIZE_OF_HEADER = 0x0c
+
+		@package_id = 0
+
+		def initialize ip, port, uid = 0x1337
+
+			@socket = UDPSocket.new
+			@socket.bind "0.0.0.0", 9100
+
+			@ip = ip
+			@port = port
+			@uid = uid
+			@package_id = 0
+
+		end
+
+		def disconnect
+			@socket.close
+		end
+
+		def << data
+
+			bitmask, ack_id, payload = data
+
+			bitmask = bitmask << 11
+			bitmask |= (payload.length + @@SIZE_OF_HEADER)
+			
+			package_id = 0
+			if (bitmask & (Packet::HELLO | Packet::ACK)) != 0 and @ready and payload.length != 0
+				# p "SENDING PACKAGE"
+				@package_id += 1 
+				package_id = @package_id
+			end
+
+			packet = [bitmask, @uid, ack_id, 0, package_id].pack("S>S>S>L>S>")
+			packet += payload
+
+			# print "TX(#{packet.length}, #{@package_id}, #{ack_id})"; p packet.to_hex
+			@socket.send packet, 0, @ip, @port
+
+		end
+
+		def send! cmd, payload
+
+			raise "Invalid command" if cmd.bytes.length != 4
+
+			size = cmd.length + payload.length + 4
+			datagram = [size, 0, 0].pack("S>CC") + cmd + payload
+
+			self << [Packet::ACK_REQ, @ack_id, datagram]
+			self.receive 
+
+		end
+
+		def hello
+
+			self << [0x02, 0x0, [0x01000000, 0x00].pack("L>L>")]
+			self.receive_until_ready
+
+		end
+
+		def receive
+
+			packets = []
+			next_packet = nil
+
+			begin
+
+				begin
+					data, _ = @socket.recvfrom(2048)
+				rescue
+					p "ERR"
+					return []
+				end
+
+				# print "RX(#{data.length}) "; p data.to_hex
+
+				bitmask, size, uid, ack_id, _, package_id = data.unpack("CXS>S>S>LS>")
+				@uid = uid
+
+				bitmask = bitmask >> 3
+				size &= 0x07FF
+
+				# print "RX HEADER: "
+				# p [bitmask, size, uid, ack_id, package_id]
+
+				@ack_id = package_id
+
+				packet = [ack_id, bitmask, package_id, data[ @@SIZE_OF_HEADER .. -1 ]]
+
+				packets += handle(packet)
+
+#				raise Retry
+
+#			rescue Retry
+#				retry if next_packet and next_packet.length >= @@SIZE_OF_HEADER
+			end
+
+			packets
+
+		end
+
+		def receive_until_ready 
+
+			packets = []
+			while !@ready
+				packets += receive
+			end
+			packets
+
+		end
+
+		private
+
+		def handle packet
+
+			bitmask = packet[1]
+
+			if (bitmask & Packet::HELLO) == Packet::HELLO
+
+				@ready = false
+				self << [Packet::ACK, 0x0, '']
+
+			elsif ((bitmask & Packet::ACK_REQ) == Packet::ACK_REQ) and (@ready or (!@ready and packet[3].length == 0))
+
+				self << [Packet::ACK, packet[2], '']
+				@ready = true
+
+			end
+
+			data = packet[3]
+			packets = []
+			
+			while data != nil and data.length > 0
+
+				packet, data = payload(data)
+				packets << packet
+				
+			end
+
+			packets
+
+		end
+
+		def payload packet
+
+			size = packet.unpack("S>")[0]
+			pack = packet[4..size-1]
+			packet = packet[size..-1]
+
+			command = pack.slice!(0, 4)
+
+			[[command, pack], packet]
+
+		end
+
+	end
+
+end

data/lib/atem/switcher.rb

@@ -0,0 +1,158 @@
+module ATEM
+
+	class Switcher
+
+		attr_reader :version, :product, :topology, :video_mode, :master
+
+		def initialize config
+			@config = config
+			@inputs = ATEM::Switcher::InputCollection.new self
+			@_audio_by_index = []
+		end
+
+		def connect
+
+			@airtower = ATEM::Network.new @config[:ip], @config[:port], @config[:uid]
+
+			response = @airtower.hello
+			# @airtower.send! "FTSU", "\x0" * 12
+			response.each { | c | handle c }
+
+		end
+
+		# YIKES!
+		def handle packet
+
+			case packet[0]
+			when "_ver"
+
+				@version = packet[1].unpack("S>S>")
+
+			when "_pin"
+
+				@product = packet[1].unpack("a20")[0]
+
+			when "_top"
+
+				top = ["MEs", "Sources", "Colour Generators", "AUX busses", "DSKs", "Stingers", "DVEs", "SuperSources"]
+				@topology = Hash[top.zip(packet[1].unpack("CCCCCCCC"))]
+
+			when "VidM"
+
+				@video_mode = packet[1].unpack("C")
+
+			when "InPr"
+
+				input = ATEM::Switcher::Input.from packet[1], self, ATEM::Switcher::Input::Type::VIDEO
+				@inputs.add input 
+
+			when "AMIP"
+
+				audio_id = packet[1].unpack("S>")[0] #("S>CxxxCCCxS>s>")
+
+				input = @inputs[audio_id]
+
+				if !@inputs[audio_id] 
+					input = ATEM::Switcher::Input.new self
+					input.init audio_id
+					@inputs.add(input)
+				end
+
+				input.type |= ATEM::Switcher::Input::Type::AUDIO
+				input.audio = ATEM::Switcher::Input::Audio.from packet[1], self, input
+
+			when "AMLv"
+
+				master = {}
+				sources, master[:left], master[:right], master[:left_peak], master[:right_peak],
+					monitor = packet[1].unpack("S>xxl>l>l>l>l>")
+
+				@master = master
+				start_offset = 38 + sources * 2
+
+				(0..sources-1).each do | source |
+
+					source_id = packet[1][(36 + source * 2)..-1].unpack("S>")[0]
+
+					levels = {}
+
+					levels[:left], levels[:right], levels[:left_peak], levels[:right_peak] =
+						packet[1][(start_offset + source * 16)..-1].unpack("l>l>l>l>")
+
+					@inputs[source_id].audio.levels = levels
+
+				end
+
+			end
+
+		end
+
+		def disconnect
+
+			@airtower.disconnect
+
+		end
+
+		def inputs
+			@inputs
+		end
+
+		def multithreading
+			@thread != nil
+		end
+
+		def multithreading= enabled
+
+			@thread.kill if @thread
+			@thread = nil
+			return if !enabled
+
+			Thread.abort_on_exception = true
+			@thread = Thread.new do
+
+				loop do
+
+					packets = @airtower.receive
+					packets.each do | packet |
+						handle packet
+					end
+
+				end
+
+			end
+
+		end
+
+		def use_audio_levels
+			@use_audio_levels
+		end
+
+		def use_audio_levels= enabled
+
+			self.multithreading = true if !@thread
+			@airtower.send! "SALN", [enabled ? 1 : 0].pack("C") + "\0\0\0"
+
+		end
+
+		def reset_audio_peaks
+
+			@inputs.each do | id, input |
+				
+				puts "Resetting #{input.name}" if input.audio != nil
+				@airtower.send! "RAMP", [2, 0, input.audio.id, 1, 0, 0, 0].pack("CCS>CCCC") if input.audio != nil
+
+			end
+
+		end
+
+		def preview id
+			@airtower.send! "CPvI", [0, 0, id].pack("CCS>")
+		end
+
+		def program id
+			@airtower.send! "CPgI", [0, 0, id].pack("CCS>")
+		end
+
+	end
+
+end

data/lib/atem/switcher/input.rb

@@ -0,0 +1,63 @@
+module ATEM
+
+	class Switcher
+
+		class Input
+
+			attr_reader :switcher, :id, :name, :short_name, :quick_init
+			attr_accessor :type, :audio
+
+			module Type
+				VIDEO = 0x01
+				AUDIO = 0x02
+				AUDIO_VIDEO = 0x03
+			end
+
+			def self.from packet, switcher, type
+
+				input = self.new switcher
+				input.init_from packet
+
+				input.type = type
+
+				input
+
+			end
+
+			def initialize switcher
+
+				@switcher = switcher
+
+			end
+
+			def init_from packet 
+
+				@id, @name, @short_name, @supported, @ext_port_type, @port_type, @availability = 
+					packet.unpack("S>Z20Z4xCxCCxC")
+
+			end
+
+			def init id, name = nil, short_name = nil
+
+				@id = id
+				@name = name or "Input #{@id}"
+				@short_name = short_name or "#{@id.to_s.rjust(4, "0")}"
+				@quick_init = true
+
+			end
+
+			######
+
+			def preview
+				@switcher.preview @id
+			end
+
+			def program
+				@switcher.program @id
+			end
+
+		end
+
+	end
+
+end

data/lib/atem/switcher/input/audio.rb

@@ -0,0 +1,59 @@
+module ATEM
+
+	class Switcher
+
+		class Input
+
+			class Audio
+
+				attr_reader :switcher, :input, :id, :type, :media_player, :plug, :mix, :gain, :balance
+				attr_accessor :levels
+
+				def self.from packet, switcher, input
+
+					audio = self.new switcher, input
+					audio.init_from packet
+					audio
+
+				end
+
+				def initialize switcher, input 
+
+					@switcher = switcher
+					@input = input
+					@level = 0
+
+				end
+
+				def init_from packet 
+
+					@id, @type, @media_player, @plug, @mix, @gain, @balance =
+						packet.unpack("S>CxxxCCCxS>s>")
+
+					# Now we have the right data, we can name the input itself
+					if @input.quick_init
+
+						values = {
+							1001 => ['XLR', 'XLR0'],
+							1101 => ['AES/EBU', 'AES3'],
+							1201 => ['RCA', 'RCA_'],
+						}
+						@input.init @input.id, values[@input.id][0], values[@input.id][1]
+
+					end
+
+				end
+
+				#####
+
+				def level
+					(@levels[:left] + @levels[:right]) / 2
+				end
+
+			end
+
+		end
+
+	end
+
+end

data/lib/atem/switcher/input_collection.rb

@@ -0,0 +1,42 @@
+module ATEM
+
+	class Switcher
+
+		class InputCollection
+
+			include Enumerable
+
+			attr_reader :switcher
+
+			def initialize switcher
+				@switcher = switcher
+				@inputs = {}
+			end
+
+			def add input
+
+				@inputs[input.id] = input
+
+			end
+
+			def [] index
+
+				return @inputs[index] if @inputs[index]
+
+				@inputs.each do | a, input |
+
+					return input if input.name == index or input.short_name.downcase == index.downcase
+
+				end if index.is_a? String
+
+			end
+
+			def each(&block)
+				@inputs.each(&block)
+			end
+
+		end
+
+	end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: libatem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jamie Woods
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-02 00:00:00.000000000 Z
+dependencies: []
+description: A library that allows control of Blackmagic Design ATEM switchers through
+  Ruby
+email: gnitupmoc@insanityradiodotcom
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/atem/network.rb
+- lib/atem/switcher/input/audio.rb
+- lib/atem/switcher/input.rb
+- lib/atem/switcher/input_collection.rb
+- lib/atem/switcher.rb
+- lib/atem.rb
+- README.md
+homepage: https://tech.insanityradio.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: ATEM for Ruby
+test_files: []