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 NewPlayer(sampleRate, channelNum, bytesPerSample int) (*Player, error) {
d := openal.OpenDevice("")
if d == nil {
return nil, fmt.Errorf("driver: OpenDevice must not return nil")
}
c := d.CreateContext()
if c == nil {
return nil, fmt.Errorf("driver: CreateContext must not return nil")
}
// Don't check openal.Err until making the current context is done.
// Linux might fail this check even though it succeeds (#204).
c.Activate()
if err := openal.Err(); err != nil {
return nil, fmt.Errorf("driver: Activate: %v", err)
}
s := openal.NewSource()
if err := openal.Err(); err != nil {
return nil, fmt.Errorf("driver: NewSource: %v", err)
}
p := &Player{
alDevice: d,
alSource: s,
alBuffers: []openal.Buffer{},
sampleRate: sampleRate,
alFormat: alFormat(channelNum, bytesPerSample),
}
runtime.SetFinalizer(p, (*Player).Close)
bs := openal.NewBuffers(maxBufferNum)
const bufferSize = 1024
emptyBytes := make([]byte, bufferSize)
for _, b := range bs {
// Note that the third argument of only the first buffer is used.
b.SetData(p.alFormat, emptyBytes, int32(p.sampleRate))
p.alBuffers = append(p.alBuffers, b)
}
p.alSource.Play()
return p, nil
}
func (p *Player) Close() error {
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: starting Close: %v", err)
}
if p.isClosed {
return nil
}
var bs []openal.Buffer
p.alSource.Rewind()
p.alSource.Play()
if n := p.alSource.BuffersQueued(); 0 < n {
bs = make([]openal.Buffer, n)
p.alSource.UnqueueBuffers(bs)
p.alBuffers = append(p.alBuffers, bs...)
}
p.alDevice.CloseDevice()
p.isClosed = true
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: CloseDevice: %v", err)
}
runtime.SetFinalizer(p, nil)
return nil
}
func (p *Player) Proceed(data []byte) error {
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: starting Proceed: %v", err)
}
processedNum := p.alSource.BuffersProcessed()
if 0 < processedNum {
bufs := make([]openal.Buffer, processedNum)
p.alSource.UnqueueBuffers(bufs)
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: UnqueueBuffers: %v", err)
}
p.alBuffers = append(p.alBuffers, bufs...)
}
if len(p.alBuffers) == 0 {
// This can happen (#207)
return nil
}
buf := p.alBuffers[0]
p.alBuffers = p.alBuffers[1:]
buf.SetData(p.alFormat, data, int32(p.sampleRate))
p.alSource.QueueBuffer(buf)
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: QueueBuffer: %v", err)
}
if p.alSource.State() == openal.Stopped || p.alSource.State() == openal.Initial {
p.alSource.Rewind()
p.alSource.Play()
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: Rewind or Play: %v", err)
}
}
return nil
}
func TestGetVendor(t *testing.T) {
device := openal.OpenDevice("")
defer device.CloseDevice()
context := device.CreateContext()
defer context.Destroy()
context.Activate()
vendor := openal.GetVendor()
if err := openal.Err(); err != nil {
t.Fatal(err)
} else if vendor == "" {
t.Fatal("empty vendor returned")
}
}
func ExamplePlay() {
device := openal.OpenDevice("")
defer device.CloseDevice()
context := device.CreateContext()
defer context.Destroy()
context.Activate()
source := openal.NewSource()
defer source.Pause()
source.SetLooping(false)
buffer := openal.NewBuffer()
if err := openal.Err(); err != nil {
fmt.Println(err)
return
}
data, err := ioutil.ReadFile("data/welcome.wav")
if err != nil {
fmt.Println(err)
return
}
buffer.SetData(openal.FormatMono16, data, 44100)
source.SetBuffer(buffer)
source.Play()
for source.State() == openal.Playing {
// loop long enough to let the wave file finish
time.Sleep(time.Millisecond * 100)
}
source.Delete()
fmt.Println("sound played")
// Output: sound played
}