mirrors
/
navidrome
mirror of https://github.com/navidrome/navidrome.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Return album art as a Reader

This commit is contained in:
Deluan 2020-11-17 13:30:37 -05:00
parent 0aaa261a71
commit 25ae1c6cdd
5 changed files with 70 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
core/artwork.go
View File

@ -10,6 +10,7 @@ import (
"image/jpeg"
_ "image/png"
"io"
"io/ioutil"
"os"
"strings"
"sync"
@ -29,7 +30,7 @@ import (
)
type Artwork interface {
Get(ctx context.Context, id string, size int, out io.Writer) error
Get(ctx context.Context, id string, size int) (io.ReadCloser, error)
}
type ArtworkCache cache.FileCache
@ -55,10 +56,10 @@ func (ci *imageInfo) Key() string {
return fmt.Sprintf("%s.%d.%s.%d", ci.path, ci.size, ci.lastUpdate.Format(time.RFC3339Nano), conf.Server.CoverJpegQuality)
}
func (a *artwork) Get(ctx context.Context, id string, size int, out io.Writer) error {
func (a *artwork) Get(ctx context.Context, id string, size int) (io.ReadCloser, error) {
path, lastUpdate, err := a.getImagePath(ctx, id)
if err != nil && err != model.ErrNotFound {
return err
return nil, err
}
if !conf.Server.DevFastAccessCoverArt {
@ -78,12 +79,9 @@ func (a *artwork) Get(ctx context.Context, id string, size int, out io.Writer) e
r, err := a.cache.Get(ctx, info)
if err != nil {
log.Error(ctx, "Error accessing image cache", "path", path, "size", size, err)
return err
return nil, err
}
defer r.Close()
_, err = io.Copy(out, r)
return err
return r, err
}
func (a *artwork) getImagePath(ctx context.Context, id string) (path string, lastUpdated time.Time, err error) {
@ -126,7 +124,7 @@ func (a *artwork) getImagePath(ctx context.Context, id string) (path string, las
return a.getImagePath(ctx, "al-"+mf.AlbumID)
}
func (a *artwork) getArtwork(ctx context.Context, id string, path string, size int) (reader io.Reader, err error) {
func (a *artwork) getArtwork(ctx context.Context, id string, path string, size int) (reader io.ReadCloser, err error) {
defer func() {
if err != nil {
log.Warn(ctx, "Error extracting image", "path", path, "size", size, err)
@ -138,35 +136,28 @@ func (a *artwork) getArtwork(ctx context.Context, id string, path string, size i
return nil, errors.New("empty path given for artwork")
}
var data []byte
if size == 0 {
// If requested original size, just read from the file
if utils.IsAudioFile(path) {
data, err = readFromTag(path)
reader, err = readFromTag(path)
} else {
data, err = readFromFile(path)
reader, err = readFromFile(path)
}
} else {
// If requested a resized image, get the original (possibly from cache) and resize it
buf := new(bytes.Buffer)
err = a.Get(ctx, id, 0, buf)
var r io.ReadCloser
r, err = a.Get(ctx, id, 0)
if err != nil {
return
}
data, err = resizeImage(buf, size)
}
// Confirm the image is valid. Costly, but necessary
_, _, err = image.Decode(bytes.NewReader(data))
if err == nil {
reader = bytes.NewReader(data)
defer r.Close()
reader, err = resizeImage(r, size)
}
return
}
func resizeImage(reader io.Reader, size int) ([]byte, error) {
func resizeImage(reader io.Reader, size int) (io.ReadCloser, error) {
img, _, err := image.Decode(reader)
if err != nil {
return nil, err
@ -183,10 +174,10 @@ func resizeImage(reader io.Reader, size int) ([]byte, error) {
buf := new(bytes.Buffer)
err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
return buf.Bytes(), err
return ioutil.NopCloser(buf), err
}
func readFromTag(path string) ([]byte, error) {
func readFromTag(path string) (io.ReadCloser, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
@ -202,22 +193,11 @@ func readFromTag(path string) ([]byte, error) {
if picture == nil {
return nil, errors.New("file does not contain embedded art")
}
return picture.Data, nil
return ioutil.NopCloser(bytes.NewReader(picture.Data)), nil
}
func readFromFile(path string) ([]byte, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
var buf bytes.Buffer
if _, err := buf.ReadFrom(f); err != nil {
return nil, err
}
return buf.Bytes(), nil
func readFromFile(path string) (io.ReadCloser, error) {
return os.Open(path)
}
var (

75
core/artwork_test.go
View File

@ -1,7 +1,6 @@
package core
import (
"bytes"
"context"
"image"
"io/ioutil"
@ -42,102 +41,100 @@ var _ = Describe("Artwork", func() {
})
It("retrieves the external artwork art for an album", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "al-444", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "al-444", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(r.Close()).To(BeNil())
})
It("retrieves the embedded artwork art for an album", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "al-222", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "al-222", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(r.Close()).To(BeNil())
})
It("returns the default artwork if album does not have artwork", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "al-333", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "al-333", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("png"))
Expect(r.Close()).To(BeNil())
})
It("returns the default artwork if album is not found", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "al-0101", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "al-0101", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("png"))
Expect(r.Close()).To(BeNil())
})
It("retrieves the original artwork art from a media_file", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "123", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "123", 0, buf)).To(BeNil())
img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
img, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(img.Bounds().Size().X).To(Equal(600))
Expect(img.Bounds().Size().Y).To(Equal(600))
Expect(r.Close()).To(BeNil())
})
It("retrieves the album artwork art if media_file does not have one", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "456", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "456", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(r.Close()).To(BeNil())
})
It("retrieves the album artwork by album id", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "222", 0)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "222", 0, buf)).To(BeNil())
_, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
_, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(r.Close()).To(BeNil())
})
It("resized artwork art as requested", func() {
buf := new(bytes.Buffer)
r, err := artwork.Get(ctx, "123", 200)
Expect(err).To(BeNil())
Expect(artwork.Get(ctx, "123", 200, buf)).To(BeNil())
img, format, err := image.Decode(bytes.NewReader(buf.Bytes()))
img, format, err := image.Decode(r)
Expect(err).To(BeNil())
Expect(format).To(Equal("jpeg"))
Expect(img.Bounds().Size().X).To(Equal(200))
Expect(img.Bounds().Size().Y).To(Equal(200))
Expect(r.Close()).To(BeNil())
})
Context("Errors", func() {
It("returns err if gets error from album table", func() {
ds.Album(ctx).(*tests.MockAlbum).SetError(true)
buf := new(bytes.Buffer)
Expect(artwork.Get(ctx, "al-222", 0, buf)).To(MatchError("Error!"))
_, err := artwork.Get(ctx, "al-222", 0)
Expect(err).To(MatchError("Error!"))
})
It("returns err if gets error from media_file table", func() {
ds.MediaFile(ctx).(*tests.MockMediaFile).SetError(true)
buf := new(bytes.Buffer)
Expect(artwork.Get(ctx, "123", 0, buf)).To(MatchError("Error!"))
_, err := artwork.Get(ctx, "123", 0)
Expect(err).To(MatchError("Error!"))
})
})
})

