diff options
Diffstat (limited to 'pkg')
| -rw-r--r-- | pkg/mixer/config.go | 4 | ||||
| -rw-r--r-- | pkg/mixer/mixer.go | 315 |
2 files changed, 171 insertions, 148 deletions
diff --git a/pkg/mixer/config.go b/pkg/mixer/config.go index bc0a292..e25ba2e 100644 --- a/pkg/mixer/config.go +++ b/pkg/mixer/config.go @@ -23,6 +23,6 @@ package mixer type Config struct { - DevIn string `json:"dev-in" yaml:"dev-in" toml:"dev-in"` - DevOut string `json:"dev-out" yaml:"dev-out" toml:"dev-out"` + Host string `json:"host" yaml:"host" toml:"host"` + Port string `json:"port" yaml:"port" toml:"port"` } 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 } |