mirror of
https://github.com/bloeys/wavy.git
synced 2025-12-29 09:28:19 +00:00
Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| eade35695f | |||
| 3d3cdf1e32 | |||
| 0021d0a7dc |
4
go.mod
4
go.mod
@ -5,7 +5,7 @@ go 1.18
|
||||
require (
|
||||
github.com/go-audio/wav v1.1.0
|
||||
github.com/hajimehoshi/go-mp3 v0.3.3
|
||||
github.com/hajimehoshi/oto/v2 v2.1.0
|
||||
github.com/hajimehoshi/oto/v2 v2.2.0
|
||||
github.com/jfreymuth/oggvorbis v1.0.3
|
||||
)
|
||||
|
||||
@ -13,5 +13,5 @@ require (
|
||||
github.com/go-audio/audio v1.0.0 // indirect
|
||||
github.com/go-audio/riff v1.0.0 // indirect
|
||||
github.com/jfreymuth/vorbis v1.0.2 // indirect
|
||||
golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f // indirect
|
||||
golang.org/x/sys v0.0.0-20220712014510-0a85c31ab51e // indirect
|
||||
)
|
||||
|
||||
4
go.sum
4
go.sum
@ -9,6 +9,8 @@ github.com/hajimehoshi/go-mp3 v0.3.3/go.mod h1:qMJj/CSDxx6CGHiZeCgbiq2DSUkbK0Ubt
|
||||
github.com/hajimehoshi/oto v0.6.1/go.mod h1:0QXGEkbuJRohbJaxr7ZQSxnju7hEhseiPx2hrh6raOI=
|
||||
github.com/hajimehoshi/oto/v2 v2.1.0 h1:/h+UkbKzhD7xBHOQlWgKUplBPZ+J4DK3P2Y7g2UF1X4=
|
||||
github.com/hajimehoshi/oto/v2 v2.1.0/go.mod h1:9i0oYbpJ8BhVGkXDKdXKfFthX1JUNfXjeTp944W8TGM=
|
||||
github.com/hajimehoshi/oto/v2 v2.2.0 h1:qhTriSacJ/2pdONRa90hjTvpEZH7xIP4W3itwYyE1Uk=
|
||||
github.com/hajimehoshi/oto/v2 v2.2.0/go.mod h1:seWLbgHH7AyUMYKfKYT9pg7PhUu9/SisyJvNTT+ASQo=
|
||||
github.com/jfreymuth/oggvorbis v1.0.3 h1:MLNGGyhOMiVcvea9Dp5+gbs2SAwqwQbtrWnonYa0M0Y=
|
||||
github.com/jfreymuth/oggvorbis v1.0.3/go.mod h1:1U4pqWmghcoVsCJJ4fRBKv9peUJMBHixthRlBeD6uII=
|
||||
github.com/jfreymuth/vorbis v1.0.2 h1:m1xH6+ZI4thH927pgKD8JOH4eaGRm18rEE9/0WKjvNE=
|
||||
@ -20,4 +22,6 @@ golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7w
|
||||
golang.org/x/sys v0.0.0-20190429190828-d89cdac9e872/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
|
||||
golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f h1:8w7RhxzTVgUzw/AH/9mUV5q0vMgy40SQRursCcfmkCw=
|
||||
golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/sys v0.0.0-20220712014510-0a85c31ab51e h1:NHvCuwuS43lGnYhten69ZWqi2QOj/CiDNcKbVqwVoew=
|
||||
golang.org/x/sys v0.0.0-20220712014510-0a85c31ab51e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
|
||||
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
|
||||
|
||||
@ -3,7 +3,6 @@ package wavy
|
||||
import (
|
||||
"io"
|
||||
"os"
|
||||
"sync"
|
||||
|
||||
"github.com/jfreymuth/oggvorbis"
|
||||
)
|
||||
@ -13,31 +12,20 @@ var _ io.ReadSeeker = &OggStreamer{}
|
||||
type OggStreamer struct {
|
||||
F *os.File
|
||||
Dec *oggvorbis.Reader
|
||||
|
||||
//TODO: This is currently needed because of https://github.com/hajimehoshi/oto/issues/171
|
||||
//We should be able to delete once its resolved
|
||||
mutex sync.Mutex
|
||||
}
|
||||
|
||||
func (ws *OggStreamer) Read(outBuf []byte) (floatsRead int, err error) {
|
||||
|
||||
ws.mutex.Lock()
|
||||
|
||||
readerBuf := make([]float32, len(outBuf)/2)
|
||||
floatsRead, err = ws.Dec.Read(readerBuf)
|
||||
F32ToUnsignedPCM16(readerBuf[:floatsRead], outBuf)
|
||||
|
||||
ws.mutex.Unlock()
|
||||
|
||||
return floatsRead * 2, err
|
||||
}
|
||||
|
||||
func (ws *OggStreamer) Seek(offset int64, whence int) (int64, error) {
|
||||
|
||||
ws.mutex.Lock()
|
||||
defer ws.mutex.Unlock()
|
||||
|
||||
//This is because ogg expects position in samples not bytes
|
||||
// This is because ogg expects position in samples not bytes
|
||||
offset /= BytesPerSample
|
||||
|
||||
switch whence {
|
||||
@ -61,15 +49,14 @@ func (ws *OggStreamer) Seek(offset int64, whence int) (int64, error) {
|
||||
return ws.Dec.Position() * BytesPerSample, nil
|
||||
}
|
||||
|
||||
//Size returns number of bytes
|
||||
// Size returns number of bytes
|
||||
func (ws *OggStreamer) Size() int64 {
|
||||
return ws.Dec.Length() * BytesPerSample
|
||||
}
|
||||
|
||||
func NewOggStreamer(f *os.File, dec *oggvorbis.Reader) *OggStreamer {
|
||||
return &OggStreamer{
|
||||
F: f,
|
||||
Dec: dec,
|
||||
mutex: sync.Mutex{},
|
||||
F: f,
|
||||
Dec: dec,
|
||||
}
|
||||
}
|
||||
|
||||
@ -5,7 +5,7 @@ import (
|
||||
"io"
|
||||
)
|
||||
|
||||
//Pre-defined errors
|
||||
// Pre-defined errors
|
||||
var (
|
||||
ErrInvalidWhence = errors.New("invalid whence value. Must be: io.SeekStart, io.SeekCurrent, or io.SeekEnd")
|
||||
ErrNegativeSeekPos = errors.New("negative seeker position")
|
||||
@ -16,11 +16,11 @@ var _ io.ReadSeeker = &SoundBuffer{}
|
||||
type SoundBuffer struct {
|
||||
Data []byte
|
||||
|
||||
//Pos is the starting position of the next read
|
||||
// Pos is the starting position of the next read
|
||||
Pos int64
|
||||
}
|
||||
|
||||
//Read only returns io.EOF when bytesRead==0 and no more input is available
|
||||
// Read only returns io.EOF when bytesRead==0 and no more input is available
|
||||
func (sb *SoundBuffer) Read(outBuf []byte) (bytesRead int, err error) {
|
||||
|
||||
bytesRead = copy(outBuf, sb.Data[sb.Pos:])
|
||||
@ -32,10 +32,10 @@ func (sb *SoundBuffer) Read(outBuf []byte) (bytesRead int, err error) {
|
||||
return bytesRead, nil
|
||||
}
|
||||
|
||||
//Seek returns the new position.
|
||||
//An error is only returned if the whence is invalid or if the resulting position is negative.
|
||||
// Seek returns the new position.
|
||||
// An error is only returned if the whence is invalid or if the resulting position is negative.
|
||||
//
|
||||
//If the resulting position is >=len(SoundBuffer.Data) then future Read() calls will return io.EOF
|
||||
// If the resulting position is >=len(SoundBuffer.Data) then future Read() calls will return io.EOF
|
||||
func (sb *SoundBuffer) Seek(offset int64, whence int) (int64, error) {
|
||||
|
||||
newPos := sb.Pos
|
||||
@ -58,10 +58,10 @@ func (sb *SoundBuffer) Seek(offset int64, whence int) (int64, error) {
|
||||
return sb.Pos, nil
|
||||
}
|
||||
|
||||
//Copy returns a new SoundBuffer that uses the same `Data` but with an independent ReadSeeker.
|
||||
//This allows you to have many readers all reading from different positions of the same buffer.
|
||||
// Copy returns a new SoundBuffer that uses the same `Data` but with an independent ReadSeeker.
|
||||
// This allows you to have many readers all reading from different positions of the same buffer.
|
||||
//
|
||||
//The new buffer will have its starting position set to io.SeekStart (`Pos=0`)
|
||||
// The new buffer will have its starting position set to io.SeekStart (`Pos=0`)
|
||||
func (sb *SoundBuffer) Copy() *SoundBuffer {
|
||||
return &SoundBuffer{
|
||||
Data: sb.Data,
|
||||
|
||||
@ -3,7 +3,6 @@ package wavy
|
||||
import (
|
||||
"io"
|
||||
"os"
|
||||
"sync"
|
||||
|
||||
"github.com/go-audio/wav"
|
||||
)
|
||||
@ -15,35 +14,26 @@ type WavStreamer struct {
|
||||
Dec *wav.Decoder
|
||||
Pos int64
|
||||
PCMStart int64
|
||||
|
||||
//TODO: This is currently needed because of https://github.com/hajimehoshi/oto/issues/171
|
||||
//We should be able to delete once its resolved
|
||||
mutex sync.Mutex
|
||||
}
|
||||
|
||||
func (ws *WavStreamer) Read(outBuf []byte) (bytesRead int, err error) {
|
||||
|
||||
ws.mutex.Lock()
|
||||
bytesRead, err = ws.Dec.PCMChunk.Read(outBuf)
|
||||
ws.Pos += int64(bytesRead)
|
||||
ws.mutex.Unlock()
|
||||
|
||||
return bytesRead, err
|
||||
}
|
||||
|
||||
func (ws *WavStreamer) Seek(offset int64, whence int) (int64, error) {
|
||||
|
||||
ws.mutex.Lock()
|
||||
defer ws.mutex.Unlock()
|
||||
|
||||
//This will only seek the underlying file but not the actual decoder because it can't seek
|
||||
// This will only seek the underlying file but not the actual decoder because it can't seek
|
||||
n, err := ws.Dec.Seek(offset, whence)
|
||||
if err != nil {
|
||||
return n, err
|
||||
}
|
||||
|
||||
//Since underlying decoder can't seek back, if the requested movement is back we have to rewind the decoder
|
||||
//then seek forward to the requested position.
|
||||
// Since underlying decoder can't seek back, if the requested movement is back we have to rewind the decoder
|
||||
// then seek forward to the requested position.
|
||||
if n < ws.Pos {
|
||||
|
||||
err = ws.Dec.Rewind()
|
||||
@ -51,7 +41,7 @@ func (ws *WavStreamer) Seek(offset int64, whence int) (int64, error) {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
//Anything before PCMStart is not valid sound, so the minimum seek back we allow is PCMStart
|
||||
// Anything before PCMStart is not valid sound, so the minimum seek back we allow is PCMStart
|
||||
if n < ws.PCMStart {
|
||||
n = ws.PCMStart
|
||||
} else {
|
||||
@ -66,7 +56,7 @@ func (ws *WavStreamer) Seek(offset int64, whence int) (int64, error) {
|
||||
return n, err
|
||||
}
|
||||
|
||||
//Size returns number of bytes
|
||||
// Size returns number of bytes
|
||||
func (ws *WavStreamer) Size() int64 {
|
||||
return ws.Dec.PCMLen()
|
||||
}
|
||||
@ -78,7 +68,7 @@ func NewWavStreamer(f *os.File, wavDec *wav.Decoder) (*WavStreamer, error) {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
//The actual data starts somewhat within the file, not at 0
|
||||
// The actual data starts somewhat within the file, not at 0
|
||||
currPos, err := wavDec.Seek(0, 1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@ -89,6 +79,5 @@ func NewWavStreamer(f *os.File, wavDec *wav.Decoder) (*WavStreamer, error) {
|
||||
Dec: wavDec,
|
||||
Pos: currPos,
|
||||
PCMStart: currPos,
|
||||
mutex: sync.Mutex{},
|
||||
}, nil
|
||||
}
|
||||
|
||||
181
wavy.go
181
wavy.go
@ -16,7 +16,7 @@ import (
|
||||
"github.com/jfreymuth/oggvorbis"
|
||||
)
|
||||
|
||||
//SoundInfo contains static info about a loaded sound file
|
||||
// SoundInfo contains static info about a loaded sound file
|
||||
type SoundInfo struct {
|
||||
Type SoundType
|
||||
Mode SoundMode
|
||||
@ -25,21 +25,22 @@ type SoundInfo struct {
|
||||
}
|
||||
|
||||
type Sound struct {
|
||||
Player oto.Player
|
||||
Info SoundInfo
|
||||
Player oto.Player
|
||||
PlayerSeeker io.Seeker
|
||||
Info SoundInfo
|
||||
|
||||
//File is the file descriptor of the sound file being streamed.
|
||||
//This is only set if sound is streamed, and is kept to ensure GC doesn't hit it
|
||||
// File is the file descriptor of the sound file being streamed.
|
||||
// This is only set if sound is streamed, and is kept to ensure GC doesn't hit it
|
||||
File *os.File
|
||||
|
||||
//Data is an io.ReadSeeker over an open file or over a buffer containing the uncompressed sound file.
|
||||
//Becomes nil after close
|
||||
// Data is an io.ReadSeeker over an open file or over a buffer containing the uncompressed sound file.
|
||||
// Becomes nil after close
|
||||
Data io.ReadSeeker
|
||||
|
||||
IsLooping bool
|
||||
}
|
||||
|
||||
//Those values are set after Init
|
||||
// Those values are set after Init
|
||||
var (
|
||||
Ctx *oto.Context
|
||||
|
||||
@ -51,13 +52,13 @@ var (
|
||||
BytesPerSecond int64
|
||||
)
|
||||
|
||||
//Pre-defined errors
|
||||
// Pre-defined errors
|
||||
var (
|
||||
errUnknownSoundType = errors.New("unknown sound type. Sound file extension must be one of: .mp3")
|
||||
)
|
||||
|
||||
//Init prepares the default audio device and does any required setup.
|
||||
//It must be called before loading any sounds
|
||||
// Init prepares the default audio device and does any required setup.
|
||||
// It must be called before loading any sounds
|
||||
func Init(sr SampleRate, chanCount SoundChannelCount, bitDepth SoundBitDepth) error {
|
||||
|
||||
otoCtx, readyChan, err := oto.NewContext(int(sr), int(chanCount), int(bitDepth))
|
||||
@ -77,30 +78,30 @@ func Init(sr SampleRate, chanCount SoundChannelCount, bitDepth SoundBitDepth) er
|
||||
return nil
|
||||
}
|
||||
|
||||
//Wait blocks until sound finishes playing. If the sound is not playing Wait returns immediately.
|
||||
//In the worst case (Wait sleeping then sound immediately paused), Wait will block ~4% of the total play time.
|
||||
//In most other cases Wait should be accurate to ~1ms.
|
||||
// Wait blocks until sound finishes playing. If the sound is not playing Wait returns immediately.
|
||||
// In the worst case (Wait sleeping then sound immediately paused), Wait will block ~4% of the total play time.
|
||||
// In most other cases Wait should be accurate to ~1ms.
|
||||
//
|
||||
//If you want to wait for all loops to finish then use WaitLoop
|
||||
// If you want to wait for all loops to finish then use WaitLoop
|
||||
func (s *Sound) Wait() {
|
||||
|
||||
if !s.IsPlaying() {
|
||||
return
|
||||
}
|
||||
|
||||
//We wait the remaining time in 25 chunks so that if the sound was paused since wait was called we don't keep blocking
|
||||
// We wait the remaining time in 25 chunks so that if the sound was paused since wait was called we don't keep blocking
|
||||
sleepTime := s.RemainingTime() / 25
|
||||
for s.Player.IsPlaying() {
|
||||
time.Sleep(sleepTime)
|
||||
}
|
||||
|
||||
//If there is anything left it should be tiny so we check frequently
|
||||
// If there is anything left it should be tiny so we check frequently
|
||||
for s.Player.IsPlaying() {
|
||||
time.Sleep(time.Millisecond)
|
||||
}
|
||||
}
|
||||
|
||||
//WaitLoop waits until the sound is no longer looping
|
||||
// WaitLoop waits until the sound is no longer looping
|
||||
func (s *Sound) WaitLoop() {
|
||||
|
||||
for s.IsLooping {
|
||||
@ -108,21 +109,21 @@ func (s *Sound) WaitLoop() {
|
||||
}
|
||||
}
|
||||
|
||||
//PlayAsync plays the sound in the background and returns.
|
||||
// PlayAsync plays the sound in the background and returns.
|
||||
func (s *Sound) PlayAsync() {
|
||||
s.Player.Play()
|
||||
}
|
||||
|
||||
//PlaySync calls PlayAsync() followed by Wait()
|
||||
// PlaySync calls PlayAsync() followed by Wait()
|
||||
func (s *Sound) PlaySync() {
|
||||
s.PlayAsync()
|
||||
s.Wait()
|
||||
}
|
||||
|
||||
//LoopAsync plays the sound 'timesToPlay' times.
|
||||
//If timesToPlay<0 then it is played indefinitely until paused
|
||||
//If timesToPlay==0 then the sound is not played.
|
||||
//If a sound is already playing then it will be paused then resumed in a looping manner
|
||||
// LoopAsync plays the sound 'timesToPlay' times.
|
||||
// If timesToPlay<0 then it is played indefinitely until paused
|
||||
// If timesToPlay==0 then the sound is not played.
|
||||
// If a sound is already playing then it will be paused then resumed in a looping manner
|
||||
func (s *Sound) LoopAsync(timesToPlay int) {
|
||||
|
||||
if timesToPlay == 0 {
|
||||
@ -150,7 +151,7 @@ func (s *Sound) LoopAsync(timesToPlay int) {
|
||||
|
||||
s.Wait()
|
||||
|
||||
//Check is here because we don't want to seek back if we got paused
|
||||
// Check is here because we don't want to seek back if we got paused
|
||||
if !s.IsLooping {
|
||||
break
|
||||
}
|
||||
@ -166,7 +167,7 @@ func (s *Sound) LoopAsync(timesToPlay int) {
|
||||
timesToPlay--
|
||||
s.Wait()
|
||||
|
||||
//Check is here because we don't want to seek back if we got paused
|
||||
// Check is here because we don't want to seek back if we got paused
|
||||
if !s.IsLooping {
|
||||
break
|
||||
}
|
||||
@ -180,14 +181,14 @@ func (s *Sound) LoopAsync(timesToPlay int) {
|
||||
}()
|
||||
}
|
||||
|
||||
//TotalTime returns the time taken to play the entire sound.
|
||||
//Safe to use after close
|
||||
// TotalTime returns the time taken to play the entire sound.
|
||||
// Safe to use after close
|
||||
func (s *Sound) TotalTime() time.Duration {
|
||||
return PlayTimeFromByteCount(s.Info.Size)
|
||||
}
|
||||
|
||||
//RemainingTime returns the time left in the clip, which is affected by pausing/resetting/seeking of the sound.
|
||||
//Returns zero after close
|
||||
// RemainingTime returns the time left in the clip, which is affected by pausing/resetting/seeking of the sound.
|
||||
// Returns zero after close
|
||||
func (s *Sound) RemainingTime() time.Duration {
|
||||
|
||||
if s.IsClosed() {
|
||||
@ -200,8 +201,8 @@ func (s *Sound) RemainingTime() time.Duration {
|
||||
return PlayTimeFromByteCount(s.Info.Size - currBytePos)
|
||||
}
|
||||
|
||||
//SetVolume must be between 0 and 1 (both inclusive). Other values will panic.
|
||||
//The default volume is 1.
|
||||
// SetVolume must be between 0 and 1 (both inclusive). Other values will panic.
|
||||
// The default volume is 1.
|
||||
func (s *Sound) SetVolume(newVol float64) {
|
||||
|
||||
if newVol < 0 || newVol > 1 {
|
||||
@ -211,7 +212,7 @@ func (s *Sound) SetVolume(newVol float64) {
|
||||
s.Player.SetVolume(newVol)
|
||||
}
|
||||
|
||||
//Volume returns the current volume
|
||||
// Volume returns the current volume
|
||||
func (s *Sound) Volume() float64 {
|
||||
return s.Player.Volume()
|
||||
}
|
||||
@ -225,30 +226,24 @@ func (s *Sound) IsPlaying() bool {
|
||||
return s.Player.IsPlaying()
|
||||
}
|
||||
|
||||
//SeekToPercent moves the current position of the sound to the given percentage of the total sound length.
|
||||
//For example, if a sound is 10s long and percent=0.5 then when the sound is played it will start from 5s.
|
||||
// SeekToPercent moves the current position of the sound to the given percentage of the total sound length.
|
||||
// For example, if a sound is 10s long and percent=0.5 then when the sound is played it will start from 5s.
|
||||
//
|
||||
//This can be used while the sound is playing.
|
||||
// This can be used while the sound is playing.
|
||||
//
|
||||
//percent is clamped [0,1], so passing <0 is the same as zero, and >1 is the same as 1
|
||||
// percent is clamped [0,1], so passing <0 is the same as zero, and >1 is the same as 1
|
||||
func (s *Sound) SeekToPercent(percent float64) {
|
||||
|
||||
percent = clamp01F64(percent)
|
||||
s.Data.Seek(int64(float64(s.Info.Size)*percent), io.SeekStart)
|
||||
|
||||
//NOTE: Due to https://github.com/hajimehoshi/oto/issues/171, it is safer to seek before reset so we don't seek while a read is happening.
|
||||
//This can still happen though if for example sound was paused midway then seeked, as read would be getting called
|
||||
if !s.IsPlaying() {
|
||||
s.Player.Reset()
|
||||
}
|
||||
s.PlayerSeeker.Seek(int64(float64(s.Info.Size)*percent), io.SeekStart)
|
||||
}
|
||||
|
||||
//SeekToTime moves the current position of the sound to the given duration.
|
||||
//For example if you use t=5*time.Second then play you will start from 5th second.
|
||||
// SeekToTime moves the current position of the sound to the given duration.
|
||||
// For example if you use t=5*time.Second then play you will start from 5th second.
|
||||
//
|
||||
//This can be used while the sound is playing.
|
||||
// This can be used while the sound is playing.
|
||||
//
|
||||
//t is clamped between [0, totalTime]
|
||||
// t is clamped between [0, totalTime]
|
||||
func (s *Sound) SeekToTime(t time.Duration) {
|
||||
|
||||
byteCount := ByteCountFromPlayTime(t)
|
||||
@ -258,19 +253,15 @@ func (s *Sound) SeekToTime(t time.Duration) {
|
||||
byteCount = s.Info.Size
|
||||
}
|
||||
|
||||
s.Data.Seek(byteCount, io.SeekStart)
|
||||
|
||||
if !s.IsPlaying() {
|
||||
s.Player.Reset()
|
||||
}
|
||||
s.PlayerSeeker.Seek(byteCount, io.SeekStart)
|
||||
}
|
||||
|
||||
func (s *Sound) IsClosed() bool {
|
||||
return s.Data == nil
|
||||
}
|
||||
|
||||
//Close will clean underlying resources, and the 'Ctx' and 'Bytes' fields will be made nil.
|
||||
//Repeated calls are no-ops
|
||||
// Close will clean underlying resources, and the 'Ctx' and 'Bytes' fields will be made nil.
|
||||
// Repeated calls are no-ops
|
||||
func (s *Sound) Close() error {
|
||||
|
||||
if s.IsClosed() {
|
||||
@ -300,10 +291,10 @@ func (s *Sound) Close() error {
|
||||
return fdErr
|
||||
}
|
||||
|
||||
//CopyInMemSound returns a new sound object that has identitcal info and uses the same underlying data, but with independent play controls (e.g. one playing at the start while one is in the middle).
|
||||
//Since the sound data is not copied this function is very fast.
|
||||
// CopyInMemSound returns a new sound object that has identitcal info and uses the same underlying data, but with independent play controls (e.g. one playing at the start while one is in the middle).
|
||||
// Since the sound data is not copied this function is very fast.
|
||||
//
|
||||
//Panics if the sound is not in-memory
|
||||
// Panics if the sound is not in-memory
|
||||
func CopyInMemSound(s *Sound) *Sound {
|
||||
|
||||
if s.Info.Mode != SoundMode_Memory {
|
||||
@ -316,15 +307,16 @@ func CopyInMemSound(s *Sound) *Sound {
|
||||
p.SetVolume(s.Volume())
|
||||
|
||||
return &Sound{
|
||||
Player: p,
|
||||
File: nil,
|
||||
Data: sb,
|
||||
Info: s.Info,
|
||||
Player: p,
|
||||
PlayerSeeker: p.(io.Seeker),
|
||||
File: nil,
|
||||
Data: sb,
|
||||
Info: s.Info,
|
||||
}
|
||||
}
|
||||
|
||||
//ClipInMemSoundPercent is like CopyInMemSound but produces a sound that plays only between from and to.
|
||||
//fromPercent and toPercent must be between 0 and 1
|
||||
// ClipInMemSoundPercent is like CopyInMemSound but produces a sound that plays only between from and to.
|
||||
// fromPercent and toPercent must be between 0 and 1
|
||||
func ClipInMemSoundPercent(s *Sound, fromPercent, toPercent float64) *Sound {
|
||||
|
||||
if s.Info.Mode != SoundMode_Memory {
|
||||
@ -344,10 +336,11 @@ func ClipInMemSoundPercent(s *Sound, fromPercent, toPercent float64) *Sound {
|
||||
p.SetVolume(s.Volume())
|
||||
|
||||
return &Sound{
|
||||
Player: p,
|
||||
File: nil,
|
||||
Data: sb,
|
||||
Info: s.Info,
|
||||
Player: p,
|
||||
PlayerSeeker: p.(io.Seeker),
|
||||
File: nil,
|
||||
Data: sb,
|
||||
Info: s.Info,
|
||||
}
|
||||
}
|
||||
|
||||
@ -359,8 +352,8 @@ func ResumeAllSounds() {
|
||||
Ctx.Resume()
|
||||
}
|
||||
|
||||
//NewSoundStreaming plays sound by streaming from a file, so no need to load the entire file into memory.
|
||||
//Good for large sound files
|
||||
// NewSoundStreaming plays sound by streaming from a file, so no need to load the entire file into memory.
|
||||
// Good for large sound files
|
||||
func NewSoundStreaming(fpath string) (s *Sound, err error) {
|
||||
|
||||
soundType := GetSoundFileType(fpath)
|
||||
@ -368,7 +361,7 @@ func NewSoundStreaming(fpath string) (s *Sound, err error) {
|
||||
return nil, errUnknownSoundType
|
||||
}
|
||||
|
||||
//We read file but don't close so the player can stream the file any time later
|
||||
// We read file but don't close so the player can stream the file any time later
|
||||
file, err := os.Open(fpath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@ -401,6 +394,7 @@ func soundFromFile(f *os.File, s *Sound) error {
|
||||
|
||||
s.Data = dec
|
||||
s.Player = Ctx.NewPlayer(dec)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = dec.Length()
|
||||
} else if s.Info.Type == SoundType_WAV {
|
||||
|
||||
@ -411,6 +405,7 @@ func soundFromFile(f *os.File, s *Sound) error {
|
||||
|
||||
s.Data = ws
|
||||
s.Player = Ctx.NewPlayer(ws)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = ws.Size()
|
||||
} else if s.Info.Type == SoundType_OGG {
|
||||
|
||||
@ -423,6 +418,7 @@ func soundFromFile(f *os.File, s *Sound) error {
|
||||
|
||||
s.Data = oggStreamer
|
||||
s.Player = Ctx.NewPlayer(oggStreamer)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = oggStreamer.Size()
|
||||
}
|
||||
|
||||
@ -433,7 +429,7 @@ func soundFromFile(f *os.File, s *Sound) error {
|
||||
return nil
|
||||
}
|
||||
|
||||
//NewSoundMem loads the entire sound file into memory
|
||||
// NewSoundMem loads the entire sound file into memory
|
||||
func NewSoundMem(fpath string) (s *Sound, err error) {
|
||||
|
||||
soundType := GetSoundFileType(fpath)
|
||||
@ -466,8 +462,8 @@ func getLoadingErr(fpath string, err error) error {
|
||||
return fmt.Errorf("failed to load '%s' with err '%s'", fpath, err.Error())
|
||||
}
|
||||
|
||||
//decodeSoundFromReaderSeeker reads and decodes till EOF, and places the final
|
||||
//PCM16 data in a buffer, thus producing an in-memory sound
|
||||
// decodeSoundFromReaderSeeker reads and decodes till EOF, and places the final
|
||||
// PCM16 data in a buffer, thus producing an in-memory sound
|
||||
func decodeSoundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
|
||||
|
||||
if s.Info.Type == SoundType_MP3 {
|
||||
@ -485,6 +481,7 @@ func decodeSoundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
|
||||
sb := &SoundBuffer{Data: finalBuf}
|
||||
s.Data = sb
|
||||
s.Player = Ctx.NewPlayer(sb)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = int64(len(sb.Data))
|
||||
} else if s.Info.Type == SoundType_WAV {
|
||||
|
||||
@ -502,6 +499,7 @@ func decodeSoundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
|
||||
sb := &SoundBuffer{Data: finalBuf}
|
||||
s.Data = sb
|
||||
s.Player = Ctx.NewPlayer(sb)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = int64(len(sb.Data))
|
||||
} else if s.Info.Type == SoundType_OGG {
|
||||
|
||||
@ -513,6 +511,7 @@ func decodeSoundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
|
||||
sb := &SoundBuffer{Data: F32ToUnsignedPCM16(soundData, nil)}
|
||||
s.Data = sb
|
||||
s.Player = Ctx.NewPlayer(sb)
|
||||
s.PlayerSeeker = s.Player.(io.Seeker)
|
||||
s.Info.Size = int64(len(sb.Data))
|
||||
}
|
||||
|
||||
@ -538,17 +537,17 @@ func GetSoundFileType(fpath string) SoundType {
|
||||
}
|
||||
}
|
||||
|
||||
//ReadAllFromReader takes an io.Reader and reads until error or io.EOF.
|
||||
// ReadAllFromReader takes an io.Reader and reads until error or io.EOF.
|
||||
//
|
||||
//If io.EOF is reached then read bytes are returned with a nil error.
|
||||
//If the reader returns an error that's not io.EOF then everything read till that point is returned along with the error
|
||||
// If io.EOF is reached then read bytes are returned with a nil error.
|
||||
// If the reader returns an error that's not io.EOF then everything read till that point is returned along with the error
|
||||
//
|
||||
//readingBufSize is the buffer used to read from reader.Read(). Bigger values might read more efficiently.
|
||||
//If readingBufSize<4096 then readingBufSize is set to 4096
|
||||
// readingBufSize is the buffer used to read from reader.Read(). Bigger values might read more efficiently.
|
||||
// If readingBufSize<4096 then readingBufSize is set to 4096
|
||||
//
|
||||
//ouputBufSize is used to set the capacity of the final buffer to be returned. This can greatly improve performance
|
||||
//if you know the size of the output. It is allowed to have an outputBufSize that's smaller or larger than what the reader
|
||||
//ends up returning
|
||||
// ouputBufSize is used to set the capacity of the final buffer to be returned. This can greatly improve performance
|
||||
// if you know the size of the output. It is allowed to have an outputBufSize that's smaller or larger than what the reader
|
||||
// ends up returning
|
||||
func ReadAllFromReader(reader io.Reader, readingBufSize, ouputBufSize uint64) ([]byte, error) {
|
||||
|
||||
if readingBufSize < 4096 {
|
||||
@ -571,19 +570,19 @@ func ReadAllFromReader(reader io.Reader, readingBufSize, ouputBufSize uint64) ([
|
||||
}
|
||||
}
|
||||
|
||||
//PlayTimeFromByteCount returns the time taken to play this many bytes
|
||||
// PlayTimeFromByteCount returns the time taken to play this many bytes
|
||||
func PlayTimeFromByteCount(byteCount int64) time.Duration {
|
||||
//timeToPlayInMs = timeToPlayInSec * 1000 = byteCount / bytesPerSecond * 1000
|
||||
// timeToPlayInMs = timeToPlayInSec * 1000 = byteCount / bytesPerSecond * 1000
|
||||
lenInMs := float64(byteCount) / float64(BytesPerSecond) * 1000
|
||||
return time.Duration(lenInMs) * time.Millisecond
|
||||
}
|
||||
|
||||
//PlayTimeFromByteCount returns how many bytes are needed to produce a sound that takes t time to play
|
||||
// PlayTimeFromByteCount returns how many bytes are needed to produce a sound that takes t time to play
|
||||
func ByteCountFromPlayTime(t time.Duration) int64 {
|
||||
return t.Milliseconds() * BytesPerSecond / 1000
|
||||
}
|
||||
|
||||
//clampF64 [min,max]
|
||||
// clampF64 [min,max]
|
||||
func clamp01F64(x float64) float64 {
|
||||
|
||||
if x < 0 {
|
||||
@ -597,8 +596,8 @@ func clamp01F64(x float64) float64 {
|
||||
return x
|
||||
}
|
||||
|
||||
//F32ToUnsignedPCM16 takes PCM data stored as float32 between [-1, 1]
|
||||
//and returns a byte array of uint16, where each two subsequent bytes represent one uint16.
|
||||
// F32ToUnsignedPCM16 takes PCM data stored as float32 between [-1, 1]
|
||||
// and returns a byte array of uint16, where each two subsequent bytes represent one uint16.
|
||||
func F32ToUnsignedPCM16(fs []float32, outBuf []byte) []byte {
|
||||
|
||||
if outBuf == nil {
|
||||
@ -607,9 +606,9 @@ func F32ToUnsignedPCM16(fs []float32, outBuf []byte) []byte {
|
||||
|
||||
for i := 0; i < len(fs); i++ {
|
||||
|
||||
//Remap [-1,1]->[-32768, 32767], then re-interprets the int16 as a uint16.
|
||||
//With this, the negative values are mapped into the higher half of the uint16 range,
|
||||
//while positive values remain unchanged
|
||||
// Remap [-1,1]->[-32768, 32767], then re-interprets the int16 as a uint16.
|
||||
// With this, the negative values are mapped into the higher half of the uint16 range,
|
||||
// while positive values remain unchanged
|
||||
x := fs[i]
|
||||
var u16 uint16
|
||||
if x < 0 {
|
||||
|
||||
22
wavy_test.go
22
wavy_test.go
@ -8,13 +8,13 @@ import (
|
||||
)
|
||||
|
||||
func TestWavy(t *testing.T) {
|
||||
t.Run("Init", TestInit)
|
||||
t.Run("Init", InitSubtest)
|
||||
t.Run("MP3", MP3Subtest)
|
||||
t.Run("Wav", WavSubtest)
|
||||
t.Run("Ogg", OggSubtest)
|
||||
}
|
||||
|
||||
func TestInit(t *testing.T) {
|
||||
func InitSubtest(t *testing.T) {
|
||||
|
||||
err := wavy.Init(wavy.SampleRate_44100, wavy.SoundChannelCount_2, wavy.SoundBitDepth_2)
|
||||
if err != nil {
|
||||
@ -29,7 +29,7 @@ func MP3Subtest(t *testing.T) {
|
||||
const tadaFilepath = "./test_audio_files/tada.mp3"
|
||||
const fatihaLenMS = 55484
|
||||
|
||||
//Mp3 streaming
|
||||
// Mp3 streaming
|
||||
s, err := wavy.NewSoundStreaming(fatihaFilepath)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to load streaming sound with path '%s'. Err: %s\n", fatihaFilepath, err)
|
||||
@ -57,7 +57,7 @@ func MP3Subtest(t *testing.T) {
|
||||
return
|
||||
}
|
||||
|
||||
//Mp3 in-memory
|
||||
// Mp3 in-memory
|
||||
s, err = wavy.NewSoundMem(fatihaFilepath)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to load memory sound with path '%s'. Err: %s\n", fatihaFilepath, err)
|
||||
@ -85,7 +85,7 @@ func MP3Subtest(t *testing.T) {
|
||||
return
|
||||
}
|
||||
|
||||
//'tada.mp3' memory
|
||||
// 'tada.mp3' memory
|
||||
s, err = wavy.NewSoundMem(tadaFilepath)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to load memory sound with path '%s'. Err: %s\n", tadaFilepath, err)
|
||||
@ -93,17 +93,17 @@ func MP3Subtest(t *testing.T) {
|
||||
}
|
||||
s.PlaySync()
|
||||
|
||||
//Test repeat playing
|
||||
// Test repeat playing
|
||||
s2 := wavy.CopyInMemSound(s)
|
||||
s2.SetVolume(0.25)
|
||||
|
||||
//Already finished, should not play
|
||||
// Already finished, should not play
|
||||
s.PlaySync()
|
||||
|
||||
//Should play from beginning
|
||||
// Should play from beginning
|
||||
s2.PlaySync()
|
||||
|
||||
//Test seek and play
|
||||
// Test seek and play
|
||||
s2.SeekToPercent(0.2)
|
||||
s2.PlaySync()
|
||||
|
||||
@ -126,7 +126,7 @@ func WavSubtest(t *testing.T) {
|
||||
}
|
||||
s.PlaySync()
|
||||
|
||||
//Wav streaming
|
||||
// Wav streaming
|
||||
s, err = wavy.NewSoundStreaming(wavFPath)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to load streaming sound with path '%s'. Err: %s\n", wavFPath, err)
|
||||
@ -147,7 +147,7 @@ func OggSubtest(t *testing.T) {
|
||||
}
|
||||
s.PlaySync()
|
||||
|
||||
//Ogg streaming
|
||||
// Ogg streaming
|
||||
s, err = wavy.NewSoundStreaming(oggFPath)
|
||||
if err != nil {
|
||||
t.Errorf("Failed to load streaming sound with path '%s'. Err: %s\n", oggFPath, err)
|
||||
|
||||
Reference in New Issue
Block a user