6
core/cache_warmer.go
View File

@ -2,6 +2,7 @@ package core
import (
"context"
"io"
"io/ioutil"
"time"
@ -78,10 +79,13 @@ func (w *warmer) execute(workload interface{}) {
ctx := context.Background()
item := workload.(artworkItem)
log.Trace(ctx, "Pre-caching album artwork", "albumID", item.albumID)
err := w.artwork.Get(ctx, item.albumID, 0, ioutil.Discard)
r, err := w.artwork.Get(ctx, item.albumID, 0)
if err != nil {
log.Warn("Error pre-caching artwork from album", "id", item.albumID, err)
return
}
defer r.Close()
_, _ = io.Copy(ioutil.Discard, r)
}
type artworkItem struct {

7
server/subsonic/media_retrieval.go
View File

@ -65,8 +65,8 @@ func (c *MediaRetrievalController) GetCoverArt(w http.ResponseWriter, r *http.Re
size := utils.ParamInt(r, "size", 0)
w.Header().Set("cache-control", "public, max-age=315360000")
err = c.artwork.Get(r.Context(), id, size, w)
imgReader, err := c.artwork.Get(r.Context(), id, size)
switch {
case err == model.ErrNotFound:
log.Error(r, "Couldn't find coverArt", "id", id, err)
@ -76,5 +76,8 @@ func (c *MediaRetrievalController) GetCoverArt(w http.ResponseWriter, r *http.Re
return nil, err
}
return nil, nil
defer imgReader.Close()
_, err = io.Copy(w, imgReader)
return nil, err
}

9
server/subsonic/media_retrieval_test.go
View File

@ -1,9 +1,11 @@
package subsonic
import (
"bytes"
"context"
"errors"
"io"
"io/ioutil"
"net/http/httptest"
"github.com/deluan/navidrome/model"
@ -67,12 +69,11 @@ type fakeArtwork struct {
recvSize int
}
func (c *fakeArtwork) Get(ctx context.Context, id string, size int, out io.Writer) error {
func (c *fakeArtwork) Get(ctx context.Context, id string, size int) (io.ReadCloser, error) {
if c.err != nil {
return c.err
return nil, c.err
}
c.recvId = id
c.recvSize = size
_, err := out.Write([]byte(c.data))
return err
return ioutil.NopCloser(bytes.NewReader([]byte(c.data))), nil
}