fix: add public attribute to playlists. Even though it is optional,

DSub requires it

Dockerfile

@@ -48,6 +48,11 @@ RUN GIT_TAG=$(git name-rev --name-only HEAD) && \
 FROM alpine as release
 MAINTAINER  Deluan Quintao <navidrome@deluan.com>
 
+# Download Tini
+ENV TINI_VERSION v0.18.0
+ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-static /tini
+RUN chmod +x /tini
+
 COPY --from=gobuilder /src/navidrome /app/
 COPY --from=gobuilder /tmp/ffmpeg*/ffmpeg /usr/bin/
 
@@ -64,4 +69,5 @@ ENV ND_PORT 4533
 EXPOSE 4533
 WORKDIR /app
 
-ENTRYPOINT "/app/navidrome"
+ENTRYPOINT ["/tini", "--"]
+CMD ["/app/navidrome"]

bin/extract_itunes_artwork.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-# Script to transfort .itc files into images (JPG or PNG)
-#
-# .itc files are located in ~/Music/iTunes/Album Artwork
-#
-# This script uses (/!\ needs ) ImageMagick's convert, hexdump, printf and dd.
-#
-# This script might be a little slow, You might want to look at Simon Kennedy's work at http://www.sffjunkie.co.uk/python-itc.html
-#
-# ~/{Library Path}/Album Artwork/Cache/D989408F65D05F99/04/13/04/D989408F65D05F99-EB5B7A9086F4B4D4.itc
-#
-# The filenames are an amalgam of the library ID (D989408F65D05F99) and the track's ID (EB5B7A9086F4B4D4).
-# The directory structure comes from the library ID and the last three digits of the track's ID converted to decimal,
-# ie 4D4 becomes 04, 13, 04.
-#
-
-AlbumArtwork="${HOME}/Music/iTunes 1/Album Artwork"
-DestinationDir="Artwork"
-IFS=$'\n'
-
-
-if [ ! -d "$DestinationDir" ]; then
-	mkdir "$DestinationDir"
-	echo "new Images dir"
-fi
-
-for file in `find "$AlbumArtwork" -name '*.itc'`; do
-	start=0x11C
-	exit=0;
-	i=1;
-	echo $file
-	while [ 1 ]; do
-
-		typeOffset=$(($start+0x30))
-		imageType=$(hexdump -n 4 -s $typeOffset -e '"0x"4/1 "%02x" "\n"' $file)
-
-		#If there is no next byte, jump to the next itc file.
-		if [[ -z $imageType ]]; then
-			break
-		fi
-
-		imageOffsetOffset=$(($start+8))
-
-		itemSize=$(hexdump -n 4 -s $start -e '"0x"4/1 "%02x" "\n"' $file)
-		imageOffset=$(hexdump -n 4 -s $imageOffsetOffset -e '"0x"4/1 "%02x" "\n"' $file)
-
-		imageStart=$(($start+$imageOffset))
-		imageSize=$(($itemSize-imageOffset))
-
-		imageWidth=$(hexdump -n 4 -s $(($start+56)) -e '"0x"4/1 "%02x" "\n"' $file)
-		imageWidth=$(printf "%d" $imageWidth)
-		imageHeight=$(hexdump -n 4 -s $(($start+60)) -e '"0x"4/1 "%02x" "\n"' $file)
-		imageHeight=$(printf "%d" $imageHeight)
-
-		dir=$(dirname "$file")
-		xbase=${file##*/} #file.etc
-		xpref=${xbase%.*} #file prefix
-
-		#echo $file
-		#echo itemsize $itemSize
-		#echo start $start
-		#echo imageOffset $imageOffset
-		#echo imageStart $imageStart
-		#echo imageSize $imageSize
-		#echo imageWidth $imageWidth
-		#echo imageHeight $imageHeight
-
-		if [[ $imageType -eq 0x504E4766 ]] || [[ $imageType -eq 0x0000000E ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.png"
-			if [ ! -f "$targetFile" ]; then
-				echo PNG
-				dd skip=$imageStart count=$imageSize if="$file" of="$targetFile" bs=1 &> /dev/null
-			fi
-		elif [[ $imageType -eq 0x41524762 ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.png"
-			if [ ! -f "$targetFile" ]; then
-				echo ARGB
-				dd skip=$imageStart count=$imageSize if="$file" of="$TMPDIR/test$i" bs=1 &> /dev/null
-
-				#Using a matrix to convert ARGB to RGBA since imagemagick does only support rgba input
-				convert -size $imageWidth"x"$imageHeight -depth 8 -color-matrix '0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0' rgba:"$TMPDIR/test$i" "$targetFile"
-			fi
-		elif [[ $imageType -eq 0x0000000D ]] ; then
-			targetFile="$DestinationDir/$xpref-$i.jpg"
-			if [ ! -f "$targetFile" ]; then
-				echo JPG
-				dd skip=$imageStart count=$imageSize if="$file" of="$targetFile" bs=1 &> /dev/null
-			fi
-		else
-			echo $imageType
-			exit=1
-			break;
-		fi
-
-		start=$(($start+$itemSize))
-		i=$(($i+1))
-	done
-done

conf/configuration.go

@@ -13,20 +13,21 @@ import (
 )
 
 type nd struct {
-	Port        string `default:"4533"`
-	MusicFolder string `default:"./music"`
-	DataFolder  string `default:"./"`
-	DbPath      string
-	LogLevel    string `default:"info"`
+	Port         string `default:"4533"`
+	MusicFolder  string `default:"./music"`
+	DataFolder   string `default:"./"`
+	ScanInterval string `default:"1m"`
+	DbPath       string
+	LogLevel     string `default:"info"`
 
 	IgnoredArticles string `default:"The El La Los Las Le Les Os As O A"`
 	IndexGroups     string `default:"A B C D E F G H I J K L M N O P Q R S T U V W X-Z(XYZ) [Unknown]([)"`
 
-	EnableDownsampling bool   `default:"false"`
-	MaxBitRate         int    `default:"0"`
-	DownsampleCommand  string `default:"ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -"`
-	ProbeCommand       string `default:"ffmpeg -i %s -f ffmetadata"`
-	ScanInterval       string `default:"1m"`
+	EnableDownsampling      bool   `default:"false"`
+	MaxBitRate              int    `default:"0"`
+	MaxTranscodingCacheSize int64  `default:"100000000"` // 100MB
+	DownsampleCommand       string `default:"ffmpeg -i %s -map 0:0 -b:a %bk -v 0 -f mp3 -"`
+	ProbeCommand            string `default:"ffmpeg -i %s -f ffmetadata"`
 
 	// DevFlags. These are used to enable/disable debugging and incomplete features
 	DevDisableBanner           bool   `default:"false"`

consts/consts.go

@@ -14,6 +14,8 @@ const (
 
 	UIAssetsLocalPath = "ui/build"
 
+	CacheDir = "cache"
+
 	DevInitialUserName = "admin"
 	DevInitialName     = "Dev Admin"
 )

db/migration/20200220143731_change_duration_to_float.go

@@ -0,0 +1,129 @@
+package migration
+
+import (
+	"database/sql"
+	"github.com/deluan/navidrome/log"
+	"github.com/pressly/goose"
+)
+
+func init() {
+	goose.AddMigration(Up20200220143731, Down20200220143731)
+}
+
+func Up20200220143731(tx *sql.Tx) error {
+	log.Warn("This migration will force the next scan to be a full rescan!")
+	_, err := tx.Exec(`
+create table media_file_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	path varchar(255) default '' not null,
+	title varchar(255) default '' not null,
+	album varchar(255) default '' not null,
+	artist varchar(255) default '' not null,
+	artist_id varchar(255) default '' not null,
+	album_artist varchar(255) default '' not null,
+	album_id varchar(255) default '' not null,
+	has_cover_art bool default FALSE not null,
+	track_number integer default 0 not null,
+	disc_number integer default 0 not null,
+	year integer default 0 not null,
+	size integer default 0 not null,
+	suffix varchar(255) default '' not null,
+	duration real default 0 not null,
+	bit_rate integer default 0 not null,
+	genre varchar(255) default '' not null,
+	compilation bool default FALSE not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into media_file_dg_tmp(id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at) select id, path, title, album, artist, artist_id, album_artist, album_id, has_cover_art, track_number, disc_number, year, size, suffix, duration, bit_rate, genre, compilation, created_at, updated_at from media_file;
+
+drop table media_file;
+
+alter table media_file_dg_tmp rename to media_file;
+
+create index media_file_album_id
+	on media_file (album_id);
+
+create index media_file_genre
+	on media_file (genre);
+
+create index media_file_path
+	on media_file (path);
+
+create index media_file_title
+	on media_file (title);
+
+create table album_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	artist_id varchar(255) default '' not null,
+	cover_art_path varchar(255) default '' not null,
+	cover_art_id varchar(255) default '' not null,
+	artist varchar(255) default '' not null,
+	album_artist varchar(255) default '' not null,
+	year integer default 0 not null,
+	compilation bool default FALSE not null,
+	song_count integer default 0 not null,
+	duration real default 0 not null,
+	genre varchar(255) default '' not null,
+	created_at datetime,
+	updated_at datetime
+);
+
+insert into album_dg_tmp(id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at) select id, name, artist_id, cover_art_path, cover_art_id, artist, album_artist, year, compilation, song_count, duration, genre, created_at, updated_at from album;
+
+drop table album;
+
+alter table album_dg_tmp rename to album;
+
+create index album_artist
+	on album (artist);
+
+create index album_artist_id
+	on album (artist_id);
+
+create index album_genre
+	on album (genre);
+
+create index album_name
+	on album (name);
+
+create index album_year
+	on album (year);
+
+create table playlist_dg_tmp
+(
+	id varchar(255) not null
+		primary key,
+	name varchar(255) default '' not null,
+	comment varchar(255) default '' not null,
+	duration real default 0 not null,
+	owner varchar(255) default '' not null,
+	public bool default FALSE not null,
+	tracks text not null
+);
+
+insert into playlist_dg_tmp(id, name, comment, duration, owner, public, tracks) select id, name, comment, duration, owner, public, tracks from playlist;
+
+drop table playlist;
+
+alter table playlist_dg_tmp rename to playlist;
+
+create index playlist_name
+	on playlist (name);
+
+-- Force a full rescan
+delete from property where id like 'LastScan%';
+update media_file set updated_at = '0001-01-01';
+`)
+	return err
+}
+
+func Down20200220143731(tx *sql.Tx) error {
+	return nil
+}

engine/browser.go

@@ -159,7 +159,7 @@ func (b *browser) buildAlbumDir(al *model.Album, tracks model.MediaFiles) *Direc
 		Artist:     al.Artist,
 		ArtistId:   al.ArtistID,
 		SongCount:  al.SongCount,
-		Duration:   al.Duration,
+		Duration:   int(al.Duration),
 		Created:    al.CreatedAt,
 		Year:       al.Year,
 		Genre:      al.Genre,

engine/browser_test.go

@@ -14,7 +14,7 @@ var _ = Describe("Browser", func() {
 	var repo *mockGenreRepository
 	var b Browser
 
-	BeforeSuite(func() {
+	BeforeEach(func() {
 		repo = &mockGenreRepository{data: model.Genres{
 			{Name: "Rock", SongCount: 1000, AlbumCount: 100},
 			{Name: "", SongCount: 13, AlbumCount: 13},

engine/common.go

@@ -69,7 +69,7 @@ func FromAlbum(al *model.Album) Entry {
 	e.Created = al.CreatedAt
 	e.AlbumId = al.ID
 	e.ArtistId = al.ArtistID
-	e.Duration = al.Duration
+	e.Duration = int(al.Duration)
 	e.SongCount = al.SongCount
 	e.Starred = al.StarredAt
 	e.PlayCount = int32(al.PlayCount)
@@ -88,7 +88,7 @@ func FromMediaFile(mf *model.MediaFile) Entry {
 	e.Artist = mf.Artist
 	e.Genre = mf.Genre
 	e.Track = mf.TrackNumber
-	e.Duration = mf.Duration
+	e.Duration = int(mf.Duration)
 	e.Size = mf.Size
 	e.Suffix = mf.Suffix
 	e.BitRate = mf.BitRate

engine/ffmpeg/ffmpeg.go

@@ -0,0 +1,52 @@
+package ffmpeg
+
+import (
+	"context"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/log"
+)
+
+type FFmpeg interface {
+	StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error)
+}
+
+func New() FFmpeg {
+	return &ffmpeg{}
+}
+
+type ffmpeg struct{}
+
+func (ff *ffmpeg) StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+	cmdLine, args := createTranscodeCommand(path, maxBitRate, format)
+
+	log.Trace(ctx, "Executing ffmpeg command", "arg0", cmdLine, "args", args)
+	cmd := exec.Command(cmdLine, args...)
+	cmd.Stderr = os.Stderr
+	if f, err = cmd.StdoutPipe(); err != nil {
+		return f, err
+	}
+	if err = cmd.Start(); err != nil {
+		return f, err
+	}
+	go cmd.Wait() // prevent zombies
+	return f, err
+}
+
+func createTranscodeCommand(path string, maxBitRate int, format string) (string, []string) {
+	cmd := conf.Server.DownsampleCommand
+
+	split := strings.Split(cmd, " ")
+	for i, s := range split {
+		s = strings.Replace(s, "%s", path, -1)
+		s = strings.Replace(s, "%b", strconv.Itoa(maxBitRate), -1)
+		split[i] = s
+	}
+
+	return split[0], split[1:]
+}

engine/ffmpeg/ffmpeg_test.go

@@ -0,0 +1,29 @@
+package ffmpeg
+
+import (
+	"testing"
+
+	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/log"
+	"github.com/deluan/navidrome/tests"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestFFmpeg(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelCritical)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "FFmpeg Suite")
+}
+
+var _ = Describe("createTranscodeCommand", func() {
+	BeforeEach(func() {
+		conf.Server.DownsampleCommand = "ffmpeg -i %s -b:a %bk mp3 -"
+	})
+	It("creates a valid command line", func() {
+		cmd, args := createTranscodeCommand("/music library/file.mp3", 123, "")
+		Expect(cmd).To(Equal("ffmpeg"))
+		Expect(args).To(Equal([]string{"-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
+	})
+})

engine/media_streamer.go

@@ -2,232 +2,185 @@ package engine
 
 import (
 	"context"
+	"fmt"
 	"io"
-	"io/ioutil"
-	"mime"
+	"net/http"
 	"os"
-	"os/exec"
-	"strconv"
+	"path/filepath"
 	"strings"
 	"time"
 
 	"github.com/deluan/navidrome/conf"
+	"github.com/deluan/navidrome/consts"
+	"github.com/deluan/navidrome/engine/ffmpeg"
 	"github.com/deluan/navidrome/log"
 	"github.com/deluan/navidrome/model"
 	"github.com/deluan/navidrome/utils"
+	"gopkg.in/djherbis/fscache.v0"
 )
 
 type MediaStreamer interface {
-	NewStream(ctx context.Context, id string, maxBitRate int, format string) (mediaStream, error)
+	NewFileSystem(ctx context.Context, maxBitRate int, format string) (http.FileSystem, error)
 }
 
-func NewMediaStreamer(ds model.DataStore) MediaStreamer {
-	return &mediaStreamer{ds: ds}
-}
-
-type mediaStream interface {
-	io.ReadSeeker
-	ContentType() string
-	Name() string
-	ModTime() time.Time
-	Close() error
-	Duration() int
+func NewMediaStreamer(ds model.DataStore, ffm ffmpeg.FFmpeg, cache fscache.Cache) MediaStreamer {
+	return &mediaStreamer{ds: ds, ffm: ffm, cache: cache}
 }
 
 type mediaStreamer struct {
-	ds model.DataStore
+	ds    model.DataStore
+	ffm   ffmpeg.FFmpeg
+	cache fscache.Cache
 }
 
-func (ms *mediaStreamer) NewStream(ctx context.Context, id string, maxBitRate int, format string) (mediaStream, error) {
-	mf, err := ms.ds.MediaFile(ctx).Get(id)
-	if err != nil {
-		return nil, err
-	}
+func (ms *mediaStreamer) NewFileSystem(ctx context.Context, maxBitRate int, format string) (http.FileSystem, error) {
+	return &mediaFileSystem{ctx: ctx, ds: ms.ds, ffm: ms.ffm, cache: ms.cache, maxBitRate: maxBitRate, format: format}, nil
+}
 
+type mediaFileSystem struct {
+	ctx        context.Context
+	ds         model.DataStore
+	maxBitRate int
+	format     string
+	ffm        ffmpeg.FFmpeg
+	cache      fscache.Cache
+}
+
+func (fs *mediaFileSystem) selectTranscodingOptions(mf *model.MediaFile) (string, int) {
 	var bitRate int
+	var format string
 
-	if format == "raw" || !conf.Server.EnableDownsampling {
-		bitRate = mf.BitRate
-		format = mf.Suffix
+	if fs.format == "raw" || !conf.Server.EnableDownsampling {
+		return "raw", bitRate
 	} else {
-		if maxBitRate == 0 {
+		if fs.maxBitRate == 0 {
 			bitRate = mf.BitRate
 		} else {
-			bitRate = utils.MinInt(mf.BitRate, maxBitRate)
+			bitRate = utils.MinInt(mf.BitRate, fs.maxBitRate)
 		}
-		format = mf.Suffix
+		format = "mp3" //mf.Suffix
 	}
 	if conf.Server.MaxBitRate != 0 {
 		bitRate = utils.MinInt(bitRate, conf.Server.MaxBitRate)
 	}
 
-	var stream mediaStream
+	if bitRate == mf.BitRate {
+		return "raw", bitRate
+	}
+	return format, bitRate
+}
 
-	if bitRate == mf.BitRate && mime.TypeByExtension("."+format) == mf.ContentType() {
-		log.Debug(ctx, "Streaming raw file", "id", mf.ID, "path", mf.Path,
-			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
-
-		f, err := os.Open(mf.Path)
-		if err != nil {
-			return nil, err
-		}
-		stream = &rawMediaStream{ctx: ctx, mf: mf, file: f}
-		return stream, nil
+func (fs *mediaFileSystem) Open(name string) (http.File, error) {
+	id := strings.Trim(name, "/")
+	mf, err := fs.ds.MediaFile(fs.ctx).Get(id)
+	if err == model.ErrNotFound {
+		return nil, os.ErrNotExist
+	}
+	if err != nil {
+		log.Error("Error opening mediaFile", "id", id, err)
+		return nil, os.ErrInvalid
 	}
 
-	log.Debug(ctx, "Streaming transcoded file", "id", mf.ID, "path", mf.Path,
+	format, bitRate := fs.selectTranscodingOptions(mf)
+	if format == "raw" {
+		log.Debug(fs.ctx, "Streaming raw file", "id", mf.ID, "path", mf.Path,
+			"requestBitrate", bitRate, "requestFormat", format,
+			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
+		return os.Open(mf.Path)
+	}
+
+	log.Debug(fs.ctx, "Streaming transcoded file", "id", mf.ID, "path", mf.Path,
 		"requestBitrate", bitRate, "requestFormat", format,
 		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix)
 
-	f := &transcodedMediaStream{ctx: ctx, mf: mf, bitRate: bitRate, format: format}
-	return f, err
+	return fs.transcodeFile(mf, bitRate, format)
 }
 
-type rawMediaStream struct {
-	file *os.File
-	ctx  context.Context
-	mf   *model.MediaFile
+func (fs *mediaFileSystem) transcodeFile(mf *model.MediaFile, bitRate int, format string) (*transcodingFile, error) {
+	key := fmt.Sprintf("%s.%d.%s", mf.ID, bitRate, format)
+	r, w, err := fs.cache.Get(key)
+	if err != nil {
+		log.Error("Error creating stream caching buffer", "id", mf.ID, err)
+		return nil, os.ErrInvalid
+	}
+
+	// If it is a new file (not found in the cached), start a new transcoding session
+	if w != nil {
+		log.Debug("File not found in cache. Starting new transcoding session", "id", mf.ID)
+		out, err := fs.ffm.StartTranscoding(fs.ctx, mf.Path, bitRate, format)
+		if err != nil {
+			log.Error("Error starting transcoder", "id", mf.ID, err)
+			return nil, os.ErrInvalid
+		}
+		go func() {
+			io.Copy(w, out)
+			out.Close()
+			w.Close()
+		}()
+	} else {
+		log.Debug("Reading transcoded file from cache", "id", mf.ID)
+	}
+
+	return newTranscodingFile(fs.ctx, r, mf, bitRate), nil
 }
 
-func (m *rawMediaStream) Read(p []byte) (n int, err error) {
-	return m.file.Read(p)
+// transcodingFile Implements http.File interface, required for the FileSystem. It needs a Closer, a Reader and
+// a Seeker for the same stream. Because the fscache package only provides a ReaderAtCloser (without the Seek()
+// method), we wrap that reader with a SectionReader, which provides a Seek(). But we still need the original
+// reader, as we need to close the stream when the transfer is complete
+func newTranscodingFile(ctx context.Context, reader fscache.ReadAtCloser,
+	mf *model.MediaFile, bitRate int) *transcodingFile {
+
+	size := int64(mf.Duration*float32(bitRate*1000)) / 8
+	return &transcodingFile{
+		ctx:        ctx,
+		mf:         mf,
+		bitRate:    bitRate,
+		size:       size,
+		closer:     reader,
+		ReadSeeker: io.NewSectionReader(reader, 0, size),
+	}
 }
 
-func (m *rawMediaStream) Seek(offset int64, whence int) (int64, error) {
-	return m.file.Seek(offset, whence)
-}
-
-func (m *rawMediaStream) ContentType() string {
-	return m.mf.ContentType()
-}
-
-func (m *rawMediaStream) Name() string {
-	return m.mf.Path
-}
-
-func (m *rawMediaStream) ModTime() time.Time {
-	return m.mf.UpdatedAt
-}
-
-func (m *rawMediaStream) Duration() int {
-	return m.mf.Duration
-}
-
-func (m *rawMediaStream) Close() error {
-	log.Trace(m.ctx, "Closing file", "id", m.mf.ID, "path", m.mf.Path)
-	return m.file.Close()
-}
-
-type transcodedMediaStream struct {
+type transcodingFile struct {
 	ctx     context.Context
 	mf      *model.MediaFile
-	pipe    io.ReadCloser
 	bitRate int
-	format  string
-	skip    int64
-	pos     int64
+	size    int64
+	closer  io.Closer
+	io.ReadSeeker
 }
 
-func (m *transcodedMediaStream) Read(p []byte) (n int, err error) {
-	// Open the pipe and optionally skip a initial chunk of the stream (to simulate a Seek)
-	if m.pipe == nil {
-		m.pipe, err = newTranscode(m.ctx, m.mf.Path, m.bitRate, m.format)
-		if err != nil {
-			return 0, err
-		}
-		if m.skip > 0 {
-			_, err := io.CopyN(ioutil.Discard, m.pipe, m.skip)
-			m.pos = m.skip
-			if err != nil {
-				return 0, err
-			}
-		}
+func (tf *transcodingFile) Stat() (os.FileInfo, error) {
+	return &streamHandlerFileInfo{f: tf}, nil
+}
+
+func (tf *transcodingFile) Close() error {
+	return tf.closer.Close()
+}
+
+func (tf *transcodingFile) Readdir(count int) ([]os.FileInfo, error) {
+	return nil, nil
+}
+
+type streamHandlerFileInfo struct {
+	f *transcodingFile
+}
+
+func (fi *streamHandlerFileInfo) Name() string       { return fi.f.mf.Title }
+func (fi *streamHandlerFileInfo) ModTime() time.Time { return fi.f.mf.UpdatedAt }
+func (fi *streamHandlerFileInfo) Size() int64        { return fi.f.size }
+func (fi *streamHandlerFileInfo) Mode() os.FileMode  { return os.FileMode(0777) }
+func (fi *streamHandlerFileInfo) IsDir() bool        { return false }
+func (fi *streamHandlerFileInfo) Sys() interface{}   { return nil }
+
+func NewTranscodingCache() (fscache.Cache, error) {
+	lru := fscache.NewLRUHaunter(0, conf.Server.MaxTranscodingCacheSize, 10*time.Minute)
+	h := fscache.NewLRUHaunterStrategy(lru)
+	cacheFolder := filepath.Join(conf.Server.DataFolder, consts.CacheDir)
+	fs, err := fscache.NewFs(cacheFolder, 0755)
+	if err != nil {
+		return nil, err
 	}
-	n, err = m.pipe.Read(p)
-	m.pos += int64(n)
-	if err == io.EOF {
-		m.Close()
-	}
-	return
-}
-
-// This is an attempt to make a pipe seekable. It is very wasteful, restarting the stream every time
-// a Seek happens. This is ok-ish for audio, but would kill the server for video.
-func (m *transcodedMediaStream) Seek(offset int64, whence int) (int64, error) {
-	size := int64((m.mf.Duration)*m.bitRate*1000) / 8
-	log.Trace(m.ctx, "Seeking transcoded stream", "path", m.mf.Path, "offset", offset, "whence", whence, "size", size)
-
-	switch whence {
-	case io.SeekEnd:
-		m.skip = size - offset
-		offset = size
-	case io.SeekStart:
-		m.skip = offset
-	case io.SeekCurrent:
-		io.CopyN(ioutil.Discard, m.pipe, offset)
-		m.pos += offset
-		offset = m.pos
-	}
-
-	// If need to Seek to a previous position, close the pipe (will be restarted on next Read)
-	var err error
-	if whence != io.SeekCurrent {
-		if m.pipe != nil {
-			err = m.Close()
-		}
-	}
-	return offset, err
-}
-
-func (m *transcodedMediaStream) ContentType() string {
-	return mime.TypeByExtension(".mp3")
-}
-
-func (m *transcodedMediaStream) Name() string {
-	return m.mf.Path
-}
-
-func (m *transcodedMediaStream) ModTime() time.Time {
-	return m.mf.UpdatedAt
-}
-
-func (m *transcodedMediaStream) Duration() int {
-	return m.mf.Duration
-}
-
-func (m *transcodedMediaStream) Close() error {
-	log.Trace(m.ctx, "Closing stream", "id", m.mf.ID, "path", m.mf.Path)
-	err := m.pipe.Close()
-	m.pipe = nil
-	m.pos = 0
-	return err
-}
-
-func newTranscode(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
-	cmdLine, args := createTranscodeCommand(path, maxBitRate, format)
-
-	log.Trace(ctx, "Executing ffmpeg command", "arg0", cmdLine, "args", args)
-	cmd := exec.Command(cmdLine, args...)
-	cmd.Stderr = os.Stderr
-	if f, err = cmd.StdoutPipe(); err != nil {
-		return f, err
-	}
-	if err = cmd.Start(); err != nil {
-		return f, err
-	}
-	go cmd.Wait() // prevent zombies
-	return f, err
-}
-
-func createTranscodeCommand(path string, maxBitRate int, format string) (string, []string) {
-	cmd := conf.Server.DownsampleCommand
-
-	split := strings.Split(cmd, " ")
-	for i, s := range split {
-		s = strings.Replace(s, "%s", path, -1)
-		s = strings.Replace(s, "%b", strconv.Itoa(maxBitRate), -1)
-		split[i] = s
-	}
-
-	return split[0], split[1:]
+	return fscache.NewCacheWithHaunter(fs, h)
 }

engine/media_streamer_test.go

@@ -1,7 +1,12 @@
 package engine
 
 import (
-	"time"
+	"context"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strings"
 
 	"github.com/deluan/navidrome/conf"
 	"github.com/deluan/navidrome/log"
@@ -9,6 +14,7 @@ import (
 	"github.com/deluan/navidrome/persistence"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
+	"gopkg.in/djherbis/fscache.v0"
 )
 
 var _ = Describe("MediaStreamer", func() {
@@ -19,57 +25,40 @@ var _ = Describe("MediaStreamer", func() {
 
 	BeforeEach(func() {
 		conf.Server.EnableDownsampling = true
+		fs := fscache.NewMemFs()
+		cache, _ := fscache.NewCache(fs, nil)
 		ds = &persistence.MockDataStore{}
 		ds.MediaFile(ctx).(*persistence.MockMediaFile).SetData(`[{"id": "123", "path": "tests/fixtures/test.mp3", "bitRate": 128}]`, 1)
-		streamer = NewMediaStreamer(ds)
+		streamer = NewMediaStreamer(ds, &fakeFFmpeg{}, cache)
 	})
 
-	Context("NewStream", func() {
-		It("returns a rawMediaStream if format is 'raw'", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "raw")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+	getFile := func(id string, maxBitRate int, format string) (http.File, error) {
+		fs, _ := streamer.NewFileSystem(ctx, maxBitRate, format)
+		return fs.Open(id)
+	}
+
+	Context("NewFileSystem", func() {
+		It("returns a File if format is 'raw'", func() {
+			Expect(getFile("123", 0, "raw")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a rawMediaStream if maxBitRate is 0", func() {
-			Expect(streamer.NewStream(ctx, "123", 0, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+		It("returns a File if maxBitRate is 0", func() {
+			Expect(getFile("123", 0, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a rawMediaStream if maxBitRate is higher than file bitRate", func() {
-			Expect(streamer.NewStream(ctx, "123", 256, "mp3")).To(BeAssignableToTypeOf(&rawMediaStream{}))
+		It("returns a File if maxBitRate is higher than file bitRate", func() {
+			Expect(getFile("123", 256, "mp3")).To(BeAssignableToTypeOf(&os.File{}))
 		})
-		It("returns a transcodedMediaStream if maxBitRate is lower than file bitRate", func() {
-			s, err := streamer.NewStream(ctx, "123", 64, "mp3")
+		It("returns a transcodingFile if maxBitRate is lower than file bitRate", func() {
+			s, err := getFile("123", 64, "mp3")
 			Expect(err).To(BeNil())
-			Expect(s).To(BeAssignableToTypeOf(&transcodedMediaStream{}))
-			Expect(s.(*transcodedMediaStream).bitRate).To(Equal(64))
+			Expect(s).To(BeAssignableToTypeOf(&transcodingFile{}))
+			Expect(s.(*transcodingFile).bitRate).To(Equal(64))
 		})
 	})
-
-	Context("rawMediaStream", func() {
-		var rawStream mediaStream
-		var modTime time.Time
-
-		BeforeEach(func() {
-			modTime = time.Now()
-			mf := &model.MediaFile{ID: "123", Path: "test.mp3", UpdatedAt: modTime, Suffix: "mp3"}
-			rawStream = &rawMediaStream{mf: mf, ctx: ctx}
-		})
-
-		It("returns the ContentType", func() {
-			Expect(rawStream.ContentType()).To(Equal("audio/mpeg"))
-		})
-
-		It("returns the ModTime", func() {
-			Expect(rawStream.ModTime()).To(Equal(modTime))
-		})
-	})
-
-	Context("createTranscodeCommand", func() {
-		BeforeEach(func() {
-			conf.Server.DownsampleCommand = "ffmpeg -i %s -b:a %bk mp3 -"
-		})
-		It("creates a valid command line", func() {
-			cmd, args := createTranscodeCommand("/music library/file.mp3", 123, "")
-			Expect(cmd).To(Equal("ffmpeg"))
-			Expect(args).To(Equal([]string{"-i", "/music library/file.mp3", "-b:a", "123k", "mp3", "-"}))
-		})
-
-	})
 })
+
+type fakeFFmpeg struct {
+}
+
+func (ff *fakeFFmpeg) StartTranscoding(ctx context.Context, path string, maxBitRate int, format string) (f io.ReadCloser, err error) {
+	return ioutil.NopCloser(strings.NewReader("fake data")), nil
+}

engine/playlists.go

@@ -102,7 +102,11 @@ func (p *playlists) Update(ctx context.Context, playlistId string, name *string,
 }
 
 func (p *playlists) GetAll(ctx context.Context) (model.Playlists, error) {
-	return p.ds.Playlist(ctx).GetAll(model.QueryOptions{})
+	all, err := p.ds.Playlist(ctx).GetAll(model.QueryOptions{})
+	for i := range all {
+		all[i].Public = true
+	}
+	return all, err
 }
 
 type PlaylistInfo struct {
@@ -127,7 +131,7 @@ func (p *playlists) Get(ctx context.Context, id string) (*PlaylistInfo, error) {
 		Id:        pl.ID,
 		Name:      pl.Name,
 		SongCount: len(pl.Tracks),
-		Duration:  pl.Duration,
+		Duration:  int(pl.Duration),
 		Public:    pl.Public,
 		Owner:     pl.Owner,
 		Comment:   pl.Comment,

engine/wire_providers.go

@@ -1,6 +1,9 @@
 package engine
 
-import "github.com/google/wire"
+import (
+	"github.com/deluan/navidrome/engine/ffmpeg"
+	"github.com/google/wire"
+)
 
 var Set = wire.NewSet(
 	NewBrowser,
@@ -13,4 +16,6 @@ var Set = wire.NewSet(
 	NewNowPlayingRepository,
 	NewUsers,
 	NewMediaStreamer,
+	ffmpeg.New,
+	NewTranscodingCache,
 )

go.mod

@@ -38,5 +38,8 @@ require (
 	golang.org/x/text v0.3.2 // indirect
 	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 // indirect
 	gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
+	gopkg.in/djherbis/atime.v1 v1.0.0 // indirect
+	gopkg.in/djherbis/fscache.v0 v0.9.0
+	gopkg.in/djherbis/stream.v1 v1.2.0 // indirect
 	gopkg.in/yaml.v2 v2.2.8 // indirect
 )

go.sum

@@ -172,6 +172,12 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/djherbis/atime.v1 v1.0.0 h1:eMRqB/JrLKocla2PBPKgQYg/p5UG4L6AUAs92aP7F60=
+gopkg.in/djherbis/atime.v1 v1.0.0/go.mod h1:hQIUStKmJfvf7xdh/wtK84qe+DsTV5LnA9lzxxtPpJ8=
+gopkg.in/djherbis/fscache.v0 v0.9.0 h1:CBmOlHQKg99q0xATpQpSNAR970UN4vECB5SjzkuyLe0=
+gopkg.in/djherbis/fscache.v0 v0.9.0/go.mod h1:izqJMuO+STCEMBEGFiwW5zPlamuiUOxMRpNzHT5cQHc=
+gopkg.in/djherbis/stream.v1 v1.2.0 h1:3tZuXO+RK8opjw8/BJr780h+eAPwOFfLHCKRKyYxk3s=
+gopkg.in/djherbis/stream.v1 v1.2.0/go.mod h1:aEV8CBVRmSpLamVJfM903Npic1IKmb2qS30VAZ+sssg=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

main.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"fmt"
+
 	"github.com/deluan/navidrome/conf"
 	"github.com/deluan/navidrome/consts"
 	"github.com/deluan/navidrome/db"
@@ -14,8 +16,12 @@ func main() {
 	conf.Load()
 	db.EnsureLatestVersion()
 
+	subsonic, err := CreateSubsonicAPIRouter()
+	if err != nil {
+		panic(fmt.Sprintf("Could not create the Subsonic API router. Aborting! err=%v", err))
+	}
 	a := CreateServer(conf.Server.MusicFolder)
-	a.MountRouter("/rest", CreateSubsonicAPIRouter())
+	a.MountRouter("/rest", subsonic)
 	a.MountRouter("/app", CreateAppRouter("/app"))
 	a.Run(":" + conf.Server.Port)
 }

model/album.go

@@ -13,7 +13,7 @@ type Album struct {
 	Year         int       `json:"year"`
 	Compilation  bool      `json:"compilation"`
 	SongCount    int       `json:"songCount"`
-	Duration     int       `json:"duration"`
+	Duration     float32   `json:"duration"`
 	Genre        string    `json:"genre"`
 	CreatedAt    time.Time `json:"createdAt"`
 	UpdatedAt    time.Time `json:"updatedAt"`

model/mediafile.go

@@ -20,7 +20,7 @@ type MediaFile struct {
 	Year        int       `json:"year"`
 	Size        int       `json:"size"`
 	Suffix      string    `json:"suffix"`
-	Duration    int       `json:"duration"`
+	Duration    float32   `json:"duration"`
 	BitRate     int       `json:"bitRate"`
 	Genre       string    `json:"genre"`
 	Compilation bool      `json:"compilation"`

model/playlist.go

@@ -4,7 +4,7 @@ type Playlist struct {
 	ID       string
 	Name     string
 	Comment  string
-	Duration int
+	Duration float32
 	Owner    string
 	Public   bool
 	Tracks   MediaFiles

persistence/playlist_repository.go

@@ -13,7 +13,7 @@ type playlist struct {
 	ID       string `orm:"column(id)"`
 	Name     string
 	Comment  string
-	Duration int
+	Duration float32
 	Owner    string
 	Public   bool
 	Tracks   string

scanner/metadata_ffmpeg.go

@@ -24,19 +24,19 @@ type Metadata struct {
 	tags     map[string]string
 }
 
-func (m *Metadata) Title() string               { return m.tags["title"] }
-func (m *Metadata) Album() string               { return m.tags["album"] }
-func (m *Metadata) Artist() string              { return m.tags["artist"] }
-func (m *Metadata) AlbumArtist() string         { return m.tags["album_artist"] }
-func (m *Metadata) Composer() string            { return m.tags["composer"] }
-func (m *Metadata) Genre() string               { return m.tags["genre"] }
-func (m *Metadata) Year() int                   { return m.parseYear("year") }
-func (m *Metadata) TrackNumber() (int, int)     { return m.parseTuple("trackNum", "trackTotal") }
-func (m *Metadata) DiscNumber() (int, int)      { return m.parseTuple("discNum", "discTotal") }
-func (m *Metadata) HasPicture() bool            { return m.tags["hasPicture"] == "Video" }
-func (m *Metadata) Comment() string             { return m.tags["comment"] }
+func (m *Metadata) Title() string               { return m.getTag("title", "sort_name") }
+func (m *Metadata) Album() string               { return m.getTag("album", "sort_album") }
+func (m *Metadata) Artist() string              { return m.getTag("artist", "sort_artist") }
+func (m *Metadata) AlbumArtist() string         { return m.getTag("album_artist") }
+func (m *Metadata) Composer() string            { return m.getTag("composer", "tcm", "sort_composer") }
+func (m *Metadata) Genre() string               { return m.getTag("genre") }
+func (m *Metadata) Year() int                   { return m.parseYear("date") }
+func (m *Metadata) TrackNumber() (int, int)     { return m.parseTuple("track") }
+func (m *Metadata) DiscNumber() (int, int)      { return m.parseTuple("tpa", "disc") }
+func (m *Metadata) HasPicture() bool            { return m.getTag("has_picture") == "true" }
+func (m *Metadata) Comment() string             { return m.getTag("comment") }
 func (m *Metadata) Compilation() bool           { return m.parseBool("compilation") }
-func (m *Metadata) Duration() int               { return m.parseDuration("duration") }
+func (m *Metadata) Duration() float32           { return m.parseDuration("duration") }
 func (m *Metadata) BitRate() int                { return m.parseInt("bitrate") }
 func (m *Metadata) ModificationTime() time.Time { return m.fileInfo.ModTime() }
 func (m *Metadata) FilePath() string            { return m.filePath }
@@ -94,7 +94,22 @@ func ExtractAllMetadata(inputs []string) (map[string]*Metadata, error) {
 	return mds, nil
 }
 
-var inputRegex = regexp.MustCompile(`(?m)^Input #\d+,.*,\sfrom\s'(.*)'`)
+var (
+	// Input #0, mp3, from 'groovin.mp3':
+	inputRegex = regexp.MustCompile(`(?m)^Input #\d+,.*,\sfrom\s'(.*)'`)
+
+	//    TITLE           : Back In Black
+	tagsRx = regexp.MustCompile(`(?i)^\s{4,6}(\w+)\s+:(.*)`)
+
+	//  Duration: 00:04:16.00, start: 0.000000, bitrate: 995 kb/s`
+	durationRx = regexp.MustCompile(`^\s\sDuration: ([\d.:]+).*bitrate: (\d+)`)
+
+	//    Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 192 kb/s
+	bitRateRx = regexp.MustCompile(`^\s{4}Stream #\d+:\d+: (Audio):.*, (\d+) kb/s`)
+
+	//    Stream #0:1: Video: mjpeg, yuvj444p(pc, bt470bg/unknown/unknown), 600x600 [SAR 1:1 DAR 1:1], 90k tbr, 90k tbn, 90k tbc`
+	coverRx = regexp.MustCompile(`^\s{4}Stream #\d+:\d+: (Video):.*`)
+)
 
 func parseOutput(output string) map[string]string {
 	split := map[string]string{}
@@ -141,47 +156,44 @@ func isAudioFile(extension string) bool {
 	return strings.HasPrefix(typ, "audio/")
 }
 
-var (
-	tagsRx = map[*regexp.Regexp]string{
-		regexp.MustCompile(`(?i)^\s{4}compilation\s+:(.*)`):    "compilation",
-		regexp.MustCompile(`(?i)^\s{4}genre\s+:\s(.*)`):        "genre",
-		regexp.MustCompile(`(?i)^\s{4}title\s+:\s(.*)`):        "title",
-		regexp.MustCompile(`(?i)^\s{4}comment\s+:\s(.*)`):      "comment",
-		regexp.MustCompile(`(?i)^\s{4}artist\s+:\s(.*)`):       "artist",
-		regexp.MustCompile(`(?i)^\s{4}album_artist\s+:\s(.*)`): "album_artist",
-		regexp.MustCompile(`(?i)^\s{4}TCM\s+:\s(.*)`):          "composer",
-		regexp.MustCompile(`(?i)^\s{4}album\s+:\s(.*)`):        "album",
-		regexp.MustCompile(`(?i)^\s{4}track\s+:\s(.*)`):        "trackNum",
-		regexp.MustCompile(`(?i)^\s{4}tracktotal\s+:\s(.*)`):   "trackTotal",
-		regexp.MustCompile(`(?i)^\s{4}disc\s+:\s(.*)`):         "discNum",
-		regexp.MustCompile(`(?i)^\s{4}disctotal\s+:\s(.*)`):    "discTotal",
-		regexp.MustCompile(`(?i)^\s{4}TPA\s+:\s(.*)`):          "discNum",
-		regexp.MustCompile(`(?i)^\s{4}date\s+:\s(.*)`):         "year",
-		regexp.MustCompile(`^\s{4}Stream #\d+:\d+: (.+):\s`):   "hasPicture",
-	}
-
-	durationRx = regexp.MustCompile(`^\s\sDuration: ([\d.:]+).*bitrate: (\d+)`)
-)
-
 func (m *Metadata) parseInfo(info string) {
 	reader := strings.NewReader(info)
 	scanner := bufio.NewScanner(reader)
 	for scanner.Scan() {
 		line := scanner.Text()
-		for rx, tag := range tagsRx {
-			match := rx.FindStringSubmatch(line)
-			if len(match) > 0 {
-				m.tags[tag] = match[1]
-				break
-			}
-			match = durationRx.FindStringSubmatch(line)
-			if len(match) == 0 {
-				continue
+		if len(line) == 0 {
+			continue
+		}
+		match := tagsRx.FindStringSubmatch(line)
+		if len(match) > 0 {
+			tagName := strings.ToLower(match[1])
+			tagValue := strings.TrimSpace(match[2])
+
+			// Skip when the tag was previously found
+			if _, ok := m.tags[tagName]; !ok {
+				m.tags[tagName] = tagValue
 			}
+			continue
+		}
+
+		match = coverRx.FindStringSubmatch(line)
+		if len(match) > 0 {
+			m.tags["has_picture"] = "true"
+			continue
+		}
+
+		match = durationRx.FindStringSubmatch(line)
+		if len(match) > 0 {
 			m.tags["duration"] = match[1]
 			if len(match) > 1 {
 				m.tags["bitrate"] = match[2]
 			}
+			continue
+		}
+
+		match = bitRateRx.FindStringSubmatch(line)
+		if len(match) > 0 {
+			m.tags["bitrate"] = match[2]
 		}
 	}
 }
@@ -194,15 +206,6 @@ func (m *Metadata) parseInt(tagName string) int {
 	return 0
 }
 
-var tagYearFormats = []string{
-	"2006",
-	"2006.01",
-	"2006.01.02",
-	"2006-01",
-	"2006-01-02",
-	time.RFC3339,
-}
-
 var dateRegex = regexp.MustCompile(`^([12]\d\d\d)`)
 
 func (m *Metadata) parseYear(tagName string) int {
@@ -218,17 +221,28 @@ func (m *Metadata) parseYear(tagName string) int {
 	return 0
 }
 
-func (m *Metadata) parseTuple(numTag string, totalTag string) (int, int) {
-	if v, ok := m.tags[numTag]; ok {
-		tuple := strings.Split(v, "/")
-		t1, t2 := 0, 0
-		t1, _ = strconv.Atoi(tuple[0])
-		if len(tuple) > 1 {
-			t2, _ = strconv.Atoi(tuple[1])
-		} else {
-			t2, _ = strconv.Atoi(m.tags[totalTag])
+func (m *Metadata) getTag(tags ...string) string {
+	for _, t := range tags {
+		if v, ok := m.tags[t]; ok {
+			return v
+		}
+	}
+	return ""
+}
+
+func (m *Metadata) parseTuple(tags ...string) (int, int) {
+	for _, tagName := range tags {
+		if v, ok := m.tags[tagName]; ok {
+			tuple := strings.Split(v, "/")
+			t1, t2 := 0, 0
+			t1, _ = strconv.Atoi(tuple[0])
+			if len(tuple) > 1 {
+				t2, _ = strconv.Atoi(tuple[1])
+			} else {
+				t2, _ = strconv.Atoi(m.tags[tagName+"total"])
+			}
+			return t1, t2
 		}
-		return t1, t2
 	}
 	return 0, 0
 }
@@ -243,13 +257,13 @@ func (m *Metadata) parseBool(tagName string) bool {
 
 var zeroTime = time.Date(0000, time.January, 1, 0, 0, 0, 0, time.UTC)
 
-func (m *Metadata) parseDuration(tagName string) int {
+func (m *Metadata) parseDuration(tagName string) float32 {
 	if v, ok := m.tags[tagName]; ok {
 		d, err := time.Parse("15:04:05", v)
 		if err != nil {
 			return 0
 		}
-		return int(d.Sub(zeroTime).Seconds())
+		return float32(d.Sub(zeroTime).Seconds())
 	}
 	return 0
 }

scanner/metadata_test.go

@@ -67,31 +67,72 @@ var _ = Describe("Metadata", func() {
 	})
 
 	Context("extractMetadata", func() {
+		It("detects embedded cover art correctly", func() {
+			const output = `
+Input #0, mp3, from '/Users/deluan/Music/iTunes/iTunes Media/Music/Compilations/Putumayo Presents Blues Lounge/09 Pablo's Blues.mp3':
+  Metadata:
+    compilation     : 1
+  Duration: 00:00:01.02, start: 0.000000, bitrate: 477 kb/s
+    Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 192 kb/s
+    Stream #0:1: Video: mjpeg, yuvj444p(pc, bt470bg/unknown/unknown), 600x600 [SAR 1:1 DAR 1:1], 90k tbr, 90k tbn, 90k tbc`
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
+			Expect(md.HasPicture()).To(BeTrue())
+		})
+
+		It("gets bitrate from the stream, if available", func() {
+			const output = `
+Input #0, mp3, from '/Users/deluan/Music/iTunes/iTunes Media/Music/Compilations/Putumayo Presents Blues Lounge/09 Pablo's Blues.mp3':
+  Duration: 00:00:01.02, start: 0.000000, bitrate: 477 kb/s
+    Stream #0:0: Audio: mp3, 44100 Hz, stereo, fltp, 192 kb/s`
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
+			Expect(md.BitRate()).To(Equal(192))
+		})
+
 		It("parses correctly the compilation tag", func() {
-			const outputWithOverlappingTitleTag = `
+			const output = `
 Input #0, mp3, from '/Users/deluan/Music/iTunes/iTunes Media/Music/Compilations/Putumayo Presents Blues Lounge/09 Pablo's Blues.mp3':
   Metadata:
     compilation     : 1
   Duration: 00:05:02.63, start: 0.000000, bitrate: 140 kb/s`
-			md, _ := extractMetadata("tests/fixtures/test.mp3", outputWithOverlappingTitleTag)
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
 			Expect(md.Compilation()).To(BeTrue())
 		})
 
-		It("parses correct the title without overlapping with the stream tag", func() {
-			const outputWithOverlappingTitleTag = `
+		It("parses duration with milliseconds", func() {
+			const output = `
+Input #0, mp3, from '/Users/deluan/Music/iTunes/iTunes Media/Music/Compilations/Putumayo Presents Blues Lounge/09 Pablo's Blues.mp3':
+  Duration: 00:05:02.63, start: 0.000000, bitrate: 140 kb/s`
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
+			Expect(md.Duration()).To(BeNumerically("~", 302.63, 0.001))
+		})
+
+		It("parses stream level tags", func() {
+			const output = `
+Input #0, ogg, from './01-02 Drive (Teku).opus':
+  Metadata:
+    ALBUM           : Hot Wheels Acceleracers Soundtrack
+  Duration: 00:03:37.37, start: 0.007500, bitrate: 135 kb/s
+    Stream #0:0(eng): Audio: opus, 48000 Hz, stereo, fltp
+    Metadata:
+      TITLE           : Drive (Teku)`
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
+			Expect(md.Title()).To(Equal("Drive (Teku)"))
+		})
+
+		It("does not overlap top level tags with the stream level tags", func() {
+			const output = `
 Input #0, mp3, from 'groovin.mp3':
   Metadata:
     title           : Groovin' (feat. Daniel Sneijers, Susanne Alt)
   Duration: 00:03:34.28, start: 0.025056, bitrate: 323 kb/s
     Metadata:
-      title           : cover
-At least one output file must be specified`
-			md, _ := extractMetadata("tests/fixtures/test.mp3", outputWithOverlappingTitleTag)
+      title           : garbage`
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
 			Expect(md.Title()).To(Equal("Groovin' (feat. Daniel Sneijers, Susanne Alt)"))
 		})
 
 		It("ignores case in the tag name", func() {
-			const outputWithOverlappingTitleTag = `
+			const output = `
 Input #0, flac, from '/Users/deluan/Downloads/06. Back In Black.flac':
   Metadata:
     ALBUM           : Back In Black
@@ -103,7 +144,7 @@ Input #0, flac, from '/Users/deluan/Downloads/06. Back In Black.flac':
     TRACKTOTAL      : 10
     track           : 6
   Duration: 00:04:16.00, start: 0.000000, bitrate: 995 kb/s`
-			md, _ := extractMetadata("tests/fixtures/test.mp3", outputWithOverlappingTitleTag)
+			md, _ := extractMetadata("tests/fixtures/test.mp3", output)
 			Expect(md.Title()).To(Equal("Back In Black"))
 			Expect(md.Album()).To(Equal("Back In Black"))
 			Expect(md.Genre()).To(Equal("Hard Rock"))
@@ -164,13 +205,13 @@ Tracklist:
 				"May 12, 2016": 0,
 			}
 			for tag, expected := range examples {
-				md := &Metadata{tags: map[string]string{"year": tag}}
+				md := &Metadata{tags: map[string]string{"date": tag}}
 				Expect(md.Year()).To(Equal(expected))
 			}
 		})
 
 		It("returns 0 if year is invalid", func() {
-			md := &Metadata{tags: map[string]string{"year": "invalid"}}
+			md := &Metadata{tags: map[string]string{"date": "invalid"}}
 			Expect(md.Year()).To(Equal(0))
 		})
 	})

server/subsonic/media_retrieval.go

@@ -39,6 +39,7 @@ func (c *MediaRetrievalController) GetCoverArt(w http.ResponseWriter, r *http.Re
 	}
 	size := utils.ParamInt(r, "size", 0)
 
+	w.Header().Set("cache-control", "public, max-age=300")
 	err = c.cover.Get(r.Context(), id, size, w)
 
 	switch {

server/subsonic/playlists.go

@@ -32,7 +32,7 @@ func (c *PlaylistsController) GetPlaylists(w http.ResponseWriter, r *http.Reques
 		playlists[i].Name = p.Name
 		playlists[i].Comment = p.Comment
 		playlists[i].SongCount = len(p.Tracks)
-		playlists[i].Duration = p.Duration
+		playlists[i].Duration = int(p.Duration)
 		playlists[i].Owner = p.Owner
 		playlists[i].Public = p.Public
 	}

server/subsonic/stream.go

@@ -2,7 +2,6 @@ package subsonic
 
 import (
 	"net/http"
-	"strconv"
 
 	"github.com/deluan/navidrome/engine"
 	"github.com/deluan/navidrome/server/subsonic/responses"
@@ -25,15 +24,15 @@ func (c *StreamController) Stream(w http.ResponseWriter, r *http.Request) (*resp
 	maxBitRate := utils.ParamInt(r, "maxBitRate", 0)
 	format := utils.ParamString(r, "format")
 
-	ms, err := c.streamer.NewStream(r.Context(), id, maxBitRate, format)
+	fs, err := c.streamer.NewFileSystem(r.Context(), maxBitRate, format)
 	if err != nil {
 		return nil, err
 	}
 
-	// Override Content-Type detected by http.FileServer
-	w.Header().Set("Content-Type", ms.ContentType())
-	w.Header().Set("X-Content-Duration", strconv.Itoa(ms.Duration()))
-	http.ServeContent(w, r, ms.Name(), ms.ModTime(), ms)
+	// To be able to use a http.FileSystem, we need to change the URL structure
+	r.URL.Path = id
+
+	http.FileServer(fs).ServeHTTP(w, r)
 	return nil, nil
 }
 
@@ -43,13 +42,14 @@ func (c *StreamController) Download(w http.ResponseWriter, r *http.Request) (*re
 		return nil, err
 	}
 
-	ms, err := c.streamer.NewStream(r.Context(), id, 0, "raw")
+	fs, err := c.streamer.NewFileSystem(r.Context(), 0, "raw")
 	if err != nil {
 		return nil, err
 	}
 
-	// Override Content-Type detected by http.FileServer
-	w.Header().Set("Content-Type", ms.ContentType())
-	http.ServeContent(w, r, ms.Name(), ms.ModTime(), ms)
+	// To be able to use a http.FileSystem, we need to change the URL structure
+	r.URL.Path = id
+
+	http.FileServer(fs).ServeHTTP(w, r)
 	return nil, nil
 }

ui/src/album/AlbumDetails.js

@@ -20,11 +20,9 @@ const AlbumDetails = ({ classes, record }) => {
   return (
     <Card className={classes.container}>
       <CardMedia
-        image={subsonicUrl(
-          'getCoverArt',
-          record.coverArtId || 'not_found',
-          'size=500'
-        )}
+        image={subsonicUrl('getCoverArt', record.coverArtId || 'not_found', {
+          size: 500
+        })}
         className={classes.albumCover}
       />
       <CardContent className={classes.albumDetails}>

ui/src/player/queue.js

@@ -10,9 +10,9 @@ const PLAYER_PLAY_ALBUM = 'PLAYER_PLAY_ALBUM'
 const mapToAudioLists = (item) => ({
   name: item.title,
   singer: item.artist,
-  cover: subsonicUrl('getCoverArt', item.id, 'size=300'),
-  musicSrc: subsonicUrl('stream', item.id),
-  scrobble: (submit) => subsonicUrl('scrobble', item.id, `submission=${submit}`)
+  cover: subsonicUrl('getCoverArt', item.id, { size: 300 }),
+  musicSrc: subsonicUrl('stream', item.id, { ts: true }),
+  scrobble: (submit) => subsonicUrl('scrobble', item.id, { submission: submit })
 })
 
 const addTrack = (data) => ({

ui/src/subsonic/index.js

@@ -1,13 +1,22 @@
 const subsonicUrl = (command, id, options) => {
-  const username = localStorage.getItem('username')
-  const token = localStorage.getItem('subsonic-token')
-  const salt = localStorage.getItem('subsonic-salt')
-  const timeStamp = new Date().getTime()
-  const url = `rest/${command}?u=${username}&f=json&v=1.8.0&c=NavidromeUI&t=${token}&s=${salt}&id=${id}&_=${timeStamp}`
+  const params = new URLSearchParams()
+  params.append('u', localStorage.getItem('username'))
+  params.append('t', localStorage.getItem('subsonic-token'))
+  params.append('s', localStorage.getItem('subsonic-salt'))
+  params.append('f', 'json')
+  params.append('v', '1.8.0')
+  params.append('c', 'NavidromeUI')
+  params.append('id', id)
   if (options) {
-    return url + '&' + options
+    if (options.ts) {
+      options['_'] = new Date().getTime()
+      delete options.ts
+    }
+    Object.keys(options).forEach((k) => {
+      params.append(k, options[k])
+    })
   }
-  return url
+  return `rest/${command}?${params.toString()}`
 }
 
 export { subsonicUrl }

wire_gen.go

@@ -7,6 +7,7 @@ package main
 
 import (
 	"github.com/deluan/navidrome/engine"
+	"github.com/deluan/navidrome/engine/ffmpeg"
 	"github.com/deluan/navidrome/persistence"
 	"github.com/deluan/navidrome/scanner"
 	"github.com/deluan/navidrome/server"
@@ -30,7 +31,7 @@ func CreateAppRouter(path string) *app.Router {
 	return router
 }
 
-func CreateSubsonicAPIRouter() *subsonic.Router {
+func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
 	dataStore := persistence.New()
 	browser := engine.NewBrowser(dataStore)
 	cover := engine.NewCover(dataStore)
@@ -41,9 +42,14 @@ func CreateSubsonicAPIRouter() *subsonic.Router {
 	ratings := engine.NewRatings(dataStore)
 	scrobbler := engine.NewScrobbler(dataStore, nowPlayingRepository)
 	search := engine.NewSearch(dataStore)
-	mediaStreamer := engine.NewMediaStreamer(dataStore)
+	fFmpeg := ffmpeg.New()
+	cache, err := engine.NewTranscodingCache()
+	if err != nil {
+		return nil, err
+	}
+	mediaStreamer := engine.NewMediaStreamer(dataStore, fFmpeg, cache)
 	router := subsonic.New(browser, cover, listGenerator, users, playlists, ratings, scrobbler, search, mediaStreamer)
-	return router
+	return router, nil
 }
 
 // wire_injectors.go:

wire_injectors.go

@@ -31,6 +31,6 @@ func CreateAppRouter(path string) *app.Router {
 	panic(wire.Build(allProviders))
 }
 
-func CreateSubsonicAPIRouter() *subsonic.Router {
+func CreateSubsonicAPIRouter() (*subsonic.Router, error) {
 	panic(wire.Build(allProviders))
 }