const sampleRate = 16000
const channels = 1 // mono; 2 for stereo
const bufferSize = 1000 // choose any buffer size you like. 1k is plenty

func main(){
	enc, err := opus.NewEncoder(sampleRate, channels, opus.AppAudio)
	if err != nil {
		panic(err)
	}
	if err != enc.SetBitrate(25600) {
		panic(err)
	}
	if err != enc.SetComplexity(10) {
		panic(err)
	}
	if err !=enc.SetMaxBandwidth(opus.Wideband){
		panic(err)
	}


        fb,err := os.Open("1549937764922.pcm")
	if err != nil {
		panic(err)
	}
	var totalOpus bytes.Buffer
	for {
		pcm := make([]int16, 320)
		err = binary.Read(fb, binary.LittleEndian, &pcm)
		if err == io.EOF || err == io.ErrUnexpectedEOF {
			break
		}
		if err != nil {
			fmt.Printf("%+v\n", err)
			break
		}
		frameSize := len(pcm)
		frameSizeMs := float32(frameSize) / channels * 1000 / sampleRate
		switch frameSizeMs { //
		case 2.5, 5, 10, 20, 40, 60:
			// Good.
		default:
			panic(fmt.Sprintf("Illegal frame size: %d bytes (%f ms)", frameSize, frameSizeMs))
		}
		data := make([]byte, bufferSize)
		n, err := enc.Encode(pcm, data)
		if err != nil {
			panic(err)
		}
		fmt.Printf("readPcm_len=%d,encodeOpus_len=%d\n",frameSize,n)
		totalOpus.Write(data[:n])
	}
	ioutil.WriteFile("encoded.opus",totalOpus.Bytes(),os.ModePerm)
}

env GOOS=linux GOARCH=arm go build   
# github.com/hraban/opus
/home/juice/code/golang/pkg/mod/github.com/hraban/[email protected]/streams_map.go:32:23: undefined: Stream
/home/juice/code/golang/pkg/mod/github.com/hraban/[email protected]/streams_map.go:36:40: undefined: Stream
/home/juice/code/golang/pkg/mod/github.com/hraban/[email protected]/streams_map.go:42:30: undefined: Stream
/home/juice/code/golang/pkg/mod/github.com/hraban/[email protected]/streams_map.go:53:31: undefined: Stream

env GOOS=linux GOARCH=arm go build -tags nolibopusfile 
go build github.com/hraban/opus: build constraints exclude all Go files in /home/juice/code/golang/pkg/mod/github.com/hraban/[email protected]

package main

import (
	opus "gopkg.in/hraban/opus.v2"
)

func main() {
	encoder, err := opus.NewEncoder(48000, 2, opus.AppAudio)
	if err != nil {
		println(err.Error())
		return
	}

	pcm := make([]float32, 512)

	data := make([]byte, 256)

	n, err := encoder.EncodeFloat32(pcm, data)
	if err != nil {
		println(err.Error())
		return
	}

	println(len(pcm[:n]))
}

// play -t raw -r 48000 -e signed -b 16 -c 1 test.raw
//

package main

import (
	"encoding/binary"
	"fmt"
	"os"
	"os/signal"
	"io/ioutil"

	"github.com/gordonklaus/portaudio"
	"gopkg.in/hraban/opus.v2"
)

func main() {
	var readBuffer = make([]byte, 0)
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, os.Interrupt, os.Kill)

	fileName := "test.raw"

	f, err := os.Create(fileName)
	chk(err)


	portaudio.Initialize()
	defer portaudio.Terminate()
	in := make([]int16, 960)
	stream, err := portaudio.OpenDefaultStream(1, 0, 48000, len(in), in)
	chk(err)
	defer stream.Close()

	chk(stream.Start())
	for {
		chk(stream.Read())
		
		chk(binary.Write(f, binary.LittleEndian, in))
		buf, encErr := encode(in)
		if err != nil {
			panic(encErr)
		}
		readBuffer = append(readBuffer, buf...)

		//fmt.Println(in, len(in))
		select {
		case <-sig:		
			// write the whole body at once
			err = ioutil.WriteFile("output.ogg", readBuffer, 0644)
			if err != nil {
				panic(err)
			}
			return
		default:
		}
	}
	chk(stream.Stop())
}

