1 files changed, 223 insertions(+), 16 deletions(-)

M player_lib/player_test_sdl/main.go
M player_lib/player_test_sdl/main.go +223 -16
@@ 11,14 11,19 @@ void AudioCallback3(void *userdata, Uint
 void AudioCallback4(void *userdata, Uint8 *stream, int len);
 void AudioCallback5(void *userdata, Uint8 *stream, int len);
 void AudioCallback6(void *userdata, Uint8 *stream, int len);
+void AudioCallback7(void *userdata, Uint8 *stream, int len);
+void AudioCallback8(void *userdata, Uint8 *stream, int len);
 */
 import "C"
 import (
 	"fmt"
 	"os"
 	"math"
+	//"math/rand"
 	"log"
 	"reflect"
+	"bytes"
+	"encoding/binary"
 	"unsafe"
 	
 	"github.com/veandco/go-sdl2/sdl"

          
@@ 180,27 185,36 @@ func AudioCallback4(userdata unsafe.Poin
 
 	// Num samples / frames (?)
 	// 16bit: 2x less
-	numSamples := int(len_bytes)/2/2
+	//numSamples := int(len_bytes)/2/2
+	// XXX
+	numSamples := bytesToSamples(int(len_bytes))
 	//numSamples := int(len_bytes)/2
 	_ =	numSamples
 
 	fmt.Println("len_bytes:", len_bytes)
 	fmt.Println("numSamples:", numSamples)
 
+	//panic(2)
+
 	// XXX
 	renderBufLenBytes := int(len_bytes)
+	//renderBufLenBytes := int(len_bytes)/2
 	renderBuf, xret := FillBuffer(renderBufLenBytes)
 	_ = renderBuf
 
 	println("xret:", xret)
 
+	// XXX
+	buffer_pos := 0
+
 	//for i := 0; i < n; i += 2 {
 	//for i := 0; i < numSamples; i += 2 {
 	//for i := 0; i < xnumSamples; i += 2 {
 	for i := 0; i < numSamples; i++ {
 
 		//idx := g_audio_data_buffer_pos
-		idx := i
+		idx := buffer_pos
+		//idx := i
 		//idx := i*2
 		//idx := i/2
 		//idx := i/2/2

          
@@ 219,9 233,11 @@ func AudioCallback4(userdata unsafe.Poin
 
 		// XXX finally
 		//g_audio_data_buffer_pos += 2
+		buffer_pos += 2
 
-		outIdx := i*2
-		//outIdx := i
+		//outIdx := i*2
+		outIdx := i
+		_ = outIdx
 
 		buf[outIdx] = vl
 		buf[outIdx+1] = vr

          
@@ 245,6 261,8 @@ func AudioCallback5(userdata unsafe.Poin
 	buf := *(*[]C.Sint16)(unsafe.Pointer(&hdr))
 
 	fmt.Println("len_bytes:", len_bytes)
+	
+	fmt.Println("len buf:", len(buf))
 
 	//panic(2)
 

          
@@ 254,13 272,22 @@ func AudioCallback5(userdata unsafe.Poin
 	_ = renderBuf
 
 	println("xret:", xret)
+	println("len renderBuf:", len(renderBuf))
+	//panic(2)
 
 	numBytes := int(len_bytes)
 	_ = numBytes
 	lenBytes := int(len_bytes)
 	_ = lenBytes
 
-	xlen := numBytes/2
+	//xlen := lenBytes/2/2
+	// len in s16 samples ?
+	// len / sizeof(int16)
+	// len_bytes / sizeof(int16)
+	xlen := lenBytes/2
+	//xlen := lenBytes
+
+	var phase float64
 
 	// stereo ?
 	//for i := 0; i < numBytes/2; i++ {

          
@@ 270,21 297,40 @@ func AudioCallback5(userdata unsafe.Poin
 	//for i := 0; i < numBytes-1; i++ {
 	//for i := 0; i < lenBytes/2; i++ {
 	for i := 0; i < xlen; i += 2 {
+	//for i := 0; i < xlen; i++ {
 
 		//println("-> i:", i)
 
+			phase += dPhase
+
+			// XXX
+			g_d_phase += 0.010
+			sineV := math.Sin(g_d_phase * 4) * 5000
+			sample := C.Sint16(sineV)
+			_ = sample
+
 		// XXX
 		s := renderBuf[i]
-		s1 := renderBuf[i+1]
+		//s := sample
+		//s := sineV
+		//s := i
+		//s := i/2
+		//s := i/10
+		//s1 := renderBuf[i+1]
 
 		v := C.Sint16(s)
-		v1 := C.Sint16(s1)
-		_ = v1
+		//v1 := C.Sint16(s1)
+		_ = v
+		//_ = v1
 
 		buf[i] = v
 		buf[i+1] = v
 		//buf[i+1] = v1
 
+		//buf[i] = v
+		//buf[i] = 0
+		//buf[i+1] = v
+
 		/*
 		//idx := i*2
 		idx := i

          
@@ 305,6 351,8 @@ func AudioCallback5(userdata unsafe.Poin
 		//buf[i+1] = 0
 		*/
 	}
+
+	println("done")
 }
 
 ///*

          
@@ 342,11 390,164 @@ func AudioCallback6(userdata unsafe.Poin
 
 //*/
 
+///*
+//export AudioCallback7
+func AudioCallback7(userdata unsafe.Pointer, stream *C.Uint8, len_bytes C.int) {
+	println("AudioCallback7")
+	n := int(len_bytes)
+	hdr := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(stream)), Len: n, Cap: n}
+	//buf := *(*[]C.Uint8)(unsafe.Pointer(&hdr))
+	// XXX ?
+	// Copy of c code ? cast to Sint16 (from Uint8: stream)
+	// buf/buffer is Sint16
+	buf := *(*[]C.Sint16)(unsafe.Pointer(&hdr))
+
+	fmt.Println("len_bytes:", len_bytes)
+
+	// XXX Sint16 / c
+	bufLen := len(buf) / 2
+	fmt.Println("bufLen:", bufLen)
+
+	//panic(2)
+
+	lenBytes := int(len_bytes)
+
+	// XXX
+	renderBufLenBytes := int(len_bytes)
+	//renderBufLenBytes := bufLen
+	renderBuf, xret := FillBuffer(renderBufLenBytes)
+	_ = renderBuf
+
+	println("xret:", xret)
+	println("len renderBuf:", len(renderBuf))
+	//panic(2)
+
+	// XXX
+	zbuf := bytes.NewBuffer(renderBuf)
+
+	// buf
+	// left value ?
+	//convByteData := renderBuf[0:2]
+	//val := binary.LittleEndian.Int16(convByteData)
+	var val int16
+	//err := binary.Read(convByteData, binary.LittleEndian, &val)
+	err := binary.Read(zbuf, binary.LittleEndian, &val)
+	if err != nil {
+		panic(err)
+	}
+
+	// buf
+	// right value ?
+	//convByteData2 := renderBuf[2:4]
+	//val2 := binary.LittleEndian.Int16(convByteData2)
+	var val2 int16
+	//err2 := binary.Read(convByteData2, binary.LittleEndian, &val2)
+	err2 := binary.Read(zbuf, binary.LittleEndian, &val2)
+	if err2 != nil {
+		panic(err)
+	}
+
+	println("val", val)
+	println("val2", val2)
+	panic(2)
+
+	// stereo ?
+	//for i := 0; i < lenBytes; i++ {
+	//for i := 0; i < lenBytes/2; i++ {
+	for i := 0; i < lenBytes/2; i++ {
+	//for i := 0; i < lenBytes/2; i += 2 {
+
+		//println("-> i:", i)
+
+		// XXX
+
+		//buf[i] = 0
+		//buf[i+1] = 0
+
+		buf[i] = C.Sint16(renderBuf[i])
+		
+		//buf[i] = 0
+		//buf[i] = C.Sint16(renderBuf[i])
+		//buf[i+1] = C.Sint16(renderBuf[i+1])
+		//buf[i] = renderBuf[i]
+	}
+}
+
+//*/
+
+///*
+//export AudioCallback8
+func AudioCallback8(userdata unsafe.Pointer, stream *C.Uint8, len_bytes C.int) {
+	println("AudioCallback8")
+	n := int(len_bytes)
+	hdr := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(stream)), Len: n, Cap: n}
+	// XXX
+	buf := *(*[]byte)(unsafe.Pointer(&hdr))
+	//buf := *(*[]C.Uint8)(unsafe.Pointer(&hdr))
+	// XXX ?
+	// Copy of c code ? cast to Sint16 (from Uint8: stream)
+	// buf/buffer is Sint16
+	//buf := *(*[]C.Sint16)(unsafe.Pointer(&hdr))
+	_ = buf
+
+	fmt.Println("len_bytes:", len_bytes)
+
+	//panic(2)
+
+	lenBytes := int(len_bytes)
+	_ = lenBytes
+
+	//audioSamples := make([]byte, lenBytes)
+	//copy(audioSamples, buf)
+	//copy(buf, audioSamples)
+
+	//renderBufLenBytes := int(len_bytes)
+	//renderBuf, xret := FillBuffer(renderBufLenBytes)
+	renderBuf, xret := FillBuffer(lenBytes)
+	_ = renderBuf
+	_ = xret
+	//copy(renderBuf, buf)
+	copy(buf, renderBuf)
+
+	if false {
+	for i := 0; i < lenBytes; i++ {
+		//v := rand.Intn(100)
+		//buf[i] = v
+		//buf[i] = byte(v)
+
+		v := renderBuf[i]
+		buf[i] = v
+	}
+	}
+}
+
+//*/
+
 
 // util ?
-//func samplesToBytes(numSamples int) int {
-//	
-//}
+// stereo ?
+// samples = stereo samples ?
+func samplesToBytes(lenSamples int) int {
+	// 16 bit
+	// 2 + 2 (2 bytes * 2 channels)
+	// ?
+	bytesInFrame := 4
+	ret := bytesInFrame * lenSamples
+
+	return ret
+}
+
+// stereo ?
+// samples = stereo samples ?
+func bytesToSamples(lenBytes int) int {
+	// 16 bit
+	// 2 + 2 (2 bytes * 2 channels)
+	// ?
+	bytesInFrame := 4
+	ret := lenBytes / bytesInFrame
+
+	return ret
+}
 
 // XXX
 //func FillBuffer(bufSizeBytes int) {

          
@@ 376,7 577,10 @@ func FillBuffer(bufSizeBytes int) ([]byt
 	var outF *os.File
 	_ = outF
 
-	if true {
+	writeToFile := false
+	//writeToFile := true
+
+	if writeToFile {
 		var err error
 		//outF, err = os.Create("/tmp/out_fillbuffer.raw")
 		//outF, err = os.OpenFile("/tmp/out_fillbuffer.raw", os.O_RDWR | os.O_CREATE, 0666)

          
@@ 387,11 591,11 @@ func FillBuffer(bufSizeBytes int) ([]byt
 	}
 
 	// This writes buf (one)
-	if true {
+	if writeToFile {
 		outF.Write(buf)
 	}
 
-	if true {
+	if writeToFile {
 		//outF.Close()
 		// XXX ?
 		//outF.Flush()

          
@@ 415,7 619,7 @@ func main() {
 		err := os.Rename("/tmp/out_fillbuffer.raw", "/tmp/out_fillbuffer.raw.orig")
 
 		if err != nil {
-			panic(err)
+			//panic(err)
 		}
 	}
 	

          
@@ 424,6 628,7 @@ func main() {
 	// sdl ?
 	// stereo samples ?
 	bufSizeSamples := 1024
+	//bufSizeSamples := 2048
 	fmt.Println("bufSizeSamples:", bufSizeSamples)
 	
 	if err := sdl.Init(sdl.INIT_AUDIO); err != nil {

          
@@ 452,8 657,10 @@ func main() {
 		//Callback: sdl.AudioCallback(C.AudioCallback2),
 		//Callback: sdl.AudioCallback(C.AudioCallback3),
 		//Callback: sdl.AudioCallback(C.AudioCallback4),
-		Callback: sdl.AudioCallback(C.AudioCallback5),
+		//Callback: sdl.AudioCallback(C.AudioCallback5),
 		//Callback: sdl.AudioCallback(C.AudioCallback6),
+		//Callback: sdl.AudioCallback(C.AudioCallback7),
+		Callback: sdl.AudioCallback(C.AudioCallback8),
 	}
 	if err := sdl.OpenAudio(spec, nil); err != nil {
 		log.Println(err)