mth/ebiten
1
0
Fork 0
mirror of https://github.com/hajimehoshi/ebiten.git synced 2024-11-10 04:57:26 +01:00
Code Issues Packages Projects Releases Wiki Activity

audio: remove const bytesPerSampleInt16

Browse Source 
This is a preparation for float32 players.

Updates #2160
This commit is contained in:
Hajime Hoshi 2024-07-06 23:43:27 +09:00
parent 073d022c2e
commit 844a4de872
3 changed files with 60 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
audio/audio.go
View File

@ -48,7 +48,6 @@ import (
const (
channelCount = 2
bitDepthInBytesInt16 = 2
bytesPerSampleInt16 = bitDepthInBytesInt16 * channelCount
)
// A Context represents a current state of audio.
@ -324,7 +323,7 @@ type Player struct {
// A Player doesn't close src even if src implements io.Closer.
// Closing the source is src owner's responsibility.
func (c *Context) NewPlayer(src io.Reader) (*Player, error) {
pi, err := c.playerFactory.newPlayer(c, src)
pi, err := c.playerFactory.newPlayer(c, src, bitDepthInBytesInt16)
if err != nil {
return nil, err
}

38
audio/loop.go
View File

@ -25,8 +25,10 @@ type InfiniteLoop struct {
lstart int64
llength int64
pos int64
bitDepthInBytes int
bytesPerSample int
// extra is the remainder in the case when the read byte sizes are not multiple of bitDepthInBytesInt16.
// extra is the remainder in the case when the read byte sizes are not multiple of the bit depth.
extra []byte
// afterLoop is data after the loop.
@ -58,11 +60,18 @@ func NewInfiniteLoop(src io.ReadSeeker, length int64) *InfiniteLoop {
// If src has data after the loop end, an InfiniteLoop uses part of the data to blend with the loop start
// to make the loop joint smooth.
func NewInfiniteLoopWithIntro(src io.ReadSeeker, introLength int64, loopLength int64) *InfiniteLoop {
return newInfiniteLoopWithIntro(src, introLength, loopLength, bitDepthInBytesInt16)
}
func newInfiniteLoopWithIntro(src io.ReadSeeker, introLength int64, loopLength int64, bitDepthInBytes int) *InfiniteLoop {
bytesPerSample := bitDepthInBytes * channelCount
return &InfiniteLoop{
src: src,
lstart: introLength / bytesPerSampleInt16 * bytesPerSampleInt16,
llength: loopLength / bytesPerSampleInt16 * bytesPerSampleInt16,
lstart: introLength / int64(bytesPerSample) * int64(bytesPerSample),
llength: loopLength / int64(bytesPerSample) * int64(bytesPerSample),
pos: -1,
bitDepthInBytes: bitDepthInBytes,
bytesPerSample: bytesPerSample,
}
}
@ -92,8 +101,8 @@ func (i *InfiniteLoop) blendRate(pos int64) float64 {
if pos >= i.lstart+int64(len(i.afterLoop)) {
return 0
}
p := (pos - i.lstart) / bytesPerSampleInt16
l := len(i.afterLoop) / bytesPerSampleInt16
p := (pos - i.lstart) / int64(i.bytesPerSample)
l := len(i.afterLoop) / i.bytesPerSample
return 1 - float64(p)/float64(l)
}
@ -119,7 +128,7 @@ func (i *InfiniteLoop) Read(b []byte) (int, error) {
}
// Save the remainder part to extra. This will be used at the next Read.
if rem := n % bitDepthInBytesInt16; rem != 0 {
if rem := n % i.bitDepthInBytes; rem != 0 {
i.extra = append(i.extra, b[n-rem:n]...)
b = b[:n-rem]
n = n - rem
@ -128,24 +137,27 @@ func (i *InfiniteLoop) Read(b []byte) (int, error) {
// Blend afterLoop and the loop start to reduce noises (#1888).
// Ideally, afterLoop and the loop start should be identical, but they can have very slight differences.
if !i.noBlendForTesting && i.blending && i.pos >= i.lstart && i.pos-int64(n) < i.lstart+int64(len(i.afterLoop)) {
if n%bitDepthInBytesInt16 != 0 {
panic(fmt.Sprintf("audio: n must be a multiple of bitDepthInBytesInt16 but not: %d", n))
if n%i.bitDepthInBytes != 0 {
panic(fmt.Sprintf("audio: n must be a multiple of bit depth %d [bytes] but not: %d", i.bitDepthInBytes, n))
}
for idx := 0; idx < n/bitDepthInBytesInt16; idx++ {
abspos := i.pos - int64(n) + int64(idx)*bitDepthInBytesInt16
for idx := 0; idx < n/i.bitDepthInBytes; idx++ {
abspos := i.pos - int64(n) + int64(idx)*int64(i.bitDepthInBytes)
rate := i.blendRate(abspos)
if rate == 0 {
continue
}
// This assumes that bitDepthInBytesInt16 is 2.
relpos := abspos - i.lstart
switch i.bitDepthInBytes {
case 2:
afterLoop := int16(i.afterLoop[relpos]) | (int16(i.afterLoop[relpos+1]) << 8)
orig := int16(b[2*idx]) | (int16(b[2*idx+1]) << 8)
newval := int16(float64(afterLoop)*rate + float64(orig)*(1-rate))
b[2*idx] = byte(newval)
b[2*idx+1] = byte(newval >> 8)
default:
panic("not reached")
}
}
}
@ -156,7 +168,7 @@ func (i *InfiniteLoop) Read(b []byte) (int, error) {
// Read the afterLoop part if necessary.
if i.pos == i.length() && err == nil {
if i.afterLoop == nil {
buflen := int64(256 * bytesPerSampleInt16)
buflen := int64(256 * i.bytesPerSample)
if buflen > i.length() {
buflen = i.length()
}

24
audio/player.go
View File

@ -69,6 +69,7 @@ type playerImpl struct {
stream *timeStream
factory *playerFactory
initBufferSize int
bytesPerSample int
// adjustedPosition is the player's more accurate position.
// The underlying buffer might not be changed even if the player is playing.
@ -85,7 +86,7 @@ type playerImpl struct {
m sync.Mutex
}
func (f *playerFactory) newPlayer(context *Context, src io.Reader) (*playerImpl, error) {
func (f *playerFactory) newPlayer(context *Context, src io.Reader, bitDepthInBytes int) (*playerImpl, error) {
f.m.Lock()
defer f.m.Unlock()
@ -94,6 +95,7 @@ func (f *playerFactory) newPlayer(context *Context, src io.Reader) (*playerImpl,
context: context,
factory: f,
lastSamples: -1,
bytesPerSample: bitDepthInBytes * channelCount,
}
runtime.SetFinalizer(p, (*playerImpl).Close)
return p, nil
@ -163,7 +165,7 @@ func (p *playerImpl) ensurePlayer() error {
}
if p.stream == nil {
s, err := newTimeStream(p.src, p.factory.sampleRate)
s, err := newTimeStream(p.src, p.factory.sampleRate, p.bytesPerSample/channelCount)
if err != nil {
return err
}
@ -313,8 +315,8 @@ func (p *playerImpl) SetBufferSize(bufferSize time.Duration) {
p.m.Lock()
defer p.m.Unlock()
bufferSizeInBytes := int(bufferSize * bytesPerSampleInt16 * time.Duration(p.factory.sampleRate) / time.Second)
bufferSizeInBytes = bufferSizeInBytes / bytesPerSampleInt16 * bytesPerSampleInt16
bufferSizeInBytes := int(bufferSize * time.Duration(p.bytesPerSample) * time.Duration(p.factory.sampleRate) / time.Second)
bufferSizeInBytes = bufferSizeInBytes / p.bytesPerSample * p.bytesPerSample
if p.player == nil {
p.initBufferSize = bufferSizeInBytes
return
@ -361,7 +363,7 @@ func (p *playerImpl) updatePosition() {
return
}
samples := (p.stream.position() - int64(p.player.BufferedSize())) / bytesPerSampleInt16
samples := (p.stream.position() - int64(p.player.BufferedSize())) / int64(p.bytesPerSample)
var adjustingTime time.Duration
if p.lastSamples >= 0 && p.lastSamples == samples {
@ -384,16 +386,18 @@ type timeStream struct {
r io.Reader
sampleRate int
pos int64
bytesPerSample int
// m is a mutex for this stream.
// All the exported functions are protected by this mutex as Read can be read from a different goroutine than Seek.
m sync.Mutex
}
func newTimeStream(r io.Reader, sampleRate int) (*timeStream, error) {
func newTimeStream(r io.Reader, sampleRate int, bitDepthInBytes int) (*timeStream, error) {
s := &timeStream{
r: r,
sampleRate: sampleRate,
bytesPerSample: bitDepthInBytes * channelCount,
}
if seeker, ok := s.r.(io.Seeker); ok {
// Get the current position of the source.
@ -437,11 +441,11 @@ func (s *timeStream) timeDurationToPos(offset time.Duration) int64 {
s.m.Lock()
defer s.m.Unlock()
o := int64(offset) * bytesPerSampleInt16 * int64(s.sampleRate) / int64(time.Second)
o := int64(offset) * int64(s.bytesPerSample) * int64(s.sampleRate) / int64(time.Second)
// Align the byte position with the samples.
o -= o % bytesPerSampleInt16
o += s.pos % bytesPerSampleInt16
o -= o % int64(s.bytesPerSample)
o += s.pos % int64(s.bytesPerSample)
return o
}
@ -457,5 +461,5 @@ func (s *timeStream) positionInTimeDuration() time.Duration {
s.m.Lock()
defer s.m.Unlock()
return time.Duration(s.pos) * time.Second / (time.Duration(s.sampleRate) * bytesPerSampleInt16)
return time.Duration(s.pos) * time.Second / (time.Duration(s.sampleRate * s.bytesPerSample))
}