ebiten/exp/audio/audio_openal.go

210 lines
4.5 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
package audio
2015-01-24 06:50:41 +01:00
import (
2016-02-11 19:06:04 +01:00
"fmt"
"io"
2016-02-11 19:06:04 +01:00
"runtime"
"sync"
"time"
2015-06-07 15:01:14 +02:00
2016-02-11 19:06:04 +01:00
"golang.org/x/mobile/exp/audio/al"
)
const (
maxSourceNum = 32
maxBufferNum = 8
)
var totalBufferNum = 0
var playerCache = []*player{}
2016-02-11 10:43:11 +01:00
type player struct {
2016-02-11 19:06:04 +01:00
alSource al.Source
alBuffers []al.Buffer
source io.ReadSeeker
sampleRate int
isClosed bool
2016-02-11 10:43:11 +01:00
}
2016-02-11 19:06:04 +01:00
var m sync.Mutex
func newPlayerFromCache(src io.ReadSeeker, sampleRate int) (*player, error) {
for _, p := range playerCache {
if p.sampleRate != sampleRate {
continue
}
if !p.isClosed {
continue
}
p.source = src
p.isClosed = false
return p, nil
}
if maxSourceNum <= len(playerCache) {
return nil, ErrTooManyPlayers
2016-02-11 19:06:04 +01:00
}
s := al.GenSources(1)
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: al.GenSources error: %d", err))
}
p := &player{
alSource: s[0],
alBuffers: []al.Buffer{},
source: src,
sampleRate: sampleRate,
}
runtime.SetFinalizer(p, (*player).close)
playerCache = append(playerCache, p)
return p, nil
}
func newPlayer(src io.ReadSeeker, sampleRate int) (*Player, error) {
m.Lock()
defer m.Unlock()
if e := al.OpenDevice(); e != nil {
m.Unlock()
return nil, fmt.Errorf("audio: OpenAL initialization failed: %v", e)
}
p, err := newPlayerFromCache(src, sampleRate)
if err != nil {
return nil, err
}
return &Player{p}, nil
2016-02-11 19:06:04 +01:00
}
const bufferSize = 1024
func (p *player) proceed() error {
m.Lock()
2016-02-13 12:43:27 +01:00
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: before proceed: %d", err))
}
2016-02-11 19:06:04 +01:00
processedNum := p.alSource.BuffersProcessed()
if 0 < processedNum {
bufs := make([]al.Buffer, processedNum)
p.alSource.UnqueueBuffers(bufs...)
2016-02-13 12:43:27 +01:00
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: Unqueue in process: %d", err))
}
2016-02-11 19:06:04 +01:00
p.alBuffers = append(p.alBuffers, bufs...)
}
m.Unlock()
2016-02-11 19:06:04 +01:00
for 0 < len(p.alBuffers) {
b := make([]byte, bufferSize)
n, err := p.source.Read(b)
if 0 < n {
m.Lock()
buf := p.alBuffers[0]
p.alBuffers = p.alBuffers[1:]
buf.BufferData(al.FormatStereo16, b[:n], int32(p.sampleRate))
p.alSource.QueueBuffers(buf)
2016-02-13 12:43:27 +01:00
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: Queue in process: %d", err))
}
2016-02-11 19:06:04 +01:00
m.Unlock()
}
if err != nil {
return err
}
}
2016-02-11 19:06:04 +01:00
m.Lock()
if p.alSource.State() == al.Stopped {
al.RewindSources(p.alSource)
al.PlaySources(p.alSource)
2016-02-13 12:43:27 +01:00
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: PlaySource in process: %d", err))
}
2016-02-11 19:06:04 +01:00
}
m.Unlock()
return nil
2016-02-11 10:43:11 +01:00
}
func (p *player) play() error {
2016-02-11 19:06:04 +01:00
// TODO: What if play is already called?
m.Lock()
n := maxBufferNum - int(p.alSource.BuffersQueued()) - len(p.alBuffers)
if 0 < n {
p.alBuffers = append(p.alBuffers, al.GenBuffers(n)...)
totalBufferNum += n
if maxSourceNum*maxBufferNum < totalBufferNum {
panic("audio: too many buffers are created")
}
}
if 0 < len(p.alBuffers) {
emptyBytes := make([]byte, bufferSize)
for _, buf := range p.alBuffers {
// Note that the third argument of only the first buffer is used.
buf.BufferData(al.FormatStereo16, emptyBytes, int32(p.sampleRate))
p.alSource.QueueBuffers(buf)
}
p.alBuffers = []al.Buffer{}
2016-02-11 19:06:04 +01:00
}
al.PlaySources(p.alSource)
m.Unlock()
2016-02-11 19:06:04 +01:00
go func() {
2016-02-15 02:41:02 +01:00
// TODO: Is it OK to close asap?
2016-02-11 19:06:04 +01:00
defer p.close()
for {
err := p.proceed()
if err == io.EOF {
break
}
if err != nil {
// TODO: Record the last error
panic(err)
}
time.Sleep(1)
}
}()
return nil
}
2016-02-11 11:55:59 +01:00
func (p *player) close() error {
2016-02-11 19:06:04 +01:00
m.Lock()
defer m.Unlock()
2016-02-13 12:43:27 +01:00
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: error before closing: %d", err))
}
if p.isClosed {
return nil
2016-02-11 19:06:04 +01:00
}
var bs []al.Buffer
al.RewindSources(p.alSource)
al.StopSources(p.alSource)
n := p.alSource.BuffersQueued()
if 0 < n {
bs = make([]al.Buffer, n)
p.alSource.UnqueueBuffers(bs...)
p.alBuffers = append(p.alBuffers, bs...)
2016-02-11 19:06:04 +01:00
}
p.isClosed = true
if err := al.Error(); err != 0 {
panic(fmt.Sprintf("audio: error after closing: %d", err))
}
2016-02-11 19:06:04 +01:00
runtime.SetFinalizer(p, nil)
return nil
2016-02-11 11:55:59 +01:00
}