mux: fix the volume ramp dividing integers and going NaN

[kumagi]

What issue is this addressing?

No issue filed yet. Found during an audit of the mux package.

What type of issue is this addressing?

bug

What this PR does | solves

(*playerImpl).readBufferAndAdd computed the volume ramp denominator as:

rateDenom := float32(n / channelCount) // integer division

n is the number of samples to mix and channelCount the number of channels. When a playing buffer holds fewer samples than channels (n < channelCount, e.g. a stereo player with a single sample left in its buffer — realistic with a small SetBufferSize), n / channelCount is 0, so rateDenom is 0.

During a volume transition (volume != prevVolume), the ramp rate is then:

rate := float32(i/channelCount) / rateDenom // = x/0 = +Inf, and 0/0 = NaN for i=0

volume*Inf + prevVolume*(-Inf) is NaN, so every sample of the ramp becomes NaN. The mixing loop drops non-finite values to protect other players, so the entire ramp is dropped and the player outputs silence until the next SetVolume.

Reproduction

The following test passes on main (demonstrating the bug) and fails without this change:

package mux

import (
	"math"
	"testing"
	"time"
)

type loudReader struct{}

func (loudReader) Read(p []byte) (int, error) {
	for i := range p {
		if i%4 < 2 {
			p[i] = 0xff // 16-bit stereo, 0x7fff = 0.99997
		} else {
			p[i] = 0x7f
		}
	}
	return len(p), nil
}

func TestVolumeRampNaN(t *testing.T) {
	m := New(48000, 2, FormatSignedInt16LE)
	p := m.NewPlayer(loudReader{})
	p.SetBufferSize(4) // one stereo sample
	p.Play()
	deadline := time.Now().Add(5 * time.Second)
	for p.BufferedSize() < 4 {
		if time.Now().After(deadline) {
			t.Fatal("buffer never filled")
		}
		time.Sleep(time.Millisecond)
	}
	p.SetVolume(0.5) // while playing: prevVolume (1) != volume (0.5)
	buf := make([]float32, 2)
	m.ReadFloat32s(buf)
	for i, v := range buf {
		if v == 0 || math.IsNaN(float64(v)) {
			t.Errorf("buf[%d] = %v: sample dropped by NaN ramp", i, v)
		}
	}
}

On main, both samples come out as 0 (dropped). With this PR, they are ±0.49998… as expected.

The fix

Divide floats:

rateDenom := float32(n) / float32(channelCount)

The float32(i/channelCount) numerator is left as is: it is a per-frame index and the integer division there is intentional.

[hajimehoshi]

LGTM

[hajimehoshi]

Can we have tests?

[kumagi]

Thanks for the review! I added a test as requested: TestVolumeRampWithFewerSamplesThanChannelsDoesNotSilence in internal/mux/mux_test.go. It deterministically exercises readBufferAndAdd (via a small export_test.go helper that primes a player with buffered data and a volume ramp) for a stereo player with a single sample or a partial frame left in its buffer, and for a quadrophonic player with a single sample. Each mixed sample is asserted to be finite and within the expected ramp range, so the test fails with the old integer division (the ramp becomes NaN and the samples are dropped to silence) and passes with the float division.

[kumagi]

Thanks for the review! I updated the test so the table entries use explicit member names, written across multiple lines, instead of positional literals. The behavior is unchanged: the test still fails with the old float32(n / channelCount) (the ramp becomes NaN and every sample is dropped to silence) and passes with the float division. go build ./..., go vet ./..., gofmt, and go test ./internal/mux/ are all clean.