fix: tighten PipeWire buffer helper invariants

commit: 66c3355792f6d0576c462837103a6f42f41da9f0
author: brice · 6mo ago · 2026-04-10 13:27 UTC
parent: 177250e
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +119 -68

M internal/core/pwbuffer.go +9 -6


@@ -2,6 +2,7 @@ package core
2	2
3	3		import (
4	4		"errors"
	5	+	"fmt"
5	6		"unsafe"
6	7		)
7	8

@@ -58,6 +59,7 @@ var (
58	59		ErrNilBufferPointer = errors.New("nil buffer pointer")
59	60		ErrChannelMismatch = errors.New("buffer data count does not match channels")
60	61		ErrUnmappedData = errors.New("buffer data pointer is nil")
	62	+	ErrFrameOverflow = errors.New("requested frames exceed buffer capacity")
61	63		)
62	64
63	65		// newPWBufferView interprets bufPtr as a *pwBuffer and returns a view that

@@ -88,13 +90,12 @@ func newPWBufferView(bufPtr unsafe.Pointer, channels, frames int) (*pwBufferView
88	90		if data.Data == nil {
89	91		return nil, ErrUnmappedData
90	92		}
91		-	// Slice the raw memory as []float32 for this channel.
92		-	// Data.Maxsize gives the total buffer size in bytes for this channel.
93		-	nFloats := frames
94		-	if maxSize := int(data.Maxsize) / 4; nFloats > maxSize {
95		-	nFloats = maxSize
	93	+	// Reject if the buffer cannot hold the requested number of frames.
	94	+	maxFrames := int(data.Maxsize) / 4
	95	+	if frames > maxFrames {
	96	+	return nil, fmt.Errorf("%w: requested %d frames but buffer holds %d", ErrFrameOverflow, frames, maxFrames)
96	97		}
97		-	samples[i] = unsafe.Slice((*float32)(data.Data), nFloats)
	98	+	samples[i] = unsafe.Slice((*float32)(data.Data), frames)
98	99		}
99	100
100	101		return &pwBufferView{

@@ -107,10 +108,12 @@ func newPWBufferView(bufPtr unsafe.Pointer, channels, frames int) (*pwBufferView
107	108
108	109		// PCM returns a PCMBuffer pointing at the buffer's planar float32 data.
109	110		// The caller can write into Samples and then call Commit.
	111	+	// Stride is set to 4 (bytes per float32 sample) for planar float32 layout.
110	112		func (v pwBufferView) PCM() PCMBuffer {
111	113		return &PCMBuffer{
112	114		Frames: v.frames,
113	115		Channels: v.channels,
	116	+	Stride: 4, // sizeof(float32) — planar float32 byte stride per channel
114	117		Samples: v.samples,
115	118		}
116	119		}

 import (
 	"errors"
+	"fmt"
 	"unsafe"
 )
 	ErrNilBufferPointer = errors.New("nil buffer pointer")
 	ErrChannelMismatch  = errors.New("buffer data count does not match channels")
 	ErrUnmappedData     = errors.New("buffer data pointer is nil")
+	ErrFrameOverflow    = errors.New("requested frames exceed buffer capacity")
 )
 // newPWBufferView interprets bufPtr as a *pwBuffer and returns a view that
 		if data.Data == nil {
 			return nil, ErrUnmappedData
 		}
-		// Slice the raw memory as []float32 for this channel.
+		// Reject if the buffer cannot hold the requested number of frames.
-		// Data.Maxsize gives the total buffer size in bytes for this channel.
+		maxFrames := int(data.Maxsize) / 4
-		nFloats := frames
+		if frames > maxFrames {
-		if maxSize := int(data.Maxsize) / 4; nFloats > maxSize {
+			return nil, fmt.Errorf("%w: requested %d frames but buffer holds %d", ErrFrameOverflow, frames, maxFrames)
-			nFloats = maxSize
 		}
-		samples[i] = unsafe.Slice((*float32)(data.Data), nFloats)
+		samples[i] = unsafe.Slice((*float32)(data.Data), frames)
 	}
 	return &pwBufferView{
 // PCM returns a PCMBuffer pointing at the buffer's planar float32 data.
 // The caller can write into Samples and then call Commit.
+// Stride is set to 4 (bytes per float32 sample) for planar float32 layout.
 func (v *pwBufferView) PCM() *PCMBuffer {
 	return &PCMBuffer{
 		Frames:   v.frames,
 		Channels: v.channels,
+		Stride:   4, // sizeof(float32) — planar float32 byte stride per channel
 		Samples:  v.samples,
 	}
 }

M internal/core/pwbuffer_test.go +110 -62


@@ -6,62 +6,58 @@ import (
6	6		"unsafe"
7	7		)
8	8
9		-	// TestNewPWBufferViewWrapsWritablePlanarFloatData verifies that newPWBufferView
10		-	// correctly interprets a C-layout pwBuffer as planar float32 channel data.
11		-	func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
12		-	const channels = 2
13		-	const frames = 64
	9	+	// Named constants for SPA data type and flag values (from <spa/buffer/buffer.h>).
	10	+	const (
	11	+	spaDataTypeMemPtr uint32 = 2 // SPA_DATA_MemPtr
	12	+	spaDataFlagRW uint32 = 3 // SPA_DATA_FLAG_READABLE \| SPA_DATA_FLAG_WRITABLE
	13	+	)
14	14
15		-	// Allocate planar float32 backing memory for each channel.
	15	+	// helper to build a channels×frames buffer view for tests.
	16	+	// Returns the view, the chunks slice, and the pwBuffer pointer.
	17	+	func newTestBufferView(t testing.T, channels, frames, maxsizeFrames int) (pwBufferView, []spaChunk, *pwBuffer) {
	18	+	t.Helper()
16	19		channelData := make([][]float32, channels)
17	20		channelPtrs := make([]unsafe.Pointer, channels)
18	21		for ch := 0; ch < channels; ch++ {
19		-	channelData[ch] = make([]float32, frames)
	22	+	channelData[ch] = make([]float32, maxsizeFrames)
20	23		channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
21	24		}
22	25
23		-	// Build the C-layout chunk structs.
24	26		chunks := make([]spaChunk, channels)
25		-	for ch := 0; ch < channels; ch++ {
26		-	chunks[ch] = spaChunk{
27		-	Offset: 0,
28		-	Size: 0, // will be set on Commit
29		-	Stride: 0,
30		-	Flags: 0,
31		-	}
32		-	}
33		-
34		-	// Build the C-layout spaData structs.
35	27		datas := make([]spaData, channels)
36	28		for ch := 0; ch < channels; ch++ {
	29	+	chunks[ch] = spaChunk{}
37	30		datas[ch] = spaData{
38		-	Type: 2, // SPA_DATA_MemPtr
39		-	Flags: 3, // SPA_DATA_FLAG_READABLE \| SPA_DATA_FLAG_WRITABLE
40		-	Maxsize: uint32(frames * 4), // bytes
	31	+	Type: spaDataTypeMemPtr,
	32	+	Flags: spaDataFlagRW,
	33	+	Maxsize: uint32(maxsizeFrames * 4),
41	34		Data: channelPtrs[ch],
42	35		Chunk: &chunks[ch],
43	36		}
44	37		}
45	38
46		-	// Build the C-layout spaBuffer.
47	39		buf := spaBuffer{
48		-	NMetas: 0,
49	40		NDatas: uint32(channels),
50		-	Metas: nil,
51	41		Datas: unsafe.Pointer(&datas[0]),
52	42		}
53		-
54		-	// Build the C-layout pwBuffer.
55	43		pwBuf := pwBuffer{
56		-	Buffer: &buf,
57		-	UserData: nil,
58		-	Size: 0,
	44	+	Buffer: &buf,
59	45		}
60	46
61	47		view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
62	48		if err != nil {
63		-	t.Fatalf("unexpected error: %v", err)
	49	+	t.Fatalf("unexpected error building test buffer: %v", err)
64	50		}
	51	+	return view, chunks, &pwBuf
	52	+	}
	53	+
	54	+	// TestNewPWBufferViewWrapsWritablePlanarFloatData verifies that newPWBufferView
	55	+	// correctly interprets a C-layout pwBuffer as planar float32 channel data.
	56	+	func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
	57	+	const channels = 2
	58	+	const frames = 64
	59	+
	60	+	view, _, _ := newTestBufferView(t, channels, frames, frames)
65	61
66	62		pcm := view.PCM()
67	63		if pcm.Channels != channels {

@@ -70,6 +66,9 @@ func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
70	66		if pcm.Frames != frames {
71	67		t.Errorf("expected %d frames, got %d", frames, pcm.Frames)
72	68		}
	69	+	if pcm.Stride != 4 {
	70	+	t.Errorf("expected Stride=4 for planar float32, got %d", pcm.Stride)
	71	+	}
73	72		if len(pcm.Samples) != channels {
74	73		t.Fatalf("expected %d sample slices, got %d", channels, len(pcm.Samples))
75	74		}

@@ -78,8 +77,60 @@ func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
78	77		t.Errorf("channel %d: expected %d frames, got %d", ch, frames, len(pcm.Samples[ch]))
79	78		}
80	79		}
	80	+	}
	81	+
	82	+	// TestNewPWBufferViewPCMStrideIsSet verifies that PCM() returns a buffer
	83	+	// with Stride set to 4 (bytes per float32 for planar layout).
	84	+	func TestNewPWBufferViewPCMStrideIsSet(t *testing.T) {
	85	+	const channels = 1
	86	+	const frames = 32
	87	+
	88	+	view, _, _ := newTestBufferView(t, channels, frames, frames)
	89	+
	90	+	pcm := view.PCM()
	91	+	if pcm.Stride != 4 {
	92	+	t.Errorf("PCMBuffer.Stride = %d, want 4 (sizeof float32)", pcm.Stride)
	93	+	}
	94	+	}
	95	+
	96	+	// TestNewPWBufferViewSharedMemory verifies that writes to the PCMBuffer
	97	+	// propagate to the underlying channel data (not a copy).
	98	+	func TestNewPWBufferViewSharedMemory(t *testing.T) {
	99	+	const channels = 2
	100	+	const frames = 64
	101	+
	102	+	channelData := make([][]float32, channels)
	103	+	channelPtrs := make([]unsafe.Pointer, channels)
	104	+	for ch := 0; ch < channels; ch++ {
	105	+	channelData[ch] = make([]float32, frames)
	106	+	channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
	107	+	}
81	108
82		-	// Verify the PCM buffer shares memory with channelData (not a copy).
	109	+	chunks := make([]spaChunk, channels)
	110	+	datas := make([]spaData, channels)
	111	+	for ch := 0; ch < channels; ch++ {
	112	+	chunks[ch] = spaChunk{}
	113	+	datas[ch] = spaData{
	114	+	Type: spaDataTypeMemPtr,
	115	+	Flags: spaDataFlagRW,
	116	+	Maxsize: uint32(frames * 4),
	117	+	Data: channelPtrs[ch],
	118	+	Chunk: &chunks[ch],
	119	+	}
	120	+	}
	121	+
	122	+	buf := spaBuffer{
	123	+	NDatas: uint32(channels),
	124	+	Datas: unsafe.Pointer(&datas[0]),
	125	+	}
	126	+	pwBuf := pwBuffer{Buffer: &buf}
	127	+
	128	+	view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
	129	+	if err != nil {
	130	+	t.Fatalf("unexpected error: %v", err)
	131	+	}
	132	+
	133	+	pcm := view.PCM()
83	134		pcm.Samples[0][0] = 1.0
84	135		if channelData[0][0] != 1.0 {
85	136		t.Error("PCM buffer does not share memory with underlying channel data — write did not propagate")

@@ -114,21 +165,17 @@ func TestNewPWBufferViewRejectsNilPointer(t *testing.T) {
114	165		// TestNewPWBufferViewRejectsChannelMismatch verifies that a buffer whose
115	166		// NDatas does not match the requested channel count returns ErrChannelMismatch.
116	167		func TestNewPWBufferViewRejectsChannelMismatch(t *testing.T) {
117		-	// Build a buffer claiming 1 data slot.
118	168		singleData := spaData{
119		-	Type: 2,
	169	+	Type: spaDataTypeMemPtr,
120	170		Maxsize: 256,
121	171		Data: unsafe.Pointer(new(float32)),
122	172		Chunk: &spaChunk{},
123	173		}
124	174		buf := spaBuffer{
125		-	NMetas: 0,
126	175		NDatas: 1, // only 1 channel
127	176		Datas: unsafe.Pointer(&singleData),
128	177		}
129		-	pwBuf := pwBuffer{
130		-	Buffer: &buf,
131		-	}
	178	+	pwBuf := pwBuffer{Buffer: &buf}
132	179
133	180		_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64) // requesting 2 channels
134	181		if !errors.Is(err, ErrChannelMismatch) {

@@ -141,26 +188,23 @@ func TestNewPWBufferViewRejectsChannelMismatch(t *testing.T) {
141	188		func TestNewPWBufferViewRejectsUnmappedData(t *testing.T) {
142	189		datas := make([]spaData, 2)
143	190		datas[0] = spaData{
144		-	Type: 2,
	191	+	Type: spaDataTypeMemPtr,
145	192		Maxsize: 256,
146	193		Data: nil, // nil — should trigger ErrUnmappedData
147	194		Chunk: &spaChunk{},
148	195		}
149	196		datas[1] = spaData{
150		-	Type: 2,
	197	+	Type: spaDataTypeMemPtr,
151	198		Maxsize: 256,
152	199		Data: unsafe.Pointer(new(float32)),
153	200		Chunk: &spaChunk{},
154	201		}
155	202
156	203		buf := spaBuffer{
157		-	NMetas: 0,
158	204		NDatas: 2,
159	205		Datas: unsafe.Pointer(&datas[0]),
160	206		}
161		-	pwBuf := pwBuffer{
162		-	Buffer: &buf,
163		-	}
	207	+	pwBuf := pwBuffer{Buffer: &buf}
164	208
165	209		_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64)
166	210		if !errors.Is(err, ErrUnmappedData) {

@@ -172,9 +216,7 @@ func TestNewPWBufferViewRejectsUnmappedData(t *testing.T) {
172	216		// pointer inside the pwBuffer returns ErrNilBufferPointer.
173	217		func TestNewPWBufferViewRejectsNilSpaBuffer(t *testing.T) {
174	218		pwBuf := pwBuffer{
175		-	Buffer: nil, // nil — should trigger ErrNilBufferPointer
176		-	UserData: nil,
177		-	Size: 0,
	219	+	Buffer: nil,
178	220		}
179	221
180	222		_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64)

@@ -183,43 +225,49 @@ func TestNewPWBufferViewRejectsNilSpaBuffer(t *testing.T) {
183	225		}
184	226		}
185	227
186		-	// TestCommitUpdatesSizeAndStride verifies that Commit writes the correct
187		-	// byte sizes and strides for planar float32 data.
188		-	func TestCommitUpdatesSizeAndStride(t *testing.T) {
	228	+	// TestNewPWBufferViewRejectsOversizedFrames verifies that requesting more
	229	+	// frames than the buffer can hold (based on Maxsize) returns ErrFrameOverflow.
	230	+	func TestNewPWBufferViewRejectsOversizedFrames(t *testing.T) {
189	231		const channels = 2
190		-	const frames = 128
	232	+	const maxFrames = 32
	233	+	const requestedFrames = 64 // exceeds maxFrames
191	234
192	235		channelData := make([][]float32, channels)
193	236		channelPtrs := make([]unsafe.Pointer, channels)
194	237		for ch := 0; ch < channels; ch++ {
195		-	channelData[ch] = make([]float32, frames)
	238	+	channelData[ch] = make([]float32, maxFrames)
196	239		channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
197	240		}
198	241
199		-	chunks := make([]spaChunk, channels)
200	242		datas := make([]spaData, channels)
201	243		for ch := 0; ch < channels; ch++ {
202	244		datas[ch] = spaData{
203		-	Type: 2,
204		-	Maxsize: uint32(frames * 4),
	245	+	Type: spaDataTypeMemPtr,
	246	+	Maxsize: uint32(maxFrames * 4), // only room for 32 frames
205	247		Data: channelPtrs[ch],
206		-	Chunk: &chunks[ch],
	248	+	Chunk: &spaChunk{},
207	249		}
208	250		}
209	251
210	252		buf := spaBuffer{
211		-	NMetas: 0,
212	253		NDatas: uint32(channels),
213	254		Datas: unsafe.Pointer(&datas[0]),
214	255		}
215		-	pwBuf := pwBuffer{
216		-	Buffer: &buf,
217		-	}
	256	+	pwBuf := pwBuffer{Buffer: &buf}
218	257
219		-	view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
220		-	if err != nil {
221		-	t.Fatalf("unexpected error: %v", err)
	258	+	_, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, requestedFrames)
	259	+	if !errors.Is(err, ErrFrameOverflow) {
	260	+	t.Fatalf("expected ErrFrameOverflow, got %v", err)
222	261		}
	262	+	}
	263	+
	264	+	// TestCommitUpdatesSizeAndStride verifies that Commit writes the correct
	265	+	// byte sizes and strides for planar float32 data.
	266	+	func TestCommitUpdatesSizeAndStride(t *testing.T) {
	267	+	const channels = 2
	268	+	const frames = 128
	269	+
	270	+	view, chunks, pwBuf := newTestBufferView(t, channels, frames, frames)
223	271
224	272		// Write some audio data to the PCM buffer.
225	273		const writtenFrames = 96

 	"unsafe"
 )
-// TestNewPWBufferViewWrapsWritablePlanarFloatData verifies that newPWBufferView
+// Named constants for SPA data type and flag values (from <spa/buffer/buffer.h>).
-// correctly interprets a C-layout pwBuffer as planar float32 channel data.
+const (
-func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
+	spaDataTypeMemPtr uint32 = 2 // SPA_DATA_MemPtr
-	const channels = 2
+	spaDataFlagRW     uint32 = 3 // SPA_DATA_FLAG_READABLE | SPA_DATA_FLAG_WRITABLE
-	const frames = 64
+)
-	// Allocate planar float32 backing memory for each channel.
+// helper to build a channels×frames buffer view for tests.
+// Returns the view, the chunks slice, and the pwBuffer pointer.
+func newTestBufferView(t *testing.T, channels, frames, maxsizeFrames int) (*pwBufferView, []spaChunk, *pwBuffer) {
+	t.Helper()
 	channelData := make([][]float32, channels)
 	channelPtrs := make([]unsafe.Pointer, channels)
 	for ch := 0; ch < channels; ch++ {
-		channelData[ch] = make([]float32, frames)
+		channelData[ch] = make([]float32, maxsizeFrames)
 		channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
 	}
-	// Build the C-layout chunk structs.
 	chunks := make([]spaChunk, channels)
-	for ch := 0; ch < channels; ch++ {
-		chunks[ch] = spaChunk{
-			Offset: 0,
-			Size:   0, // will be set on Commit
-			Stride: 0,
-			Flags:  0,
-		}
-	}
-	// Build the C-layout spaData structs.
 	datas := make([]spaData, channels)
 	for ch := 0; ch < channels; ch++ {
+		chunks[ch] = spaChunk{}
 		datas[ch] = spaData{
-			Type:    2,                  // SPA_DATA_MemPtr
+			Type:    spaDataTypeMemPtr,
-			Flags:   3,                  // SPA_DATA_FLAG_READABLE | SPA_DATA_FLAG_WRITABLE
+			Flags:   spaDataFlagRW,
-			Maxsize: uint32(frames * 4), // bytes
+			Maxsize: uint32(maxsizeFrames * 4),
 			Data:    channelPtrs[ch],
 			Chunk:   &chunks[ch],
 		}
 	}
-	// Build the C-layout spaBuffer.
 	buf := spaBuffer{
-		NMetas: 0,
 		NDatas: uint32(channels),
-		Metas:  nil,
 		Datas:  unsafe.Pointer(&datas[0]),
 	}
-	// Build the C-layout pwBuffer.
 	pwBuf := pwBuffer{
-		Buffer:   &buf,
+		Buffer: &buf,
-		UserData: nil,
-		Size:     0,
 	}
 	view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
 	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("unexpected error building test buffer: %v", err)
 	}
+	return view, chunks, &pwBuf
+}
+// TestNewPWBufferViewWrapsWritablePlanarFloatData verifies that newPWBufferView
+// correctly interprets a C-layout pwBuffer as planar float32 channel data.
+func TestNewPWBufferViewWrapsWritablePlanarFloatData(t *testing.T) {
+	const channels = 2
+	const frames = 64
+	view, _, _ := newTestBufferView(t, channels, frames, frames)
 	pcm := view.PCM()
 	if pcm.Channels != channels {
 	if pcm.Frames != frames {
 		t.Errorf("expected %d frames, got %d", frames, pcm.Frames)
 	}
+	if pcm.Stride != 4 {
+		t.Errorf("expected Stride=4 for planar float32, got %d", pcm.Stride)
+	}
 	if len(pcm.Samples) != channels {
 		t.Fatalf("expected %d sample slices, got %d", channels, len(pcm.Samples))
 	}
 			t.Errorf("channel %d: expected %d frames, got %d", ch, frames, len(pcm.Samples[ch]))
 		}
 	}
+}
+// TestNewPWBufferViewPCMStrideIsSet verifies that PCM() returns a buffer
+// with Stride set to 4 (bytes per float32 for planar layout).
+func TestNewPWBufferViewPCMStrideIsSet(t *testing.T) {
+	const channels = 1
+	const frames = 32
+	view, _, _ := newTestBufferView(t, channels, frames, frames)
+	pcm := view.PCM()
+	if pcm.Stride != 4 {
+		t.Errorf("PCMBuffer.Stride = %d, want 4 (sizeof float32)", pcm.Stride)
+	}
+}
+// TestNewPWBufferViewSharedMemory verifies that writes to the PCMBuffer
+// propagate to the underlying channel data (not a copy).
+func TestNewPWBufferViewSharedMemory(t *testing.T) {
+	const channels = 2
+	const frames = 64
+	channelData := make([][]float32, channels)
+	channelPtrs := make([]unsafe.Pointer, channels)
+	for ch := 0; ch < channels; ch++ {
+		channelData[ch] = make([]float32, frames)
+		channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
+	}
-	// Verify the PCM buffer shares memory with channelData (not a copy).
+	chunks := make([]spaChunk, channels)
+	datas := make([]spaData, channels)
+	for ch := 0; ch < channels; ch++ {
+		chunks[ch] = spaChunk{}
+		datas[ch] = spaData{
+			Type:    spaDataTypeMemPtr,
+			Flags:   spaDataFlagRW,
+			Maxsize: uint32(frames * 4),
+			Data:    channelPtrs[ch],
+			Chunk:   &chunks[ch],
+		}
+	}
+	buf := spaBuffer{
+		NDatas: uint32(channels),
+		Datas:  unsafe.Pointer(&datas[0]),
+	}
+	pwBuf := pwBuffer{Buffer: &buf}
+	view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	pcm := view.PCM()
 	pcm.Samples[0][0] = 1.0
 	if channelData[0][0] != 1.0 {
 		t.Error("PCM buffer does not share memory with underlying channel data — write did not propagate")
 // TestNewPWBufferViewRejectsChannelMismatch verifies that a buffer whose
 // NDatas does not match the requested channel count returns ErrChannelMismatch.
 func TestNewPWBufferViewRejectsChannelMismatch(t *testing.T) {
-	// Build a buffer claiming 1 data slot.
 	singleData := spaData{
-		Type:    2,
+		Type:    spaDataTypeMemPtr,
 		Maxsize: 256,
 		Data:    unsafe.Pointer(new(float32)),
 		Chunk:   &spaChunk{},
 	}
 	buf := spaBuffer{
-		NMetas: 0,
 		NDatas: 1, // only 1 channel
 		Datas:  unsafe.Pointer(&singleData),
 	}
-	pwBuf := pwBuffer{
+	pwBuf := pwBuffer{Buffer: &buf}
-		Buffer: &buf,
-	}
 	_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64) // requesting 2 channels
 	if !errors.Is(err, ErrChannelMismatch) {
 func TestNewPWBufferViewRejectsUnmappedData(t *testing.T) {
 	datas := make([]spaData, 2)
 	datas[0] = spaData{
-		Type:    2,
+		Type:    spaDataTypeMemPtr,
 		Maxsize: 256,
 		Data:    nil, // nil — should trigger ErrUnmappedData
 		Chunk:   &spaChunk{},
 	}
 	datas[1] = spaData{
-		Type:    2,
+		Type:    spaDataTypeMemPtr,
 		Maxsize: 256,
 		Data:    unsafe.Pointer(new(float32)),
 		Chunk:   &spaChunk{},
 	}
 	buf := spaBuffer{
-		NMetas: 0,
 		NDatas: 2,
 		Datas:  unsafe.Pointer(&datas[0]),
 	}
-	pwBuf := pwBuffer{
+	pwBuf := pwBuffer{Buffer: &buf}
-		Buffer: &buf,
-	}
 	_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64)
 	if !errors.Is(err, ErrUnmappedData) {
 // pointer inside the pwBuffer returns ErrNilBufferPointer.
 func TestNewPWBufferViewRejectsNilSpaBuffer(t *testing.T) {
 	pwBuf := pwBuffer{
-		Buffer:   nil, // nil — should trigger ErrNilBufferPointer
+		Buffer: nil,
-		UserData: nil,
-		Size:     0,
 	}
 	_, err := newPWBufferView(unsafe.Pointer(&pwBuf), 2, 64)
 	}
 }
-// TestCommitUpdatesSizeAndStride verifies that Commit writes the correct
+// TestNewPWBufferViewRejectsOversizedFrames verifies that requesting more
-// byte sizes and strides for planar float32 data.
+// frames than the buffer can hold (based on Maxsize) returns ErrFrameOverflow.
-func TestCommitUpdatesSizeAndStride(t *testing.T) {
+func TestNewPWBufferViewRejectsOversizedFrames(t *testing.T) {
 	const channels = 2
-	const frames = 128
+	const maxFrames = 32
+	const requestedFrames = 64 // exceeds maxFrames
 	channelData := make([][]float32, channels)
 	channelPtrs := make([]unsafe.Pointer, channels)
 	for ch := 0; ch < channels; ch++ {
-		channelData[ch] = make([]float32, frames)
+		channelData[ch] = make([]float32, maxFrames)
 		channelPtrs[ch] = unsafe.Pointer(&channelData[ch][0])
 	}
-	chunks := make([]spaChunk, channels)
 	datas := make([]spaData, channels)
 	for ch := 0; ch < channels; ch++ {
 		datas[ch] = spaData{
-			Type:    2,
+			Type:    spaDataTypeMemPtr,
-			Maxsize: uint32(frames * 4),
+			Maxsize: uint32(maxFrames * 4), // only room for 32 frames
 			Data:    channelPtrs[ch],
-			Chunk:   &chunks[ch],
+			Chunk:   &spaChunk{},
 		}
 	}
 	buf := spaBuffer{
-		NMetas: 0,
 		NDatas: uint32(channels),
 		Datas:  unsafe.Pointer(&datas[0]),
 	}
-	pwBuf := pwBuffer{
+	pwBuf := pwBuffer{Buffer: &buf}
-		Buffer: &buf,
-	}
-	view, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, frames)
+	_, err := newPWBufferView(unsafe.Pointer(&pwBuf), channels, requestedFrames)
-	if err != nil {
+	if !errors.Is(err, ErrFrameOverflow) {
-		t.Fatalf("unexpected error: %v", err)
+		t.Fatalf("expected ErrFrameOverflow, got %v", err)
 	}
+}
+// TestCommitUpdatesSizeAndStride verifies that Commit writes the correct
+// byte sizes and strides for planar float32 data.
+func TestCommitUpdatesSizeAndStride(t *testing.T) {
+	const channels = 2
+	const frames = 128
+	view, chunks, pwBuf := newTestBufferView(t, channels, frames, frames)
 	// Write some audio data to the PCM buffer.
 	const writtenFrames = 96