Update docs to mention ogg

README.md

@@ -1,2 +1,197 @@
 # wavy
-Wavy is a high-level sound library for Go built on top of https://github.com/hajimehoshi/oto
+
+Wavy is a high-level, easy to use, and cross-platform Go sound library built on top of <https://github.com/hajimehoshi/oto>.
+
+Wavy supports both streaming sounds from disk and playing from memory.
+
+- [wavy](#wavy)
+  - [Supported Platforms](#supported-platforms)
+  - [Supported audio formats](#supported-audio-formats)
+  - [Usage](#usage)
+    - [Installation](#installation)
+    - [Basics](#basics)
+    - [Controls](#controls)
+
+## Supported Platforms
+
+Supported platforms are:
+
+- Windows
+- macOS
+- Linux
+- FreeBSD
+- OpenBSD
+- Android
+- iOS
+- WebAssembly
+
+If you are using iOS or Linux please check [this](https://github.com/hajimehoshi/oto#prerequisite).
+
+## Supported audio formats
+
+- MP3 (`.mp3`)
+- Wav (`.wav`/`.wave`)
+- OGG (`.ogg`)
+
+## Usage
+
+### Installation
+
+First install Wavy with `go get github.com/bloeys/wavy`, and if you are using iOS or Linux check [this](https://github.com/hajimehoshi/oto#prerequisite).
+
+### Basics
+
+You can start playing sounds with a few lines:
+
+```go
+import (
+    "github.com/bloeys/wavy"
+)
+
+func main() {
+
+    //At the start if your program you should init wavy and tell it the
+    //sampling rate of your sounds (usually 44100), the number of 
+    //channels (usually 2) and the number of bytes per channel (usually 2).
+    //
+    //These settings will be used for all sounds regardless of their actual settings
+    err := wavy.Init(wavy.SampleRate_44100, wavy.SoundChannelCount_2, wavy.SoundBitDepth_2)
+    if err != nil {
+        panic("Failed to init wavy. Err: " + err.Error())
+    }
+
+    //Here we load a sound into memory
+    mySound, err := wavy.NewSoundMem("./my-sound.mp3")
+    if err != nil {
+        panic("Failed to create new sound. Err: " + err.Error())
+    }
+
+    //Now we set volume of this sound to 50% then play the sound
+    //and wait for it to finish (PlayAsync plays in the background)
+    mySound.SetVolume(0.5)
+    mySound.PlaySync()
+
+    //Since the sound finished playing, lets reset to start
+    //by seeking to 0% then play again. Seeking to 0.5 then playing
+    //will start from the middle the sound.
+    mySound.SeekToPercent(0)
+    mySound.PlayAsync()
+
+    //The sound is playing the background, so lets wait for it to finish
+    mySound.Wait()
+}
+```
+
+If you are dealing with large sound files you might want to stream from a file (play as you go), this will only
+use a small amount of memory, but is less flexible and might be slower to seek.
+
+Here is an example streaming a sound:
+
+```go
+
+    //Here we load a sound into memory
+    mySound, err := wavy.NewSoundStreaming("./my-sound.mp3")
+    if err != nil {
+        panic("Failed to create new sound. Err: " + err.Error())
+    }
+
+    //Rest is the same...
+```
+
+### Controls
+
+Once you have loaded a sound you can:
+
+- Pause/Resume
+- Set volume per sound
+- Play synchronously or asynchronously
+- Loop a number of times or infinitely
+- Check total play time and remaining time
+- Seek to any position (by percent or time) of the sound even when its already playing
+- Wait for a sound to finish playing once
+- Wait for a looping sound to finish all its repeats
+- (only in-memory) Load it once but have many versions play from different positions simultaneously (e.g. one gun starting to shoot, another ending its shot sound)
+- (only in-memory) Take a short clip from a sound (e.g. keep only the first half of the sound)
+
+Code examples of everything:
+
+```go
+
+//Load wav into memory
+mySound, err := wavy.NewSoundMem("./my-sound.wav")
+if err != nil {
+    panic("Failed to create new sound. Err: " + err.Error())
+}
+
+//Play for ~1s then Pause
+mySound.PlayAsync()
+time.sleep(1 * time.Second)
+mySound.Pause()
+
+//Resume and play till end
+mySound.PlaySync()
+
+//Set volume to 25%
+mySound.SetVolume(0.25)
+
+//Play the sound three times and wait for all 3 plays to finish.
+//Negative numbers will play infinitely till paused
+mySound.LoopAsync(3)
+mySound.WaitLoop()
+
+//Check playtime
+println("Time to play full sound:", mySound.TotalTime().Seconds())
+println("Time remaining till sound finishes:", mySound.RemainingTime().Seconds())
+
+//Play sound from the middle
+mySound.SeekToPercent(0.5)
+mySound.PlaySync()
+
+//Play sound from time=5s
+mySound.SeekToTime(5 * time.Second)
+mySound.PlaySync()
+
+//Wait for sound to finish if started async
+mySound.Wait()
+
+//Start looping infinitely then stop
+mySound.LoopAsync(-1)
+time.Sleep(1 * time.Second)
+mySound.Pause()
+
+//
+// Things only possible for in-memory sounds
+//
+
+//1. Playing sound many times simultaneously without loading it multiple times
+
+//We reuse the underlying sound data but get two independent sounds with their own controls!
+//This operation is fast so you can do it a lot
+mySound2 := CopyInMemSound(mySound)
+
+//Set one to play from the beginning and the other to play from the middle
+mySound.SeekToPercent(0)
+mySound2.SeekToPercent(0.5)
+
+//Play both simultaneously
+mySound.PlayAsync()
+mySound2.PlayAsync()
+
+//Wait for both to finish
+mySound.Wait()
+mySound2.Wait()
+
+//2. Cut parts of a sound
+
+//Here we get a new sound that only has the first half of the sound.
+//This operation is very quick and does not duplicate the underlying data
+clippedSound := ClipInMemSoundPercent(mySound, 0, 0.5)
+clippedSound.PlaySync()
+```
+
+Aside from per sound controls, there are a few global controls:
+
+```go
+wavy.PauseAllSounds()
+wavy.ResumeAllSounds()
+```

go.mod

@@ -3,13 +3,15 @@ module github.com/bloeys/wavy
 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/jfreymuth/oggvorbis v1.0.3
 )
 
 require (
 	github.com/go-audio/audio v1.0.0 // indirect
 	github.com/go-audio/riff v1.0.0 // indirect
-	github.com/go-audio/wav v1.1.0 // indirect
+	github.com/jfreymuth/vorbis v1.0.2 // indirect
 	golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f // indirect
 )

go.sum

@@ -9,6 +9,10 @@ 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/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=
+github.com/jfreymuth/vorbis v1.0.2/go.mod h1:DoftRo4AznKnShRl1GxiTFCseHr4zR9BN3TWXyuzrqQ=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
 golang.org/x/mobile v0.0.0-20190415191353-3e0bab5405d6/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=

sound_enums.go

@@ -6,6 +6,7 @@ const (
 	SoundType_Unknown SoundType = iota
 	SoundType_MP3
 	SoundType_WAV
+	SoundType_OGG
 )
 
 type SampleRate int

wavy.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"os"
 	"path"
 	"time"
@@ -12,6 +13,7 @@ import (
 	"github.com/go-audio/wav"
 	"github.com/hajimehoshi/go-mp3"
 	"github.com/hajimehoshi/oto/v2"
+	"github.com/jfreymuth/oggvorbis"
 )
 
 //SoundInfo contains static info about a loaded sound file
@@ -240,6 +242,12 @@ func (s *Sound) SeekToPercent(percent float64) {
 	s.Data.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.
+//
+//This can be used while the sound is playing.
+//
+//t is clamped between [0, totalTime]
 func (s *Sound) SeekToTime(t time.Duration) {
 
 	if !s.IsPlaying() {
@@ -432,8 +440,6 @@ func soundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
 		s.Data = sb
 		s.Player = Ctx.NewPlayer(sb)
 		s.Info.Size = int64(len(sb.Data))
-		return nil
-
 	} else if s.Info.Type == SoundType_WAV {
 
 		wavDec := wav.NewDecoder(r)
@@ -451,10 +457,24 @@ func soundFromReaderSeeker(r io.ReadSeeker, s *Sound) error {
 		s.Data = sb
 		s.Player = Ctx.NewPlayer(sb)
 		s.Info.Size = int64(len(sb.Data))
-		return nil
+	} else if s.Info.Type == SoundType_OGG {
+
+		soundData, _, err := oggvorbis.ReadAll(r)
+		if err != nil {
+			return err
+		}
+
+		sb := &SoundBuffer{Data: F32ToUnsignedPCM16(soundData)}
+		s.Data = sb
+		s.Player = Ctx.NewPlayer(sb)
+		s.Info.Size = int64(len(sb.Data))
 	}
 
-	panic("invalid sound type")
+	if s.Data == nil {
+		panic("invalid sound type. This is probably a bug!")
+	}
+
+	return nil
 }
 
 func GetSoundFileType(fpath string) SoundType {
@@ -465,6 +485,8 @@ func GetSoundFileType(fpath string) SoundType {
 		return SoundType_MP3
 	case ".wav", ".wave":
 		return SoundType_WAV
+	case ".ogg":
+		return SoundType_OGG
 	default:
 		return SoundType_Unknown
 	}
@@ -528,3 +550,23 @@ 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.
+func F32ToUnsignedPCM16(fs []float32) []byte {
+
+	outBuf := make([]byte, len(fs)*2)
+	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
+		x16 := uint16(fs[i] * math.MaxInt16)
+
+		baseIndex := i * 2
+		outBuf[baseIndex] = byte(x16 >> 0)
+		outBuf[baseIndex+1] = byte(x16 >> 8)
+	}
+
+	return outBuf
+}

wavy_test.go

@@ -112,6 +112,15 @@ func TestSound(t *testing.T) {
 		return
 	}
 	s.PlaySync()
+
+	//Ogg
+	const oggFPath = "./test_audio_files/camera.ogg"
+	s, err = wavy.NewSoundMem(oggFPath)
+	if err != nil {
+		t.Errorf("Failed to load memory sound with path '%s'. Err: %s\n", oggFPath, err)
+		return
+	}
+	s.PlaySync()
 }
 
 func TestByteCountFromPlayTime(t *testing.T) {