ebiten/exp/audio/internal/driver/driver_openal.go

157 lines
4.2 KiB
Go
Raw Normal View History

2015-01-24 06:50:41 +01:00
// Copyright 2015 Hajime Hoshi
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// +build !js,!windows
2015-01-24 06:50:41 +01:00
2016-04-08 17:54:18 +02:00
package driver
2015-01-24 06:50:41 +01:00
import (
"errors"
2016-02-11 19:06:04 +01:00
"fmt"
"runtime"
2015-06-07 15:01:14 +02:00
"github.com/hajimehoshi/go-openal/openal"
)
// As x/mobile/exp/audio/al is broken on Mac OS X (https://github.com/golang/go/issues/15075),
2016-04-09 18:13:15 +02:00
// let's use github.com/hajimehoshi/go-openal instead.
const (
maxBufferNum = 8
)
2016-04-08 17:54:18 +02:00
type Player struct {
alDevice *openal.Device
alSource openal.Source
alBuffers []openal.Buffer
2016-02-11 19:06:04 +01:00
sampleRate int
isClosed bool
alFormat openal.Format
}
func alFormat(channelNum, bytesPerSample int) openal.Format {
switch {
case channelNum == 1 && bytesPerSample == 1:
return openal.FormatMono8
case channelNum == 1 && bytesPerSample == 2:
return openal.FormatMono16
case channelNum == 2 && bytesPerSample == 1:
return openal.FormatStereo8
case channelNum == 2 && bytesPerSample == 2:
return openal.FormatStereo16
}
panic(fmt.Sprintf("driver: invalid channel num (%d) or bytes per sample (%d)", channelNum, bytesPerSample))
2016-02-11 10:43:11 +01:00
}
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.alSource.QueueBuffer(b)
p.alBuffers = append(p.alBuffers, b)
}
p.alSource.Play()
2016-04-04 16:42:44 +02:00
return p, nil
}
func (p *Player) Proceed(data []byte) error {
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: starting Proceed: %v", err)
2016-02-13 12:43:27 +01:00
}
2016-02-11 19:06:04 +01:00
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)
2016-02-13 12:43:27 +01:00
}
2016-02-11 19:06:04 +01:00
p.alBuffers = append(p.alBuffers, bufs...)
}
if len(p.alBuffers) == 0 {
return errors.New("driver: p.alBuffers must > 0")
}
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 {
2016-04-09 19:14:20 +02:00
return fmt.Errorf("driver: Rewind or Play: %v", err)
2016-02-13 12:43:27 +01:00
}
2016-02-11 19:06:04 +01:00
}
return nil
2016-02-11 10:43:11 +01:00
}
2016-04-08 17:54:18 +02:00
func (p *Player) Close() error {
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: starting Close: %v", err)
2016-02-13 12:43:27 +01:00
}
if p.isClosed {
return nil
2016-02-11 19:06:04 +01:00
}
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...)
2016-02-11 19:06:04 +01:00
}
p.alDevice.CloseDevice()
p.isClosed = true
if err := openal.Err(); err != nil {
return fmt.Errorf("driver: CloseDevice: %v", err)
}
2016-02-11 19:06:04 +01:00
runtime.SetFinalizer(p, nil)
return nil
2016-02-11 11:55:59 +01:00
}