implement {Comp} threshold, ratio, attack, hold, release, makeup and mix methods

add new compressor subcommands to strip/bus command groups

internal/xair/comp.go

@@ -48,3 +48,162 @@ func (c *Comp) SetOn(index int, on bool) error {
 	}
 	return c.client.SendMessage(address, value)
 }
+
+// Threshold retrieves the threshold value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Threshold(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/thr"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor threshold value")
+	}
+	return linGet(-60, 0, float64(val)), nil
+}
+
+// SetThreshold sets the threshold value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetThreshold(index int, threshold float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/thr"
+	return c.client.SendMessage(address, float32(linSet(-60, 0, threshold)))
+}
+
+// Ratio retrieves the ratio value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Ratio(index int) (float32, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/ratio"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	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)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor ratio value")
+	}
+
+	return possibleValues[val], nil
+}
+
+// SetRatio sets the ratio value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetRatio(index int, ratio float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/ratio"
+	possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100}
+
+	return c.client.SendMessage(address, int32(indexOf(possibleValues, float32(ratio))))
+}
+
+// Attack retrieves the attack time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Attack(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/attack"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor attack value")
+	}
+	return linGet(0, 120, float64(val)), nil
+}
+
+// SetAttack sets the attack time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetAttack(index int, attack float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/attack"
+	return c.client.SendMessage(address, float32(linSet(0, 120, attack)))
+}
+
+// Hold retrieves the hold time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Hold(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/hold"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor hold value")
+	}
+	return logGet(0.02, 2000, float64(val)), nil
+}
+
+// SetHold sets the hold time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetHold(index int, hold float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/hold"
+	return c.client.SendMessage(address, float32(logSet(0.02, 2000, hold)))
+}
+
+// Release retrieves the release time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Release(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/release"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor release value")
+	}
+	return logGet(4, 4000, float64(val)), nil
+}
+
+// SetRelease sets the release time of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetRelease(index int, release float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/release"
+	return c.client.SendMessage(address, float32(logSet(4, 4000, release)))
+}
+
+// MakeUp retrieves the make-up gain of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) MakeUp(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mgain"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor make-up gain value")
+	}
+	return linGet(0, 24, float64(val)), nil
+}
+
+// SetMakeUp sets the make-up gain of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetMakeUp(index int, makeUp float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mgain"
+	return c.client.SendMessage(address, float32(linSet(0, 24, makeUp)))
+}
+
+// Mix retrieves the mix value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) Mix(index int) (float64, error) {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mix"
+	err := c.client.SendMessage(address)
+	if err != nil {
+		return 0, err
+	}
+
+	resp := <-c.client.respChan
+	val, ok := resp.Arguments[0].(float32)
+	if !ok {
+		return 0, fmt.Errorf("unexpected argument type for Compressor mix value")
+	}
+	return linGet(0, 100, float64(val)), nil
+}
+
+// SetMix sets the mix value of the Compressor for a specific strip or bus (1-based indexing).
+func (c *Comp) SetMix(index int, mix float64) error {
+	address := fmt.Sprintf(c.baseAddress, index) + "/dyn/mix"
+	return c.client.SendMessage(address, float32(linSet(0, 100, mix)))
+}

internal/xair/util.go

@@ -56,3 +56,13 @@ func toFixed(num float64, precision int) float64 {
 	output := math.Pow(10, float64(precision))
 	return float64(math.Round(num*output)) / output
 }
+
+// generic indexOf returns the index of elem in slice, or -1 if not found.
+func indexOf[T comparable](slice []T, elem T) int {
+	for i, v := range slice {
+		if v == elem {
+			return i
+		}
+	}
+	return -1
+}