func (s *Stream) sourceRoutine() {
interval := s.client.Config.AudioInterval
frameSize := s.client.Config.GetAudioFrameSize()
if frameSize != s.sourceFrameSize {
s.deviceSource.CaptureCloseDevice()
s.sourceFrameSize = frameSize
s.deviceSource = openal.CaptureOpenDevice("", gumble.AudioSampleRate, openal.FormatMono16, uint32(s.sourceFrameSize))
}
ticker := time.NewTicker(interval)
defer ticker.Stop()
stop := s.sourceStop
int16Buffer := make([]int16, frameSize)
for {
select {
case <-stop:
return
case <-ticker.C:
buff := s.deviceSource.CaptureSamples(uint32(frameSize))
if len(buff) != frameSize*2 {
continue
}
for i := range int16Buffer {
int16Buffer[i] = int16(binary.LittleEndian.Uint16(buff[i*2 : (i+1)*2]))
}
s.client.Send(gumble.AudioBuffer(int16Buffer))
}
}
}
func ExampleMonitor() {
const (
frequency = 44100
format = openal.FormatStereo16
captureSize = 512
buffersCount = 10
)
mic := openal.CaptureOpenDevice("", frequency, format, frequency*2)
mic.CaptureStart()
defer mic.CloseDevice()
device := openal.OpenDevice("")
defer device.CloseDevice()
context := device.CreateContext()
context.Activate()
defer context.Destroy()
source := openal.NewSource()
source.SetLooping(false)
defer source.Stop()
buffers := openal.NewBuffers(buffersCount)
samples := make([]byte, captureSize*format.SampleSize())
start := time.Now()
for time.Since(start) < time.Second { // play for 1 second
if err := openal.Err(); err != nil {
fmt.Println("error:", err)
return
}
// Get any free buffers
if prcessed := source.BuffersProcessed(); prcessed > 0 {
buffersNew := make(openal.Buffers, prcessed)
source.UnqueueBuffers(buffersNew)
buffers = append(buffers, buffersNew...)
}
if len(buffers) == 0 {
continue
}
if mic.CapturedSamples() >= captureSize {
mic.CaptureTo(samples)
buffer := buffers[len(buffers)-1]
buffers = buffers[:len(buffers)-1]
buffer.SetData(format, samples, frequency)
source.QueueBuffer(buffer)
// If we have enough buffers, start playing
if source.State() != openal.Playing {
if source.BuffersQueued() > 2 {
source.Play()
}
}
}
}
fmt.Println(source.State())
// Output: Playing
}
func New(client *gumble.Client) (*Stream, error) {
s := &Stream{
client: client,
sourceFrameSize: client.Config.AudioFrameSize(),
}
s.deviceSource = openal.CaptureOpenDevice("", gumble.AudioSampleRate, openal.FormatMono16, uint32(s.sourceFrameSize))
s.deviceSink = openal.OpenDevice("")
s.contextSink = s.deviceSink.CreateContext()
s.contextSink.Activate()
s.link = client.Config.AttachAudio(s)
return s, nil
}
func New(client *gumble.Client) (*Stream, error) {
s := &Stream{
client: client,
userStreams: make(map[uint32]openal.Source),
sourceFrameSize: client.Config.GetAudioFrameSize(),
}
s.deviceSource = openal.CaptureOpenDevice("", gumble.AudioSampleRate, openal.FormatMono16, uint32(s.sourceFrameSize))
s.deviceSink = openal.OpenDevice("")
s.contextSink = s.deviceSink.CreateContext()
s.contextSink.Activate()
s.buffer = make([]byte, gumble.AudioMaximumFrameSize)
s.link = client.AttachAudio(s)
return s, nil
}