begin of major change: switching from midi to OSC

1 files changed, 130 insertions, 158 deletions

diff --git a/pkg/mixer/mixer.go b/pkg/mixer/mixer.go
index afa1534..8782765 100644
--- a/pkg/mixer/mixer.go
+++ b/pkg/mixer/mixer.go
@@ -24,20 +24,11 @@ package mixer
 
 import (
 	"container/list"
-	"errors"
 	"fmt"
-	"log"
-	"strings"
+	// "log"
+	"net"
 	"sync"
-	"time"
-
-	"github.com/scgolang/midi"
-)
-
-// TODO: make this configurable
-const (
-	CC_MUTE  = byte(0xB1)
-	CC_FADER = byte(0xB0)
+	//	"github.com/scgolang/osc"
 )
 
 type Channel uint8
@@ -59,21 +50,20 @@ 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)
 )
 
 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)"
@@ -123,38 +113,24 @@ type subscriber struct {
 
 type Mixer struct {
 	config          Config
-	devIn           *midi.Device
-	devOutLock      sync.Mutex
-	devOut          *midi.Device
+	client          *net.UDPConn
+	clientLock      sync.Mutex
 	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 NewMixer(c Config) (*Mixer, error) {
-	devices, err := midi.Devices()
-	if err != nil {
-		return nil, err
+	if c.Port == "" {
+		c.Port = "10023"
 	}
-
-	// TODO: add support for devIn == devOut
 	m := &Mixer{config: c}
-	if m.devIn, err = openDevice(devices, c.DevIn); err != nil {
+
+	server, err := net.ResolveUDPAddr("udp", c.Host+":"+c.Port)
+	if err != nil {
 		return nil, err
 	}
-	m.devIn.QueueSize = 100
-	if m.devOut, err = openDevice(devices, c.DevOut); err != nil {
+	m.client, err = net.DialUDP("udp", nil, server)
+	if err != nil {
 		return nil, err
 	}
 
@@ -162,56 +138,56 @@ func NewMixer(c Config) (*Mixer, error) {
 	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) 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) publishEvent(ev Event) {
 	m.subscribersLock.Lock()
@@ -246,57 +222,53 @@ func (m *Mixer) publishEvent(ev Event) {
 	}
 }
 
-func (m *Mixer) handleMidiPacket(p midi.Packet) {
-	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.Type = EventMute
-		ev.Mute = MuteUnmuted
-		if p.Data[2] > 0 {
-			ev.Mute = MuteMuted
-		}
-	default:
-		return
-	}
-	m.publishEvent(ev)
-}
+// func (m *Mixer) handleMidiPacket(p midi.Packet) {
+// 	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.Type = EventMute
+// 		ev.Mute = MuteUnmuted
+// 		if p.Data[2] > 0 {
+// 			ev.Mute = MuteMuted
+// 		}
+// 	default:
+// 		return
+// 	}
+// 	m.publishEvent(ev)
+// }
 
 func (m *Mixer) Init() error {
-	ch, err := m.devIn.Packets()
-	if err != nil {
-		return err
-	}
-
-	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)
-			}
-		}
-	}()
+	// ch, err := m.devIn.Packets()
+	// if err != nil {
+	// 	return err
+	// }
+
+	// 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)
+	// 		}
+	// 	}
+	// }()
 	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.Close()
+		m.client = nil
 	}
 
 	m.subscribersLock.Lock()
@@ -319,30 +291,30 @@ 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")
-	}
+func (m *Mixer) sendOSCMessage(msg []byte) error {
+	m.clientLock.Lock()
+	defer m.clientLock.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})
+	return nil // m.sendMidiMessage([]byte{CC_MUTE, channel, value})
 }
 
 func (m *Mixer) Mute(ch Channel) error {
@@ -357,7 +329,7 @@ func (m *Mixer) SetLevel(ch Channel, level FaderLevel) error {
 	if level > FaderLevelMax {
 		level = FaderLevelMax
 	}
-	return m.sendMidiMessage([]byte{CC_FADER, byte(ch), byte(level)})
+	return nil // m.sendMidiMessage([]byte{CC_FADER, byte(ch), byte(level)})
 }
 
 func (m *Mixer) Subscribe(ch Channel, out chan<- Event) chan<- struct{} {