mirror of https://github.com/stashapp/stash.git
122 lines
2.9 KiB
Go
122 lines
2.9 KiB
Go
package image
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"image"
|
|
"os/exec"
|
|
"runtime"
|
|
"sync"
|
|
|
|
"github.com/stashapp/stash/pkg/ffmpeg"
|
|
"github.com/stashapp/stash/pkg/ffmpeg/transcoder"
|
|
"github.com/stashapp/stash/pkg/models"
|
|
)
|
|
|
|
const ffmpegImageQuality = 5
|
|
|
|
var vipsPath string
|
|
var once sync.Once
|
|
|
|
var (
|
|
ErrUnsupportedImageFormat = errors.New("unsupported image format")
|
|
|
|
// ErrNotSupportedForThumbnail is returned if the image format is not supported for thumbnail generation
|
|
ErrNotSupportedForThumbnail = errors.New("unsupported image format for thumbnail")
|
|
)
|
|
|
|
type ThumbnailEncoder struct {
|
|
ffmpeg ffmpeg.FFMpeg
|
|
vips *vipsEncoder
|
|
}
|
|
|
|
func GetVipsPath() string {
|
|
once.Do(func() {
|
|
vipsPath, _ = exec.LookPath("vips")
|
|
})
|
|
return vipsPath
|
|
}
|
|
|
|
func NewThumbnailEncoder(ffmpegEncoder ffmpeg.FFMpeg) ThumbnailEncoder {
|
|
ret := ThumbnailEncoder{
|
|
ffmpeg: ffmpegEncoder,
|
|
}
|
|
|
|
vipsPath := GetVipsPath()
|
|
if vipsPath != "" {
|
|
vipsEncoder := vipsEncoder(vipsPath)
|
|
ret.vips = &vipsEncoder
|
|
}
|
|
|
|
return ret
|
|
}
|
|
|
|
// GetThumbnail returns the thumbnail image of the provided image resized to
|
|
// the provided max size. It resizes based on the largest X/Y direction.
|
|
// It returns nil and an error if an error occurs reading, decoding or encoding
|
|
// the image, or if the image is not suitable for thumbnails.
|
|
func (e *ThumbnailEncoder) GetThumbnail(img *models.Image, maxSize int) ([]byte, error) {
|
|
reader, err := openSourceImage(img.Path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
buf := new(bytes.Buffer)
|
|
if _, err := buf.ReadFrom(reader); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data := buf.Bytes()
|
|
|
|
// use NewBufferString to copy the buffer, rather than reuse it
|
|
_, format, err := image.DecodeConfig(bytes.NewBufferString(string(data)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
animated := format == formatGif
|
|
|
|
// #2266 - if image is webp, then determine if it is animated
|
|
if format == formatWebP {
|
|
animated = isWebPAnimated(data)
|
|
}
|
|
|
|
// #2266 - don't generate a thumbnail for animated images
|
|
if animated {
|
|
return nil, fmt.Errorf("%w: %s", ErrNotSupportedForThumbnail, format)
|
|
}
|
|
|
|
// vips has issues loading files from stdin on Windows
|
|
if e.vips != nil && runtime.GOOS != "windows" {
|
|
return e.vips.ImageThumbnail(buf, maxSize)
|
|
} else {
|
|
return e.ffmpegImageThumbnail(buf, format, maxSize)
|
|
}
|
|
}
|
|
|
|
func (e *ThumbnailEncoder) ffmpegImageThumbnail(image *bytes.Buffer, format string, maxSize int) ([]byte, error) {
|
|
var ffmpegFormat ffmpeg.ImageFormat
|
|
|
|
switch format {
|
|
case "jpeg":
|
|
ffmpegFormat = ffmpeg.ImageFormatJpeg
|
|
case "png":
|
|
ffmpegFormat = ffmpeg.ImageFormatPng
|
|
case "webp":
|
|
ffmpegFormat = ffmpeg.ImageFormatWebp
|
|
default:
|
|
return nil, ErrUnsupportedImageFormat
|
|
}
|
|
|
|
args := transcoder.ImageThumbnail("-", transcoder.ImageThumbnailOptions{
|
|
InputFormat: ffmpegFormat,
|
|
OutputPath: "-",
|
|
MaxDimensions: maxSize,
|
|
Quality: ffmpegImageQuality,
|
|
})
|
|
|
|
return e.ffmpeg.GenerateOutput(context.TODO(), args, image)
|
|
}
|