Merge branch 'topic/x32-osc'HEADmaster

1 files changed, 169 insertions, 146 deletions

diff --git a/pkg/mixer/mixer.go b/pkg/mixer/mixer.go
index afa1534..dbc4dae 100644
--- a/pkg/mixer/mixer.go
+++ b/pkg/mixer/mixer.go
@@ -27,20 +27,19 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"net"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/scgolang/midi"
+	"github.com/scgolang/osc"
 )
 
-// TODO: make this configurable
 const (
-	CC_MUTE  = byte(0xB1)
-	CC_FADER = byte(0xB0)
+	OSCSubscriptionTimeFactor = 0
 )
 
-type Channel uint8
+type Channel string
 type EventType int
 
 const (
@@ -59,21 +58,21 @@ func (et EventType) String() string {
 	}
 }
 
-type FaderLevel uint8
+type FaderLevel float32
 
-// TODO: make the values configurable
 const (
-	FaderLevelUnknown = FaderLevel(0xFF)
-	FaderLevelMax     = FaderLevel(0x7F)
-	FaderLevel0db     = FaderLevel(0x60)
-	FaderLevelOff     = FaderLevel(0x00)
+	FaderLevelUnknown   = FaderLevel(-1.0)
+	FaderLevelMax       = FaderLevel(1.00)
+	FaderLevel0db       = FaderLevel(0.75)
+	FaderLevelOff       = FaderLevel(0.00)
+	FaderLevelIncrement = FaderLevel(0.01)
 )
 
 func (fl FaderLevel) String() string {
 	if fl > FaderLevelMax {
 		return "unknown"
 	}
-	val := fmt.Sprintf("%3d", fl)
+	val := fmt.Sprintf("%3f", fl)
 	switch fl {
 	case FaderLevelMax:
 		return val + " (max)"
@@ -86,7 +85,7 @@ func (fl FaderLevel) String() string {
 	}
 }
 
-type Mute int8
+type Mute int
 
 const (
 	MuteUnknown = Mute(-1)
@@ -113,7 +112,7 @@ type Event struct {
 }
 
 func (e Event) String() string {
-	return fmt.Sprintf("Event(%s) for channel %d: level=%s, muted=%s", e.Type, e.Channel, e.Level, e.Mute)
+	return fmt.Sprintf("Event(%s) for channel '%s': level=%s, muted=%s", e.Type, e.Channel, e.Level, e.Mute)
 }
 
 type subscriber struct {
@@ -121,96 +120,89 @@ type subscriber struct {
 	unsubscribe <-chan struct{}
 }
 
+type MixerInfo struct {
+	ServerVersion  string
+	ServerName     string
+	ConsoleModel   string
+	ConsoleVersion string
+}
+
 type Mixer struct {
 	config          Config
-	devIn           *midi.Device
-	devOutLock      sync.Mutex
-	devOut          *midi.Device
+	client          *osc.UDPConn
+	info            MixerInfo
 	subscribersLock sync.Mutex
 	subscribers     map[Channel]*list.List
 }
 
-func openDevice(devices []*midi.Device, prefix string) (d *midi.Device, err error) {
-	for _, device := range devices {
-		if strings.HasPrefix(device.Name, prefix) {
-			d = device
-		}
-	}
-	if d == nil {
-		return nil, errors.New("could not find device with prefix: " + prefix)
-	}
-	return d, d.Open()
+func waitForInfo(client *osc.UDPConn, infoCh chan<- MixerInfo, errCh chan<- error) {
+	err := client.Serve(1, osc.PatternMatching{
+		"/info": osc.Method(func(msg osc.Message) (err error) {
+			mi := MixerInfo{}
+			if len(msg.Arguments) != 4 {
+				return errors.New("invalid number of arguments in /info response")
+			}
+			if mi.ServerVersion, err = msg.Arguments[0].ReadString(); err != nil {
+				return
+			}
+			if mi.ServerName, err = msg.Arguments[1].ReadString(); err != nil {
+				return
+			}
+			if mi.ConsoleModel, err = msg.Arguments[2].ReadString(); err != nil {
+				return
+			}
+			if mi.ConsoleVersion, err = msg.Arguments[3].ReadString(); err != nil {
+				return
+			}
+
+			infoCh <- mi
+			return nil
+		}),
+	})
+	errCh <- err
+
+	close(infoCh)
+	close(errCh)
 }
 
 func NewMixer(c Config) (*Mixer, error) {
-	devices, err := midi.Devices()
+	if c.Port == "" {
+		c.Port = "10023"
+	}
+	m := &Mixer{config: c}
+
+	server, err := net.ResolveUDPAddr("udp", c.Host+":"+c.Port)
+	if err != nil {
+		return nil, err
+	}
+	m.client, err = osc.DialUDP("udp", nil, server)
 	if err != nil {
 		return nil, err
 	}
 
-	// TODO: add support for devIn == devOut
-	m := &Mixer{config: c}
-	if m.devIn, err = openDevice(devices, c.DevIn); err != nil {
+	if err = m.client.Send(osc.Message{Address: "/info"}); err != nil {
 		return nil, err
 	}
-	m.devIn.QueueSize = 100
-	if m.devOut, err = openDevice(devices, c.DevOut); err != nil {
+
+	infoCh := make(chan MixerInfo)
+	errCh := make(chan error)
+	go waitForInfo(m.client, infoCh, errCh)
+
+	select {
+	case <-time.After(10 * time.Second):
+		return nil, errors.New("timeout")
+	case err := <-errCh:
 		return nil, err
+	case info := <-infoCh:
+		m.info = info
 	}
 
 	m.subscribers = make(map[Channel]*list.List)
 	return m, nil
 }
 
-func (m *Mixer) reopenInput() {
-	for {
-		time.Sleep(time.Second)
-
-		devices, err := midi.Devices()
-		if err != nil {
-			log.Printf("mixer: error listing midi devices: %v, retrying...", err)
-			continue
-		}
-
-		if m.devIn, err = openDevice(devices, m.config.DevIn); err != nil {
-			log.Printf("mixer: error re-opening midi input device: %v, retrying...", err)
-			continue
-		}
-
-		if err = m.Init(); err != nil {
-			log.Printf("mixer: error re-initializing midi input device: %v, retrying...", err)
-
-			continue
-		}
-
-		log.Printf("mixer: successfully re-initialized midi input device")
-		break
-	}
-}
-
-func (m *Mixer) reopenOutput() {
-	for {
-		time.Sleep(time.Second)
-
-		devices, err := midi.Devices()
-		if err != nil {
-			log.Printf("mixer: error listing midi devices: %v, retrying...", err)
-			continue
-		}
-
-		newOut, err := openDevice(devices, m.config.DevOut)
-		if err != nil {
-			log.Printf("mixer: error re-opening midi output device: %v, retrying...", err)
-			continue
-		}
-
-		log.Printf("mixer: successfully re-opened midi output device")
-
-		m.devOutLock.Lock()
-		defer m.devOutLock.Unlock()
-		m.devOut = newOut
-		break
-	}
+func (m *Mixer) String() string {
+	return fmt.Sprintf("Model %s (Firmware-Version: %s)", m.info.ConsoleModel, m.info.ConsoleVersion)
 }
 
 func (m *Mixer) publishEvent(ev Event) {
@@ -246,57 +238,86 @@ func (m *Mixer) publishEvent(ev Event) {
 	}
 }
 
-func (m *Mixer) handleMidiPacket(p midi.Packet) {
+type oscDispatcher struct {
+	mixer *Mixer
+}
+
+func (d oscDispatcher) Dispatch(bundle osc.Bundle, exactMatch bool) error {
+	// TODO: X32 seems to not use bundles at the momemnt - ingoring them for now
+	return nil
+}
+
+func (d oscDispatcher) Invoke(msg osc.Message, exactMatch bool) error {
+	addrParts := strings.Split(strings.TrimPrefix(msg.Address, "/"), "/")
+	if len(addrParts) < 4 {
+		return nil
+	}
+	if addrParts[2] != "mix" {
+		return nil
+	}
+	if len(msg.Arguments) != 1 {
+		return nil
+	}
+
 	ev := Event{Level: FaderLevelUnknown, Mute: MuteUnknown}
-	ev.Channel = Channel(p.Data[1])
-	switch p.Data[0] {
-	case CC_FADER:
-		ev.Type = EventFaderChange
-		ev.Level = FaderLevel(p.Data[2])
-	case CC_MUTE:
+	ev.Channel = Channel(addrParts[0] + "/" + addrParts[1])
+	switch addrParts[3] {
+	case "on":
 		ev.Type = EventMute
-		ev.Mute = MuteUnmuted
-		if p.Data[2] > 0 {
+		arg, err := msg.Arguments[0].ReadInt32()
+		if err != nil {
+			return err
+		}
+		if arg == 0 {
 			ev.Mute = MuteMuted
+		} else {
+			ev.Mute = MuteUnmuted
+		}
+	case "fader":
+		ev.Type = EventFaderChange
+		arg, err := msg.Arguments[0].ReadFloat32()
+		if err != nil {
+			return err
 		}
+		ev.Level = FaderLevel(arg)
 	default:
-		return
+		return nil
 	}
-	m.publishEvent(ev)
+
+	d.mixer.publishEvent(ev)
+	return nil
 }
 
 func (m *Mixer) Init() error {
-	ch, err := m.devIn.Packets()
-	if err != nil {
-		return err
-	}
+	go func() {
+		for {
+			dispatcher := oscDispatcher{mixer: m}
+			err := m.client.Serve(1, dispatcher)
+			if err != nil {
+				log.Printf("mixer: failed to dispatch message: %v", err)
+				time.Sleep(time.Second)
+			}
+		}
+	}()
 
 	go func() {
 		for {
-			ps := <-ch
-			for _, p := range ps {
-				if p.Err != nil {
-					log.Printf("mixer: got fatal error from midi input device: %v, trying to reopen it...", p.Err)
-					m.devIn.Close()
-					m.devIn = nil
-					go m.reopenInput()
-					return
-				}
-				m.handleMidiPacket(p)
+			time.Sleep(5 * time.Second)
+			err := m.client.Send(osc.Message{Address: "/renew"})
+			if err != nil {
+				log.Printf("mixer: failed to renew subsciptions: %v", err)
 			}
 		}
 	}()
+
 	return nil
 }
 
 func (m *Mixer) Shutdown() error {
-	if m.devIn != nil {
-		m.devIn.Close()
-		m.devIn = nil
-	}
-	if m.devOut != nil {
-		m.devOut.Close()
-		m.devOut = nil
+	if m.client != nil {
+		m.client.Send(osc.Message{Address: "/unsubscribe"})
+		m.client.Close()
+		m.client = nil
 	}
 
 	m.subscribersLock.Lock()
@@ -319,59 +340,61 @@ func (m *Mixer) Shutdown() error {
 	return nil
 }
 
-func (m *Mixer) sendMidiMessage(msg []byte) error {
-	m.devOutLock.Lock()
-	defer m.devOutLock.Unlock()
-
-	if m.devOut == nil {
-		return errors.New("mixer: output device is not ready.")
-	}
-
-	n, err := m.devOut.Write(msg)
-	if err != nil {
-		log.Printf("mixer: got fatal error from midi output device: %v, trying to reopen it...", err)
-		m.devOut.Close()
-		m.devOut = nil
-		go m.reopenOutput()
-		return err
-	}
-	if n != len(msg) {
-		return errors.New("sending midi message failed: short write")
-	}
-	return nil
-}
-
-func (m *Mixer) sendMute(channel byte, value byte) error {
-	return m.sendMidiMessage([]byte{CC_MUTE, channel, value})
+func (m *Mixer) sendMute(channel Channel, value string) error {
+	msg := osc.Message{Address: "/" + string(channel) + "/mix/on"}
+	msg.Arguments = append(msg.Arguments, osc.String(value))
+	return m.client.Send(msg)
 }
 
 func (m *Mixer) Mute(ch Channel) error {
-	return m.sendMute(byte(ch), 0x7F)
+	return m.sendMute(ch, "OFF")
 }
 
 func (m *Mixer) Unmute(ch Channel) error {
-	return m.sendMute(byte(ch), 0x00)
+	return m.sendMute(ch, "ON")
 }
 
-func (m *Mixer) SetLevel(ch Channel, level FaderLevel) error {
+func (m *Mixer) SetLevel(channel Channel, level FaderLevel) error {
 	if level > FaderLevelMax {
 		level = FaderLevelMax
 	}
-	return m.sendMidiMessage([]byte{CC_FADER, byte(ch), byte(level)})
+	msg := osc.Message{Address: "/" + string(channel) + "/mix/fader"}
+	msg.Arguments = append(msg.Arguments, osc.Float(level))
+	return m.client.Send(msg)
 }
 
-func (m *Mixer) Subscribe(ch Channel, out chan<- Event) chan<- struct{} {
+func (m *Mixer) sendSubscribe(channel Channel) (err error) {
+	msg := osc.Message{Address: "/subscribe"}
+	msg.Arguments = append(msg.Arguments, osc.String("/"+string(channel)+"/mix/on"), osc.Int(OSCSubscriptionTimeFactor))
+	if err = m.client.Send(msg); err != nil {
+		return
+	}
+
+	msg = osc.Message{Address: "/subscribe"}
+	msg.Arguments = append(msg.Arguments, osc.String("/"+string(channel)+"/mix/fader"), osc.Int(OSCSubscriptionTimeFactor))
+	if err = m.client.Send(msg); err != nil {
+		return
+	}
+
+	return
+}
+
+func (m *Mixer) Subscribe(channel Channel, out chan<- Event) (chan<- struct{}, error) {
 	m.subscribersLock.Lock()
 	defer m.subscribersLock.Unlock()
 
-	subs, exists := m.subscribers[ch]
+	subs, exists := m.subscribers[channel]
 	if !exists {
 		subs = list.New()
-		m.subscribers[ch] = subs
+		m.subscribers[channel] = subs
+	}
+
+	if err := m.sendSubscribe(channel); err != nil {
+		return nil, err
 	}
 
 	// log.Printf("mixer: subscribing '%v' to events for channel: %v", out, ch)
 	unsubscribe := make(chan struct{})
 	subs.PushBack(subscriber{publish: out, unsubscribe: unsubscribe})
-	return unsubscribe
+	return unsubscribe, nil
 }