Oto (v2)

A low-level library to play sound.

• Oto (v2)
  • Platforms
  • Prerequisite
    • macOS
    • iOS
    • Linux
    • FreeBSD, OpenBSD
  • Usage
    • Playing sounds from memory
    • Playing sounds by file streaming
    • Advanced usage
  • Crosscompiling

Platforms

• Windows
• macOS
• Linux
• FreeBSD
• OpenBSD
• Android
• iOS
• WebAssembly

Prerequisite

macOS

Oto requires AudioToolbox.framework, but this is automatically linked.

iOS

Oto requires these frameworks:

• AVFoundation.framework
• AudioToolbox.framework

Add them to "Linked Frameworks and Libraries" on your Xcode project.

Linux

ALSA is required. On Ubuntu or Debian, run this command:

apt install libasound2-dev

In most cases this command must be run by root user or through sudo command.

FreeBSD, OpenBSD

BSD systems are not tested well. If ALSA works, Oto should work.

Usage

The two main components of Oto are a Context and Players. The context handles interactions with the OS and audio drivers, and as such there can only be one context in your program.

From a context you can create any number of different players, where each player is given an io.Reader that it reads bytes representing sounds from and plays.

Note that a single io.Reader must not be used by multiple players.

Playing sounds from memory

The following is an example of loading and playing an MP3 file:

package main

import (
    "time"
    "os"

    "github.com/hajimehoshi/go-mp3"
    "github.com/hajimehoshi/oto/v2"
)

func main() {
    // Read the mp3 file into memory
    fileBytes, err := os.ReadFile("./my-file.mp3")
    if err != nil {
        panic("Failed to load mp3")
    }

    // Convert the pure bytes into a reader object that can be used with the mp3 decoder
    fileBytesReader := bytes.NewReader(fileBytes)

    // Decode file
    decodedMp3, err := mp3.NewDecoder(fileBytesReader)
    if err != nil {
        panic("Failed to decode mp3")
    }

    // Prepare an Oto context (this will use your default audio device) that will
    // play all our sounds. Its configuration can't be changed later.

    // Usually 44100 or 48000. Other values might cause distortions in Oto
    samplingRate := 44100

    // Number of channels (aka locations) to play sounds from. Either 1 or 2.
    // 1 is mono sound, and 2 is stereo (most speakers are stereo). 
    numOfChannels := 2

    // Bytes used by a channel to represent one sample. Either 1 or 2 (usually 2).
    audioBitDepth := 2

    // Remember that you should **not** create more than one context
    otoCtx, readyChan, err := oto.NewContext(samplingRate, numOfChannels, audioBitDepth)
    if err != nil {
        panic("Failed to create oto context")
    }
    // It might take a bit for the hardware audio devices to be ready, so we wait on the channel.
    <-readyChan

    // Create a new 'player' that will handle our sound. Paused by default.
    player := otoCtx.NewPlayer(decodedMp3)
    
    // Play starts playing the sound and returns without waiting for it (Play() is async).
    player.Play()

    // We can wait for the sound to finish playing using something like this
    for player.IsPlaying() {
        time.Sleep(time.Millisecond)
    }

    // Now that the sound finished playing, we can restart from the beginning using these two lines
    // player.Reset()
    // player.Play()

    // If you don't want the player/sound anymore simply close
    err = player.Close()
    if err != nil {
        // Log maybe?
    }
}

Playing sounds by file streaming

The above example loads the entire file into memory and then plays it. This is great for smaller files but might be an issue if you are playing a long song since it would take too much memory and too long to load.

In such cases you might want to stream the file. Luckily this is very simple, just use os.Open:

package main

import (
    "time"
    "os"

    "github.com/hajimehoshi/go-mp3"
    "github.com/hajimehoshi/oto/v2"
)

func main() {
    // Open the file for reading. Do NOT close before you finish playing!
    file, err := os.Open("./my-file.mp3")
    if err != nil {
        panic("Failed to open mp3 file")
    }

    // Decode file. This process is done as the file plays so it won't
    // load the whole thing into memory.
    decodedMp3, err := mp3.NewDecoder(file)
    if err != nil {
        panic("Failed to decode mp3")
    }

    // Rest is the same...

    // Close file only after you finish playing
    file.Close()
}

The only thing to note about streaming is that the file object must be kept alive, otherwise you might just play static.

To keep it alive not only must you be careful about when you close it, but you might need to keep a reference to the original file object alive (by for example keeping it in a struct).

Advanced usage

Players have their own internal audio data buffer, so while for example 200 bytes have been read from the io.Reader that doesn't mean they were all played from the audio device.

Data is moved from io.Reader->internal buffer->audio device, and when the internal buffer moves data to the audio device is not guaranteed, so there might be a small delay. The amount of data in the buffer can be retrieved using Player.UnplayedBufferSize().

The size of the underlying buffer of a player can also be set by type-asserting the player object:

myPlayer.(oto.BufferSizeSetter).SetBufferSize(newBufferSize)

This works because players implement a Player interface and a BufferSizeSetter interface.

Crosscompiling

To crosscompile, make sure the libraries for the target architecture are installed, and set CGO_ENABLED=1 as Go disables Cgo on crosscompiles by default.