From eade35695fe8cfa57b70c4bd157e9c334d136677 Mon Sep 17 00:00:00 2001 From: bloeys Date: Fri, 22 Jul 2022 17:47:05 +0400 Subject: [PATCH] Put spaces after // --- ogg_streamer.go | 4 +- sound_buffer.go | 18 +++---- wav_streamer.go | 12 ++--- wavy.go | 138 ++++++++++++++++++++++++------------------------ wavy_test.go | 18 +++---- 5 files changed, 95 insertions(+), 95 deletions(-) diff --git a/ogg_streamer.go b/ogg_streamer.go index cb0b290..427e561 100755 --- a/ogg_streamer.go +++ b/ogg_streamer.go @@ -25,7 +25,7 @@ func (ws *OggStreamer) Read(outBuf []byte) (floatsRead int, err error) { func (ws *OggStreamer) Seek(offset int64, whence int) (int64, error) { - //This is because ogg expects position in samples not bytes + // This is because ogg expects position in samples not bytes offset /= BytesPerSample switch whence { @@ -49,7 +49,7 @@ 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 } diff --git a/sound_buffer.go b/sound_buffer.go index 099c387..8a5609b 100755 --- a/sound_buffer.go +++ b/sound_buffer.go @@ -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, diff --git a/wav_streamer.go b/wav_streamer.go index 22c82d0..7c15591 100755 --- a/wav_streamer.go +++ b/wav_streamer.go @@ -26,14 +26,14 @@ func (ws *WavStreamer) Read(outBuf []byte) (bytesRead int, err error) { func (ws *WavStreamer) Seek(offset int64, whence int) (int64, error) { - //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() @@ -41,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 { @@ -56,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() } @@ -68,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 diff --git a/wavy.go b/wavy.go index e3bd5d7..3b44fdc 100644 --- a/wavy.go +++ b/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 @@ -29,18 +29,18 @@ type Sound struct { 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 @@ -52,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)) @@ -78,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 { @@ -109,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 { @@ -151,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 } @@ -167,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 } @@ -181,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() { @@ -201,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 { @@ -212,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() } @@ -226,24 +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.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) @@ -260,8 +260,8 @@ 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() { @@ -291,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 { @@ -315,8 +315,8 @@ func CopyInMemSound(s *Sound) *Sound { } } -//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 { @@ -352,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) @@ -361,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 @@ -429,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) @@ -462,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 { @@ -537,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 { @@ -570,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 { @@ -596,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 { @@ -606,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 { diff --git a/wavy_test.go b/wavy_test.go index 90db5a6..93e1cb4 100755 --- a/wavy_test.go +++ b/wavy_test.go @@ -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)