func encode(pcm []int16) ([]byte, error){	
	const sampleRate = 48000
	const channels = 1 // mono; 2 for stereo
	const bufferSize = 1000 // choose any buffer size you like. 1k is plenty.

	enc, err := opus.NewEncoder(sampleRate, channels, opus.AppVoIP)
	if err != nil {
      panic(err)
	}	

	// Check the frame size. You don't need to do this if you trust your input.
	frameSize := len(pcm) // must be interleaved if stereo
	frameSizeMs := float32(frameSize) / channels * 1000 / sampleRate
	switch frameSizeMs {
		case 2.5, 5, 10, 20, 40, 60:
    	// Good.
	default:
		fmt.Println("Illegal frame size: ", frameSize,  "bytes", frameSizeMs)
    	return nil, err
	}

	data := make([]byte, bufferSize)
	n, err := enc.Encode(pcm, data)
	if err != nil {
    	panic(err)
	}
	data = data[:n] // only the first N bytes are opus data. Just like io.Reader.
	fmt.Print(n, len(data))
	return data, err
}

func chk(err error) {
	if err != nil {
		panic(err)
	}
}

MPlayer 1.3.0 (Debian), built with gcc-7 (C) 2000-2016 MPlayer Team
do_connect: could not connect to socket
connect: No such file or directory
Failed to open LIRC support. You will not be able to use your remote control.

Playing output.ogg.
libavformat version 57.83.100 (external)
libavformat file format detected.
[ogg @ 0xb6952e98]cannot find sync word
LAVF_header: av_open_input_stream() failed
libavformat file format detected.
[ogg @ 0xb6952e98]cannot find sync word
LAVF_header: av_open_input_stream() failed

opusOutput := make([]byte, 0)
opusData := make([]byte, 4096)

encodedNumSum := 0
for encodedNumSum+OpusFrameSize < len(pcmInt16Data) {
	encodedNum, err := enc.Encode(pcmInt16Data[encodedNumSum:(encodedNumSum+OpusFrameSize)], opusData)
	if err != nil {
		fmt.Println("enc.Encode err ", err.Error())
		break
	}
	fmt.Println("encodedNum ", encodedNum)
	opusOutput = append(opusOutput, opusData[:encodedNum]...)
	encodedNumSum += OpusFrameSize
}
fmt.Println("opusOutput length ", len(opusOutput))
fopus, _ := os.OpenFile("output.opus", os.O_RDWR|os.O_CREATE, 0777)
fopus.Write(opusOutput)
fopus.Close()

https://github.com/xiph/opus
https://github.com/xiph/opusfile.git

func main() {
	runtime.GOMAXPROCS(runtime.NumCPU()) // Utilize all available CPU cores

	outboundAudioTrack, err := webrtc.NewTrackLocalStaticRTP(webrtc.RTPCodecCapability{
		MimeType: webrtc.MimeTypeOpus,
	}, "audio", "pion")
	if err != nil {
		log.Fatalf("Failed to create audio track: %s", err)
	}

	// Initialize PortAudio
	if err := portaudio.Initialize(); err != nil {
		log.Fatalf("Failed to initialize PortAudio: %s", err)
	}
	defer portaudio.Terminate()

	go StartMicrophoneStream(outboundAudioTrack)
}

func StartMicrophoneStream(outboundAudioTrack *webrtc.TrackLocalStaticRTP) {
	// Open default microphone device
	stream, err := portaudio.OpenDefaultStream(1, 0, sampleRate, frameSize, readAudio)
	if err != nil {
		log.Fatalf("Failed to open default stream: %s", err)
	}
	defer stream.Close()

	// Start the audio stream
	if err := stream.Start(); err != nil {
		log.Fatalf("Failed to start stream: %s", err)
	}
	defer stream.Stop()

	log.Println("Microphone streaming started")

	// Keep the stream open
	select {}
}

