diff --git a/internal/xair/bus.go b/internal/xair/bus.go index 8dc50a7..e5f63af 100644 --- a/internal/xair/bus.go +++ b/internal/xair/bus.go @@ -26,8 +26,11 @@ func (b *Bus) Mute(bus int) (bool, error) { return false, err } - resp := <-b.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := b.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for bus mute value") } @@ -52,8 +55,11 @@ func (b *Bus) Fader(bus int) (float64, error) { return 0, err } - resp := <-b.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := b.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for bus fader value") } @@ -75,8 +81,11 @@ func (b *Bus) Name(bus int) (string, error) { return "", fmt.Errorf("failed to send bus name request: %v", err) } - resp := <-b.client.respChan - val, ok := resp.Arguments[0].(string) + msg, err := b.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(string) if !ok { return "", fmt.Errorf("unexpected argument type for bus name value") } diff --git a/internal/xair/client.go b/internal/xair/client.go index a9298b2..ad0345a 100644 --- a/internal/xair/client.go +++ b/internal/xair/client.go @@ -41,6 +41,7 @@ func NewClient(mixerIP string, mixerPort int, opts ...Option) (*Client, error) { e := &engine{ Kind: KindXAir, + timeout: 100 * time.Millisecond, conn: conn, mixerAddr: mixerAddr, parser: newParser(), @@ -85,32 +86,35 @@ func (c *Client) SendMessage(address string, args ...any) error { } // ReceiveMessage receives an OSC message from the mixer -func (c *Client) ReceiveMessage(timeout time.Duration) (*osc.Message, error) { - t := time.Tick(timeout) +func (c *Client) ReceiveMessage() (*osc.Message, error) { + t := time.Tick(c.engine.timeout) select { case <-t: - return nil, nil - case val := <-c.respChan: - if val == nil { + return nil, fmt.Errorf("timeout waiting for response") + case msg := <-c.respChan: + if msg == nil { return nil, fmt.Errorf("no message received") } - return val, nil + return msg, nil } } // RequestInfo requests mixer information func (c *Client) RequestInfo() (InfoResponse, error) { + var info InfoResponse err := c.SendMessage("/xinfo") if err != nil { - return InfoResponse{}, err + return info, err } - val := <-c.respChan - var info InfoResponse - if len(val.Arguments) >= 3 { - info.Host = val.Arguments[0].(string) - info.Name = val.Arguments[1].(string) - info.Model = val.Arguments[2].(string) + msg, err := c.ReceiveMessage() + if err != nil { + return info, err + } + if len(msg.Arguments) >= 3 { + info.Host = msg.Arguments[0].(string) + info.Name = msg.Arguments[1].(string) + info.Model = msg.Arguments[2].(string) } return info, nil } diff --git a/internal/xair/comp.go b/internal/xair/comp.go index bbc84ae..5589be1 100644 --- a/internal/xair/comp.go +++ b/internal/xair/comp.go @@ -31,8 +31,11 @@ func (c *Comp) On(index int) (bool, error) { return false, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for Compressor on value") } @@ -59,8 +62,11 @@ func (c *Comp) Mode(index int) (string, error) { possibleModes := []string{"comp", "exp"} - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(int32) if !ok { return "", fmt.Errorf("unexpected argument type for Compressor mode value") } @@ -82,8 +88,11 @@ func (c *Comp) Threshold(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor threshold value") } @@ -106,8 +115,11 @@ func (c *Comp) Ratio(index int) (float32, error) { possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100} - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor ratio value") } @@ -131,8 +143,11 @@ func (c *Comp) Attack(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor attack value") } @@ -153,8 +168,11 @@ func (c *Comp) Hold(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor hold value") } @@ -175,8 +193,11 @@ func (c *Comp) Release(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor release value") } @@ -197,8 +218,11 @@ func (c *Comp) Makeup(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor makeup gain value") } @@ -219,8 +243,11 @@ func (c *Comp) Mix(index int) (float64, error) { return 0, err } - resp := <-c.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := c.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Compressor mix value") } diff --git a/internal/xair/engine.go b/internal/xair/engine.go index 19c352a..4099c92 100644 --- a/internal/xair/engine.go +++ b/internal/xair/engine.go @@ -15,6 +15,7 @@ type parser interface { type engine struct { Kind MixerKind + timeout time.Duration conn *net.UDPConn mixerAddr *net.UDPAddr @@ -34,7 +35,7 @@ func (e *engine) receiveLoop() { case <-e.done: return default: - // Set read timeout to avoid blocking forever + // Set a short read deadline to prevent blocking indefinitely e.conn.SetReadDeadline(time.Now().Add(100 * time.Millisecond)) n, _, err := e.conn.ReadFromUDP(buffer) if err != nil { diff --git a/internal/xair/eq.go b/internal/xair/eq.go index a5b826e..7c90f7b 100644 --- a/internal/xair/eq.go +++ b/internal/xair/eq.go @@ -31,8 +31,11 @@ func (e *Eq) On(index int) (bool, error) { return false, err } - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for EQ on value") } @@ -58,8 +61,11 @@ func (e *Eq) Mode(index int) (string, error) { possibleModes := []string{"peq", "geq", "teq"} - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(int32) if !ok { return "", fmt.Errorf("unexpected argument type for EQ mode value") } @@ -80,8 +86,11 @@ func (e *Eq) Gain(index int, band int) (float64, error) { return 0, err } - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for EQ gain value") } @@ -102,8 +111,11 @@ func (e *Eq) Frequency(index int, band int) (float64, error) { return 0, err } - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for EQ frequency value") } @@ -124,8 +136,11 @@ func (e *Eq) Q(index int, band int) (float64, error) { return 0, err } - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for EQ Q value") } @@ -148,8 +163,11 @@ func (e *Eq) Type(index int, band int) (string, error) { possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"} - resp := <-e.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := e.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(int32) if !ok { return "", fmt.Errorf("unexpected argument type for EQ type value") } diff --git a/internal/xair/gate.go b/internal/xair/gate.go index 045e163..96d5556 100644 --- a/internal/xair/gate.go +++ b/internal/xair/gate.go @@ -19,8 +19,11 @@ func (g *Gate) On(index int) (bool, error) { return false, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for Gate on value") } @@ -47,8 +50,11 @@ func (g *Gate) Mode(index int) (string, error) { possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"} - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(int32) if !ok { return "", fmt.Errorf("unexpected argument type for Gate mode value") } @@ -71,8 +77,11 @@ func (g *Gate) Threshold(index int) (float64, error) { return 0, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Gate threshold value") } @@ -93,8 +102,11 @@ func (g *Gate) Range(index int) (float64, error) { return 0, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Gate range value") } @@ -115,8 +127,11 @@ func (g *Gate) Attack(index int) (float64, error) { return 0, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Gate attack value") } @@ -137,8 +152,11 @@ func (g *Gate) Hold(index int) (float64, error) { return 0, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Gate hold value") } @@ -159,8 +177,11 @@ func (g *Gate) Release(index int) (float64, error) { return 0, err } - resp := <-g.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := g.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for Gate release value") } diff --git a/internal/xair/headamp.go b/internal/xair/headamp.go index 192a2ce..10d1b24 100644 --- a/internal/xair/headamp.go +++ b/internal/xair/headamp.go @@ -22,8 +22,11 @@ func (h *HeadAmp) Gain(index int) (float64, error) { return 0, err } - resp := <-h.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := h.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for headamp gain value") } @@ -45,8 +48,11 @@ func (h *HeadAmp) PhantomPower(index int) (bool, error) { return false, err } - resp := <-h.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := h.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for phantom power value") } diff --git a/internal/xair/main.go b/internal/xair/main.go index dc4a192..e680136 100644 --- a/internal/xair/main.go +++ b/internal/xair/main.go @@ -31,8 +31,11 @@ func (m *Main) Fader() (float64, error) { return 0, err } - resp := <-m.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := m.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for main LR fader value") } @@ -53,8 +56,11 @@ func (m *Main) Mute() (bool, error) { return false, err } - resp := <-m.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := m.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for main LR mute value") } diff --git a/internal/xair/option.go b/internal/xair/option.go index 38be1dd..02161f0 100644 --- a/internal/xair/option.go +++ b/internal/xair/option.go @@ -1,5 +1,7 @@ package xair +import "time" + type Option func(*engine) func WithKind(kind string) Option { @@ -8,3 +10,9 @@ func WithKind(kind string) Option { e.addressMap = addressMapForMixerKind(e.Kind) } } + +func WithTimeout(timeout time.Duration) Option { + return func(e *engine) { + e.timeout = timeout + } +} diff --git a/internal/xair/snapshot.go b/internal/xair/snapshot.go index 5f67236..dfce3c1 100644 --- a/internal/xair/snapshot.go +++ b/internal/xair/snapshot.go @@ -22,8 +22,11 @@ func (s *Snapshot) Name(index int) (string, error) { return "", err } - resp := <-s.client.respChan - name, ok := resp.Arguments[0].(string) + msg, err := s.client.ReceiveMessage() + if err != nil { + return "", err + } + name, ok := msg.Arguments[0].(string) if !ok { return "", fmt.Errorf("unexpected argument type for snapshot name") } diff --git a/internal/xair/strip.go b/internal/xair/strip.go index 5d7561b..8b4fecb 100644 --- a/internal/xair/strip.go +++ b/internal/xair/strip.go @@ -28,8 +28,11 @@ func (s *Strip) Mute(index int) (bool, error) { return false, err } - resp := <-s.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := s.client.ReceiveMessage() + if err != nil { + return false, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return false, fmt.Errorf("unexpected argument type for strip mute value") } @@ -54,8 +57,11 @@ func (s *Strip) Fader(strip int) (float64, error) { return 0, err } - resp := <-s.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := s.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for fader value") } @@ -77,8 +83,11 @@ func (s *Strip) Name(strip int) (string, error) { return "", fmt.Errorf("failed to send strip name request: %v", err) } - resp := <-s.client.respChan - val, ok := resp.Arguments[0].(string) + msg, err := s.client.ReceiveMessage() + if err != nil { + return "", err + } + val, ok := msg.Arguments[0].(string) if !ok { return "", fmt.Errorf("unexpected argument type for strip name value") } @@ -99,8 +108,11 @@ func (s *Strip) Color(strip int) (int32, error) { return 0, fmt.Errorf("failed to send strip color request: %v", err) } - resp := <-s.client.respChan - val, ok := resp.Arguments[0].(int32) + msg, err := s.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(int32) if !ok { return 0, fmt.Errorf("unexpected argument type for strip color value") } @@ -121,8 +133,11 @@ func (s *Strip) SendLevel(strip int, bus int) (float64, error) { return 0, fmt.Errorf("failed to send strip send level request: %v", err) } - resp := <-s.client.respChan - val, ok := resp.Arguments[0].(float32) + msg, err := s.client.ReceiveMessage() + if err != nil { + return 0, err + } + val, ok := msg.Arguments[0].(float32) if !ok { return 0, fmt.Errorf("unexpected argument type for strip send level value") } diff --git a/main.go b/main.go index efde130..aaff3ad 100644 --- a/main.go +++ b/main.go @@ -6,6 +6,7 @@ import ( "os" "runtime/debug" "strings" + "time" "github.com/alecthomas/kong" "github.com/charmbracelet/log" @@ -32,9 +33,10 @@ type context struct { } type Config struct { - Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST" short:"H"` - Port int `default:"10024" help:"The port of the X-Air device." env:"XAIR_CLI_PORT" short:"P"` - Kind string `default:"xair" help:"The kind of the X-Air device." env:"XAIR_CLI_KIND" short:"K" enum:"xair,x32"` + Host string `default:"mixer.local" help:"The host of the X-Air device." env:"XAIR_CLI_HOST" short:"H"` + Port int `default:"10024" help:"The port of the X-Air device." env:"XAIR_CLI_PORT" short:"P"` + Kind string `default:"xair" help:"The kind of the X-Air device." env:"XAIR_CLI_KIND" short:"K" enum:"xair,x32"` + Timeout time.Duration `default:"100ms" help:"Timeout for OSC operations." env:"XAIR_CLI_TIMEOUT" short:"T"` } // CLI is the main struct for the command-line interface. @@ -107,7 +109,12 @@ func run(ctx *kong.Context, config Config) error { // connect creates a new X-Air client based on the provided configuration. func connect(config Config) (*xair.Client, error) { - client, err := xair.NewClient(config.Host, config.Port, xair.WithKind(config.Kind)) + client, err := xair.NewClient( + config.Host, + config.Port, + xair.WithKind(config.Kind), + xair.WithTimeout(config.Timeout), + ) if err != nil { return nil, err } diff --git a/raw.go b/raw.go index a016cd2..bdb6309 100644 --- a/raw.go +++ b/raw.go @@ -2,14 +2,14 @@ package main import ( "fmt" - "time" + + "github.com/charmbracelet/log" ) // RawCmd represents the command to send raw OSC messages to the mixer. type RawCmd struct { - Timeout time.Duration `help:"Timeout for the OSC message send operation." default:"100ms" short:"t" env:"XAIR_CLI_RAW_TIMEOUT"` - Address string `help:"The OSC address to send the message to." arg:""` - Args []string `help:"The arguments to include in the OSC message." arg:"" optional:""` + Address string `help:"The OSC address to send the message to." arg:""` + Args []string `help:"The arguments to include in the OSC message." arg:"" optional:""` } // Run executes the RawCmd by sending the specified OSC message to the mixer and optionally waiting for a response. @@ -22,7 +22,12 @@ func (cmd *RawCmd) Run(ctx *context) error { return fmt.Errorf("failed to send raw OSC message: %w", err) } - msg, err := ctx.Client.ReceiveMessage(cmd.Timeout) + if len(params) > 0 { + log.Debugf("Sent OSC message: %s with args: %v\n", cmd.Address, cmd.Args) + return nil + } + + msg, err := ctx.Client.ReceiveMessage() if err != nil { return fmt.Errorf("failed to receive response for raw OSC message: %w", err) }