Merge pull request #1 from gotracker/alloc-reductions-and-go1.18

Upgrade to go 1.18 and reduce memory allocs

Author: heucuva

go.mod

@@ -1,3 +1,3 @@
 module github.com/gotracker/gomixing
 
-go 1.15
+go 1.18

mixing/mixbuffer.go

@@ -9,9 +9,6 @@ import (
 	"github.com/gotracker/gomixing/volume"
 )
 
-// ChannelMixBuffer is a single channel's premixed volume data
-type ChannelMixBuffer volume.Matrix
-
 // SampleMixIn is the parameters for mixing in a sample into a MixBuffer
 type SampleMixIn struct {
 	Sample    sampling.Sampler
@@ -24,7 +21,7 @@ type SampleMixIn struct {
 // MixBuffer is a buffer of premixed volume data intended to
 // be eventually sent out to the sound output device after
 // conversion to the output format
-type MixBuffer []ChannelMixBuffer
+type MixBuffer []volume.Matrix
 
 // C returns a channel and a function that flushes any outstanding mix-ins and closes the channel
 func (m *MixBuffer) C() (chan<- SampleMixIn, func()) {
@@ -46,39 +43,35 @@ func (m *MixBuffer) C() (chan<- SampleMixIn, func()) {
 func (m *MixBuffer) MixInSample(d SampleMixIn) {
 	pos := d.MixPos
 	for i := 0; i < d.MixLen; i++ {
-		sdata := d.Sample.GetSample()
-		samp := sdata.ApplyInSitu(d.StaticVol)
-		mixed := d.VolMatrix.Apply(samp...)
-		for c, s := range mixed {
-			(*m)[c][pos] += s
-		}
+		dry := d.Sample.GetSample()
+		samp := dry.Apply(d.StaticVol)
+		mixed := d.VolMatrix.ApplyToMatrix(samp)
+		(*m)[pos].Accumulate(mixed)
 		pos++
 		d.Sample.Advance()
 	}
 }
 
 // Add will mix in another MixBuffer's data
-func (m *MixBuffer) Add(pos int, rhs MixBuffer, volMtx volume.Matrix) {
-	sdata := make(volume.Matrix, len(*m))
-	for i := 0; i < len(rhs[0]); i++ {
-		for c := 0; c < len(rhs); c++ {
-			sdata[c] = rhs[c][i]
-		}
-		sd := volMtx.Apply(sdata...)
-		for c, s := range sd {
-			(*m)[c][pos+i] += s
-		}
+func (m *MixBuffer) Add(pos int, rhs *MixBuffer, volMtx volume.Matrix) {
+	maxLen := len(*rhs)
+	for i := 0; i < maxLen; i++ {
+		out := volMtx.ApplyToMatrix(volume.Matrix((*rhs)[i]))
+		(*m)[pos+i].Accumulate(out)
 	}
 }
 
 // ToRenderData converts a mixbuffer into a byte stream intended to be
 // output to the output sound device
-func (m *MixBuffer) ToRenderData(samples int, bitsPerSample int, mixerVolume volume.Volume) []byte {
+func (m *MixBuffer) ToRenderData(samples int, bitsPerSample int, channels int, mixerVolume volume.Volume) []byte {
 	writer := &bytes.Buffer{}
-	for i := 0; i < samples; i++ {
-		for _, buf := range *m {
-			v := buf[i] * mixerVolume
-			val := v.ToSample(bitsPerSample)
+	writer.Grow(samples * ((bitsPerSample + 7) / 8) * channels)
+	for _, samp := range *m {
+		buf := samp.Apply(mixerVolume)
+		var d volume.StaticMatrix
+		buf.ToChannels(channels, d[:])
+		for i := 0; i < channels; i++ {
+			val := d[i].ToSample(bitsPerSample)
 			_ = binary.Write(writer, binary.LittleEndian, val) // lint
 		}
 	}
@@ -92,10 +85,12 @@ func (m *MixBuffer) ToIntStream(outputChannels int, samples int, bitsPerSample i
 	for c := range data {
 		data[c] = make([]int32, samples)
 	}
-	for i := 0; i < samples; i++ {
-		for c, buf := range *m {
-			v := buf[i] * mixerVolume
-			data[c][i] = v.ToIntSample(bitsPerSample)
+	for i, samp := range *m {
+		buf := samp.Apply(mixerVolume)
+		var d volume.StaticMatrix
+		buf.ToChannels(outputChannels, d[:])
+		for c := 0; c < outputChannels; c++ {
+			data[c][i] = d[c].ToIntSample(bitsPerSample)
 		}
 	}
 	return data
@@ -107,8 +102,9 @@ func (m *MixBuffer) ToRenderDataWithBufs(outBuffers [][]byte, samples int, bitsP
 	pos := 0
 	onum := 0
 	out := outBuffers[onum]
-	for i := 0; i < samples; i++ {
-		for _, buf := range *m {
+	for _, samp := range *m {
+		buf := samp.Apply(mixerVolume)
+		for c := 0; c < buf.Channels; c++ {
 			for pos >= len(out) {
 				onum++
 				if onum > len(outBuffers) {
@@ -117,8 +113,7 @@ func (m *MixBuffer) ToRenderDataWithBufs(outBuffers [][]byte, samples int, bitsP
 				out = outBuffers[onum]
 				pos = 0
 			}
-			v := buf[i] * mixerVolume
-			val := v.ToSample(bitsPerSample)
+			val := buf.StaticMatrix[c].ToSample(bitsPerSample)
 			switch d := val.(type) {
 			case int8:
 				out[pos] = uint8(d)

mixing/mixer.go

@@ -11,11 +11,7 @@ type Mixer struct {
 // NewMixBuffer returns a mixer buffer with a number of channels
 // of preallocated sample data
 func (m *Mixer) NewMixBuffer(samples int) MixBuffer {
-	mb := make(MixBuffer, m.Channels)
-	for i := range mb {
-		mb[i] = make(ChannelMixBuffer, samples)
-	}
-	return mb
+	return make(MixBuffer, samples)
 }
 
 // GetDefaultMixerVolume returns the default mixer volume value based on the number of mixed channels
@@ -34,13 +30,13 @@ func (m *Mixer) Flatten(panmixer PanMixer, samplesLen int, row []ChannelData, mi
 				cdata.Flush()
 			}
 			if len(cdata.Data) > 0 {
-				volMtx := cdata.Volume.Apply(panmixer.GetMixingMatrix(cdata.Pan)...)
-				data.Add(pos, cdata.Data, volMtx)
+				volMtx := panmixer.GetMixingMatrix(cdata.Pan).Apply(cdata.Volume)
+				data.Add(pos, &cdata.Data, volMtx)
 			}
 			pos += cdata.SamplesLen
 		}
 	}
-	return data.ToRenderData(samplesLen, m.BitsPerSample, mixerVolume)
+	return data.ToRenderData(samplesLen, m.BitsPerSample, m.Channels, mixerVolume)
 }
 
 // FlattenToInts runs a flatten on the channel data into separate channel data of int32 variety
@@ -54,13 +50,13 @@ func (m *Mixer) FlattenToInts(panmixer PanMixer, samplesLen int, row []ChannelDa
 				cdata.Flush()
 			}
 			if len(cdata.Data) > 0 {
-				volMtx := cdata.Volume.Apply(panmixer.GetMixingMatrix(cdata.Pan)...)
-				data.Add(pos, cdata.Data, volMtx)
+				volMtx := panmixer.GetMixingMatrix(cdata.Pan).Apply(cdata.Volume)
+				data.Add(pos, &cdata.Data, volMtx)
 			}
 			pos += cdata.SamplesLen
 		}
 	}
-	return data.ToIntStream(panmixer.Channels(), samplesLen, m.BitsPerSample, mixerVolume)
+	return data.ToIntStream(panmixer.NumChannels(), samplesLen, m.BitsPerSample, mixerVolume)
 }
 
 // FlattenTo will to a final saturation mix of all the row's channel data into a single output buffer
@@ -77,8 +73,8 @@ func (m *Mixer) FlattenTo(resultBuffers [][]byte, panmixer PanMixer, samplesLen
 				maxLen = cdata.SamplesLen
 			}
 			if len(cdata.Data) > 0 {
-				volMtx := cdata.Volume.Apply(panmixer.GetMixingMatrix(cdata.Pan)...)
-				data.Add(pos, cdata.Data, volMtx)
+				volMtx := panmixer.GetMixingMatrix(cdata.Pan).Apply(cdata.Volume)
+				data.Add(pos, &cdata.Data, volMtx)
 			}
 		}
 		pos += maxLen

mixing/panmixer.go

@@ -1,83 +1,14 @@
 package mixing
 
 import (
-	"math"
-
 	"github.com/gotracker/gomixing/panning"
 	"github.com/gotracker/gomixing/volume"
 )
 
 // PanMixer is a mixer that's specialized for mixing multichannel audio content
 type PanMixer interface {
 	GetMixingMatrix(panning.Position) volume.Matrix
-	Channels() int
-}
-
-var (
-	// PanMixerMono is a mixer that's specialized for mixing monaural audio content
-	PanMixerMono PanMixer = &panMixerMono{}
-
-	// PanMixerStereo is a mixer that's specialized for mixing stereo audio content
-	PanMixerStereo PanMixer = &panMixerStereo{}
-
-	// PanMixerQuad is a mixer that's specialized for mixing quadraphonic audio content
-	PanMixerQuad PanMixer = &panMixerQuad{}
-)
-
-type panMixerMono struct {
-	PanMixer
-}
-
-func (p panMixerMono) GetMixingMatrix(pan panning.Position) volume.Matrix {
-	// distance and angle are ignored on mono
-	return volume.Matrix{1.0}
-}
-
-func (p panMixerMono) Channels() int {
-	return 1
-}
-
-type panMixerStereo struct {
-	PanMixer
-}
-
-func (p panMixerStereo) GetMixingMatrix(pan panning.Position) volume.Matrix {
-	pangle := float64(pan.Angle)
-	s, c := math.Sincos(pangle)
-	var d volume.Volume
-	if pan.Distance > 0 {
-		d = 1 / volume.Volume(pan.Distance*pan.Distance)
-	}
-	l := d * volume.Volume(s)
-	r := d * volume.Volume(c)
-	return volume.Matrix{l, r}
-}
-
-func (p panMixerStereo) Channels() int {
-	return 2
-}
-
-type panMixerQuad struct {
-	PanMixer
-}
-
-func (p panMixerQuad) GetMixingMatrix(pan panning.Position) volume.Matrix {
-	pangle := float64(pan.Angle)
-	sf, cf := math.Sincos(pangle)
-	sr, cr := math.Sin(pangle+math.Pi/2.0), math.Cos(pangle-math.Pi/2.0)
-	var d volume.Volume
-	if pan.Distance > 0 {
-		d = 1 / volume.Volume(pan.Distance*pan.Distance)
-	}
-	lf := d * volume.Volume(sf)
-	rf := d * volume.Volume(cf)
-	lr := d * volume.Volume(cr)
-	rr := d * volume.Volume(sr)
-	return volume.Matrix{lf, rf, lr, rr}
-}
-
-func (p panMixerQuad) Channels() int {
-	return 4
+	NumChannels() int
 }
 
 // GetPanMixer returns the panning mixer that can generate a matrix

mixing/panmixer_mono.go

@@ -0,0 +1,23 @@
+package mixing
+
+import (
+	"github.com/gotracker/gomixing/panning"
+	"github.com/gotracker/gomixing/volume"
+)
+
+// PanMixerMono is a mixer that's specialized for mixing monaural audio content
+var PanMixerMono PanMixer = &panMixerMono{}
+
+type panMixerMono volume.Matrix
+
+func (p panMixerMono) GetMixingMatrix(pan panning.Position) volume.Matrix {
+	// distance and angle are ignored on mono
+	return volume.Matrix{
+		StaticMatrix: volume.StaticMatrix{1.0},
+		Channels:     1,
+	}
+}
+
+func (p panMixerMono) NumChannels() int {
+	return p.Channels
+}

mixing/panmixer_quad.go

@@ -0,0 +1,35 @@
+package mixing
+
+import (
+	"math"
+
+	"github.com/gotracker/gomixing/panning"
+	"github.com/gotracker/gomixing/volume"
+)
+
+// PanMixerQuad is a mixer that's specialized for mixing quadraphonic audio content
+var PanMixerQuad PanMixer = &panMixerQuad{}
+
+type panMixerQuad volume.Matrix
+
+func (p panMixerQuad) GetMixingMatrix(pan panning.Position) volume.Matrix {
+	pangle := float64(pan.Angle)
+	sf, cf := math.Sincos(pangle)
+	sr, cr := math.Sin(pangle+math.Pi/2.0), math.Cos(pangle-math.Pi/2.0)
+	var d volume.Volume
+	if pan.Distance > 0 {
+		d = 1 / volume.Volume(pan.Distance*pan.Distance)
+	}
+	lf := d * volume.Volume(sf)
+	rf := d * volume.Volume(cf)
+	lr := d * volume.Volume(cr)
+	rr := d * volume.Volume(sr)
+	return volume.Matrix{
+		StaticMatrix: volume.StaticMatrix{lf, rf, lr, rr},
+		Channels:     4,
+	}
+}
+
+func (p panMixerQuad) NumChannels() int {
+	return p.Channels
+}

mixing/panmixer_stereo.go

@@ -0,0 +1,32 @@
+package mixing
+
+import (
+	"math"
+
+	"github.com/gotracker/gomixing/panning"
+	"github.com/gotracker/gomixing/volume"
+)
+
+// PanMixerStereo is a mixer that's specialized for mixing stereo audio content
+var PanMixerStereo PanMixer = &panMixerStereo{}
+
+type panMixerStereo volume.Matrix
+
+func (p panMixerStereo) GetMixingMatrix(pan panning.Position) volume.Matrix {
+	pangle := float64(pan.Angle)
+	s, c := math.Sincos(pangle)
+	var d volume.Volume
+	if pan.Distance > 0 {
+		d = 1 / volume.Volume(pan.Distance*pan.Distance)
+	}
+	l := d * volume.Volume(s)
+	r := d * volume.Volume(c)
+	return volume.Matrix{
+		StaticMatrix: volume.StaticMatrix{l, r},
+		Channels:     2,
+	}
+}
+
+func (p panMixerStereo) NumChannels() int {
+	return p.Channels
+}

sampling/samplerimpl.go

@@ -19,7 +19,7 @@ func (s *sampler) Advance() {
 
 func (s *sampler) GetSample() volume.Matrix {
 	if s.ss == nil {
-		return nil
+		return volume.Matrix{}
 	}
 	return s.ss.GetSample(s.pos)
 }