func readAudio(in []int16) {
	// Log input buffer
	// log.Printf("Captured audio data: %v", inputBuffer)

	// Create Opus encoder
	encoder, err := opus.NewEncoder(sampleRate, channels, opus.AppVoIP)
	if err != nil {
		log.Fatalf("Failed to create Opus encoder: %s", err)
	}

	// Encode PCM to Opus
	packet := make([]byte, 4000) // Adjust size as needed
	n, err := encoder.Encode(in, packet)
	if err != nil {
		log.Printf("Error encoding PCM to Opus: %s", err)
		return
	}

	// Log encoded packet size
	// log.Printf("Encoded audio packet size: %d", n)

	// Create RTP packet
	rtpPacket := &rtp.Packet{
		Header: rtp.Header{
			Version:        2,
			PayloadType:    111,                           // Dynamic payload type for Opus
			SequenceNumber: uint16(time.Now().UnixNano()), // Use a more appropriate sequence number generator
			Timestamp:      uint32(time.Now().UnixNano() / int64(time.Millisecond)),
			SSRC:           12345,
		},
		Payload: packet[:n],
	}

	// Marshal RTP packet to bytes
	rawPacket, err := rtpPacket.Marshal()
	if err != nil {
		log.Printf("Error marshaling RTP packet: %s", err)
		return
	}

	// Log RTP packet details
	// log.Printf("RTP packet details: %v", rtpPacket.Header)

	// Send RTP packet over WebRTC track
	if err := outboundAudioTrack.WriteRTP(rtpPacket); err != nil {
		log.Printf("Error writing RTP packet to track: %s", err)
	} else {
		log.Printf("RTP packet sent: %d bytes", len(rawPacket))
	}
}`

        r := bytes.NewReader(resp.AudioContent)
        s, err := opus.NewStream(r)

$ go build -race && ./run

fatal error: checkptr: unsafe pointer arithmetic

goroutine 230 [running]:
runtime.throw(0x12d4205, 0x23)
	/usr/local/go/src/runtime/panic.go:1116 +0x72 fp=0xc000519ae8 sp=0xc000519ab8 pc=0x4473d2
runtime.checkptrArithmetic(0x1, 0x0, 0x0, 0x0)
	/usr/local/go/src/runtime/checkptr.go:26 +0xce fp=0xc000519b18 sp=0xc000519ae8 pc=0x41a2ee
gopkg.in/hraban/opus%2ev2.(*Stream).Init.func1(0xc000498880, 0xc00037b1c8, 0x1)
	/home/chrb/go/pkg/mod/gopkg.in/hraban/[email protected]/stream.go:108 +0x66 fp=0xc000519b70 sp=0xc000519b18 pc=0xe256b6
gopkg.in/hraban/opus%2ev2.(*Stream).Init(0xc000498880, 0x15f9060, 0xc00071d230, 0x0, 0x0)
	/home/chrb/go/pkg/mod/gopkg.in/hraban/[email protected]/stream.go:112 +0x277 fp=0xc000519c40 sp=0xc000519b70 pc=0xe237d7
gopkg.in/hraban/opus%2ev2.NewStream(0x15f9060, 0xc00071d230, 0xc0000a7bf0, 0xc000502740, 0x0)
	/home/chrb/go/pkg/mod/gopkg.in/hraban/[email protected]/stream.go:75 +0xa0 fp=0xc000519c90 sp=0xc000519c40 pc=0xe234c0
main.sayGoogle(0xc0000198e0, 0x14, 0xc00031e4a0, 0x9, 0x0, 0x0, 0x0, 0x0, 0x0)
	/home/chrb/go/src/x/main.go:310 +0x568 fp=0xc000519e58 sp=0xc000519c90 pc=0x105a948
main.speak(0xc0000198e0, 0x14, 0xc000472000, 0xc0004a5a40)
	/home/chrb/go/src/x/main.go:488 +0x166 fp=0xc000519f70 sp=0xc000519e58 pc=0x105cf36
main.handleIncomingAudio.func4(0xc000472000, 0xc0004a5a40, 0xc0003074e0)
	/home/chrb/go/src/x/main.go:967 +0xeb fp=0xc000519fc8 sp=0xc000519f70 pc=0x10773bb
runtime.goexit()
	/usr/local/go/src/runtime/asm_amd64.s:1373 +0x1 fp=0xc000519fd0 sp=0xc000519fc8 pc=0x4792f1
created by main.handleIncomingAudio
	/home/chrb/go/src/x/main.go:962 +0x281