The seek bar of the player is the shape of the track, with the part already
heard in colour, as in the approved mockups.
- GET /tracks/{id}/peaks gives 120 levels from 0 to 255 (the loudest part is
255 whatever the volume). The server finds them by decoding the file, MP3 with
go-mp3 and FLAC with eaburns/flac, both in pure Go. It takes a few seconds, so
the first request starts the work in the background and answers 202 with
Retry-After. It is done once for each file (migration 0025), worked out again
if the size or the date of the file change, one track at a time so that a NAS
is not kept busy, and a file that cannot be decoded is remembered as such. A
track deleted while its file is being decoded is not an error.
- The seek bar of the player bar and of the full-screen player draws the shape
and asks again every few seconds until it is there. Until then, and for a
friend's track, which has none, the bar is flat. The heard part is teal, or
the friend colour. It is still a native range input, 44 pixels high in the
bar.
- OpenAPI path and schema, contract test, tests with real MP3 and FLAC files,
and a real server checked: a 4-minute MP3 is ready in about a second and a
half, a 12 MB FLAC in three, and asking again takes a millisecond.
293 lines
8 KiB
Go
293 lines
8 KiB
Go
package waveform
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"codeberg.org/squidd/sonda/internal/streaming"
|
|
)
|
|
|
|
func mean(p []byte) float64 {
|
|
var sum float64
|
|
for _, v := range p {
|
|
sum += float64(v)
|
|
}
|
|
return sum / float64(len(p))
|
|
}
|
|
|
|
func TestTheShapeOfARisingToneRisesInMp3AndFlac(t *testing.T) {
|
|
for _, name := range []string{"ramp.mp3", "ramp.flac"} {
|
|
f, err := os.Open(filepath.Join("testdata", name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
peaks, err := Decode(f, filepath.Ext(name))
|
|
_ = f.Close()
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", name, err)
|
|
}
|
|
if len(peaks) != Count {
|
|
t.Fatalf("%s: %d levels, want %d", name, len(peaks), Count)
|
|
}
|
|
third := Count / 3
|
|
first, middle, last := mean(peaks[:third]), mean(peaks[third:2*third]), mean(peaks[2*third:])
|
|
if !(first < middle && middle < last) {
|
|
t.Errorf("%s: the thirds are %.0f, %.0f, %.0f: a tone that rises must make a shape that rises", name, first, middle, last)
|
|
}
|
|
if peaks[Count-1] < 230 || peaks[0] > 40 {
|
|
t.Errorf("%s: starts at %d and ends at %d", name, peaks[0], peaks[Count-1])
|
|
}
|
|
var top byte
|
|
for _, v := range peaks {
|
|
top = max(top, v)
|
|
}
|
|
if top != 255 {
|
|
t.Errorf("%s: the loudest level is %d, want 255: a quiet track still fills the bar", name, top)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestASilentTrackIsFlatAndNothingDividesByZero(t *testing.T) {
|
|
f, err := os.Open(filepath.Join("testdata", "silence.flac"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
peaks, err := Decode(f, ".flac")
|
|
if err != nil || len(peaks) != Count {
|
|
t.Fatalf("Decode = %d levels, %v", len(peaks), err)
|
|
}
|
|
for i, v := range peaks {
|
|
if v != 0 {
|
|
t.Fatalf("level %d is %d in a silent track", i, v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWhatCannotBeDecodedIsAnErrorAndNotAPanic(t *testing.T) {
|
|
dir := t.TempDir()
|
|
junk := filepath.Join(dir, "junk")
|
|
if err := os.WriteFile(junk, []byte("this is not audio at all, not even a little bit"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, ext := range []string{".mp3", ".flac"} {
|
|
f, _ := os.Open(junk)
|
|
if _, err := Decode(f, ext); err == nil {
|
|
t.Errorf("%s: no error for text", ext)
|
|
}
|
|
_ = f.Close()
|
|
}
|
|
f, _ := os.Open(junk)
|
|
defer f.Close()
|
|
if _, err := Decode(f, ".ogg"); !errors.Is(err, ErrUnsupported) {
|
|
t.Errorf("an ogg file: %v, want ErrUnsupported", err)
|
|
}
|
|
}
|
|
|
|
// memStore keeps the shapes in memory.
|
|
type memStore struct {
|
|
mu sync.Mutex
|
|
recs map[int64]Record
|
|
}
|
|
|
|
func (m *memStore) Get(_ context.Context, id int64) (Record, bool, error) {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
r, ok := m.recs[id]
|
|
return r, ok, nil
|
|
}
|
|
|
|
func (m *memStore) Save(_ context.Context, id int64, r Record) error {
|
|
m.mu.Lock()
|
|
defer m.mu.Unlock()
|
|
if m.recs == nil {
|
|
m.recs = map[int64]Record{}
|
|
}
|
|
m.recs[id] = r
|
|
return nil
|
|
}
|
|
|
|
// files serves real files of testdata under track ids, and says what the last open found.
|
|
type files struct {
|
|
byID map[int64]string
|
|
as map[int64]string // the name a track reports, when it is not the name of its file
|
|
modtime time.Time
|
|
}
|
|
|
|
func (f *files) Open(_ context.Context, id int64) (*streaming.Stream, error) {
|
|
name, ok := f.byID[id]
|
|
if !ok {
|
|
return nil, streaming.ErrNotFound
|
|
}
|
|
file, err := os.Open(filepath.Join("testdata", name))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if reported, ok := f.as[id]; ok {
|
|
name = reported
|
|
}
|
|
return &streaming.Stream{File: file, Name: name, ModTime: f.modtime}, nil
|
|
}
|
|
|
|
func newService(t *testing.T) (*Service, *memStore, *files, *atomic.Int32) {
|
|
t.Helper()
|
|
st := &memStore{}
|
|
fs := &files{byID: map[int64]string{1: "ramp.mp3", 2: "ramp.flac", 3: "silence.flac"}, modtime: time.Unix(1_700_000_000, 0)}
|
|
s := NewService(st, fs)
|
|
var calls atomic.Int32
|
|
real := s.decode
|
|
s.decode = func(f *os.File, ext string) ([]byte, error) {
|
|
calls.Add(1)
|
|
return real(f, ext)
|
|
}
|
|
return s, st, fs, &calls
|
|
}
|
|
|
|
func TestTheShapeIsWorkedOutOnceAndRememberedForTheFile(t *testing.T) {
|
|
ctx := context.Background()
|
|
s, st, fs, calls := newService(t)
|
|
|
|
peaks, err := s.Peaks(ctx, 1)
|
|
if err != nil || len(peaks) != Count {
|
|
t.Fatalf("Peaks = %d levels, %v", len(peaks), err)
|
|
}
|
|
again, err := s.Peaks(ctx, 1)
|
|
if err != nil || string(again) != string(peaks) || calls.Load() != 1 {
|
|
t.Errorf("second ask: %v, decoded %d times, want once", err, calls.Load())
|
|
}
|
|
if rec := st.recs[1]; rec.SizeBytes == 0 || rec.MTimeUnix != 1_700_000_000 || len(rec.Peaks) != Count {
|
|
t.Errorf("record = %+v", rec)
|
|
}
|
|
|
|
// The file changes: its shape is worked out again.
|
|
fs.modtime = fs.modtime.Add(time.Hour)
|
|
if _, err := s.Peaks(ctx, 1); err != nil || calls.Load() != 2 {
|
|
t.Errorf("after the file changed: %v, decoded %d times, want 2", err, calls.Load())
|
|
}
|
|
// Another track is another job.
|
|
if _, err := s.Peaks(ctx, 2); err != nil || calls.Load() != 3 {
|
|
t.Errorf("another track: %v, decoded %d times", err, calls.Load())
|
|
}
|
|
}
|
|
|
|
func TestATrackThatIsNotThereOrCannotBeReadIsSaidOnceAndNotTriedAgain(t *testing.T) {
|
|
ctx := context.Background()
|
|
s, _, fs, calls := newService(t)
|
|
if _, err := s.Peaks(ctx, 99); !errors.Is(err, streaming.ErrNotFound) {
|
|
t.Errorf("a track that is not there: %v", err)
|
|
}
|
|
fs.byID[4], fs.as = "ramp.mp3", map[int64]string{4: "song.ogg"}
|
|
if _, err := s.Peaks(ctx, 4); !errors.Is(err, ErrUnsupported) {
|
|
t.Errorf("a format that is not read: %v, want ErrUnsupported", err)
|
|
}
|
|
if calls.Load() != 0 {
|
|
t.Errorf("decoded %d times a format that has no decoder", calls.Load())
|
|
}
|
|
|
|
// A file that is broken: the failure is kept for that file, so it is not decoded at every request.
|
|
dir := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(dir, "broken.mp3"), []byte("not an mp3"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
broken := &brokenFiles{path: filepath.Join(dir, "broken.mp3"), modtime: fs.modtime}
|
|
s2 := NewService(&memStore{}, broken)
|
|
var n atomic.Int32
|
|
real := s2.decode
|
|
s2.decode = func(f *os.File, ext string) ([]byte, error) { n.Add(1); return real(f, ext) }
|
|
for i := 0; i < 3; i++ {
|
|
if _, err := s2.Peaks(ctx, 1); !errors.Is(err, ErrUnsupported) {
|
|
t.Fatalf("ask %d: %v, want ErrUnsupported", i, err)
|
|
}
|
|
}
|
|
if n.Load() != 1 {
|
|
t.Errorf("a broken file was decoded %d times, want once", n.Load())
|
|
}
|
|
}
|
|
|
|
type brokenFiles struct {
|
|
path string
|
|
modtime time.Time
|
|
}
|
|
|
|
func (b *brokenFiles) Open(context.Context, int64) (*streaming.Stream, error) {
|
|
f, err := os.Open(b.path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &streaming.Stream{File: f, Name: filepath.Base(b.path), ModTime: b.modtime}, nil
|
|
}
|
|
|
|
func TestWhileTheShapeIsBeingWorkedOutTheAnswerIsNotReadyAndTheWorkGoesOn(t *testing.T) {
|
|
ctx := context.Background()
|
|
s, _, _, _ := newService(t)
|
|
s.wait = 30 * time.Millisecond
|
|
release := make(chan struct{})
|
|
real := s.decode
|
|
s.decode = func(f *os.File, ext string) ([]byte, error) {
|
|
<-release
|
|
return real(f, ext)
|
|
}
|
|
|
|
if _, err := s.Peaks(ctx, 1); !errors.Is(err, ErrNotReady) {
|
|
t.Fatalf("while it works: %v, want ErrNotReady", err)
|
|
}
|
|
close(release)
|
|
deadline := time.Now().Add(3 * time.Second)
|
|
for {
|
|
peaks, err := s.Peaks(ctx, 1)
|
|
if err == nil {
|
|
if len(peaks) != Count {
|
|
t.Fatalf("%d levels", len(peaks))
|
|
}
|
|
return
|
|
}
|
|
if !errors.Is(err, ErrNotReady) || time.Now().After(deadline) {
|
|
t.Fatalf("it never came: %v", err)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
func TestManyAsksForOneTrackAreOneJobAndTracksAreWorkedOutOneAtATime(t *testing.T) {
|
|
ctx := context.Background()
|
|
s, _, _, calls := newService(t)
|
|
var running, most atomic.Int32
|
|
real := s.decode
|
|
s.decode = func(f *os.File, ext string) ([]byte, error) {
|
|
now := running.Add(1)
|
|
for {
|
|
m := most.Load()
|
|
if now <= m || most.CompareAndSwap(m, now) {
|
|
break
|
|
}
|
|
}
|
|
time.Sleep(60 * time.Millisecond)
|
|
defer running.Add(-1)
|
|
return real(f, ext)
|
|
}
|
|
s.wait = 5 * time.Second
|
|
|
|
var wg sync.WaitGroup
|
|
for _, id := range []int64{1, 1, 1, 2, 3} {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
if _, err := s.Peaks(ctx, id); err != nil {
|
|
t.Errorf("track %d: %v", id, err)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
if calls.Load() != 3 {
|
|
t.Errorf("decoded %d times for 3 tracks asked 5 times", calls.Load())
|
|
}
|
|
if most.Load() != 1 {
|
|
t.Errorf("%d tracks were decoded at the same time, want 1", most.Load())
|
|
}
|
|
}
|