hajimehoshi/gorbis or hajimehoshi/ebiten/audio/vorbis?

[dolanor]

Hi,

I just need vorbis decoder to play with oto, but I don't know which player to use.
It seems too big to import ebiten just to use oto, but hajimehoshi/gorbis seems unused (not even by ebiten).

Which should be the way to go?

[hajimehoshi]

If I remember it correctly, hajimehoshi/gorbis is just a fork to contribute to the original gorbis. Forget it.

[hajimehoshi]

I deleted the repository now.

[dolanor]

Thank you :)

[tinne26]

Use oto and create a reader using github.com/jfreymuth/oggvorbis, like Ebitengine does internally, to use with oto.NewPlayer. You have to add some glue, but even AI should be able to do most of it without issues.

[dolanor]

The kind of Stream abstraction that is presented here: https://github.com/hajimehoshi/ebiten/blob/main/audio/vorbis/vorbis.go ?

Because the problem with the freymuth/oggvorbis is that it has a reader, but not of bytes, but of 32 bits float, so we need a converter if I understood right.

[tinne26]

package main

import (
	"fmt"
	"log"
	"math"
	"os"
	"slices"
	"sync"
	"time"

	"github.com/ebitengine/oto/v3"
	"github.com/jfreymuth/oggvorbis"
)

func logFatalOnErr(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	if len(os.Args) != 2 {
		fmt.Printf("Usage: %s path/file.ogg\n", os.Args[0])
		os.Exit(0)
	}

	file, err := os.Open(os.Args[1])
	logFatalOnErr(err)
	defer func() {
		logFatalOnErr(file.Close())
	}()

	oggReader, err := oggvorbis.NewReader(file)
	logFatalOnErr(err)

	ctx, ready, err := oto.NewContext(&oto.NewContextOptions{
		SampleRate:   oggReader.SampleRate(),
		ChannelCount: oggReader.Channels(),
		Format:       oto.FormatFloat32LE,
		BufferSize:   100 * time.Millisecond,
	})
	logFatalOnErr(err)

	<-ready
	fmt.Printf(
		"Preparing to play '%s'\n> Sample rate: %d\n> Num channels: %d\n\n",
		os.Args[1], oggReader.SampleRate(), oggReader.Channels(),
	)
	oggAdapter := &adapter{reader: oggReader}
	player := ctx.NewPlayer(oggAdapter)
	player.SetVolume(0.333)
	player.Play()

	for player.IsPlaying() {
		time.Sleep(1 * time.Second)
		logFatalOnErr(player.Err())
		fmt.Printf("\rPlayed for %.02fs...", oggAdapter.Position().Seconds())
	}
	fmt.Printf("\nDone\n")
}

type adapter struct {
	reader *oggvorbis.Reader
	buff   []float32
	mutex  sync.Mutex
}

func (a *adapter) Position() time.Duration {
	a.mutex.Lock()
	defer a.mutex.Unlock()

	return time.Second * time.Duration(a.reader.Position()) / time.Duration(a.reader.SampleRate())
}

func (a *adapter) Read(buffer []byte) (n int, err error) {
	a.mutex.Lock()
	defer a.mutex.Unlock()

	// cap size to multiple of 4 as f32 samples are 4 bytes each
	buffer = buffer[:len(buffer)&^0x11]

	// get number of samples to read and ensure our buffer has the capacity
	numSamplesToRead := len(buffer) / 4
	a.buff = slices.Grow(a.buff[:0], numSamplesToRead)[:numSamplesToRead]

	// read from the underlying oggvorbis.Reader
	numSamplesRead, err := a.reader.Read(a.buff)

	// process samples read
	for i, sample := range a.buff[:numSamplesRead] {
		bits := math.Float32bits(sample)
		buffer[i*4+0] = uint8((bits >> 0) & 0xFF)
		buffer[i*4+1] = uint8((bits >> 8) & 0xFF)
		buffer[i*4+2] = uint8((bits >> 16) & 0xFF)
		buffer[i*4+3] = uint8((bits >> 24) & 0xFF)
	}
	return numSamplesRead * 4, err
}