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 }