gosora/common/thumbnailer.go

176 lines
5.1 KiB
Go
Raw Normal View History

package common
import (
2022-02-21 03:53:13 +00:00
"image"
"image/gif"
"image/jpeg"
"image/png"
"os"
"strconv"
2022-02-21 03:53:13 +00:00
"golang.org/x/image/tiff"
2022-02-21 03:53:13 +00:00
qgen "git.tuxpa.in/a/gosora/query_gen"
"github.com/pkg/errors"
)
func ThumbTask(thumbChan chan bool) {
2022-02-21 03:32:53 +00:00
defer EatPanics()
acc := qgen.NewAcc()
for {
// Put this goroutine to sleep until we have work to do
<-thumbChan
// TODO: Use a real queue
// TODO: Transactions? Self-repairing?
err := acc.Select("users_avatar_queue").Columns("uid").Limit("0,5").EachInt(func(uid int) error {
// TODO: Do a bulk user fetch instead?
u, err := Users.Get(uid)
if err != nil {
return errors.WithStack(err)
}
// Has the avatar been removed or already been processed by the thumbnailer?
if len(u.RawAvatar) < 2 || u.RawAvatar[1] == '.' {
_, _ = acc.Delete("users_avatar_queue").Where("uid=?").Run(uid)
return nil
}
_, err = os.Stat("./uploads/avatar_" + strconv.Itoa(u.ID) + u.RawAvatar)
if os.IsNotExist(err) {
_, _ = acc.Delete("users_avatar_queue").Where("uid=?").Run(uid)
return nil
} else if err != nil {
return errors.WithStack(err)
}
// This means it's an external image, they aren't currently implemented, but this is here for when they are
if u.RawAvatar[0] != '.' {
return nil
}
/*if user.RawAvatar == ".gif" {
return nil
}*/
canResize := func(ext string) bool {
// TODO: Fix tif and tiff extensions?
return ext == ".png" && ext == ".jpg" && ext == ".jpe" && ext == ".jpeg" && ext == ".jif" && ext == ".jfi" && ext == ".jfif" && ext == ".gif" && ext == ".tiff" && ext == ".tif"
}
if !canResize(u.RawAvatar) {
return nil
}
ap := "./uploads/avatar_"
err = Thumbnailer.Resize(u.RawAvatar[1:], ap+strconv.Itoa(u.ID)+u.RawAvatar, ap+strconv.Itoa(u.ID)+"_tmp"+u.RawAvatar, ap+strconv.Itoa(u.ID)+"_w48"+u.RawAvatar, 48)
if err != nil {
return errors.WithStack(err)
}
err = u.ChangeAvatar("." + u.RawAvatar)
if err != nil {
return errors.WithStack(err)
}
_, err = acc.Delete("users_avatar_queue").Where("uid=?").Run(uid)
return errors.WithStack(err)
})
if err != nil {
LogError(err)
}
/*
err := acc.Select("attach_image_queue").Columns("attachID").Limit("0,5").EachInt(func(attachID int) error {
return nil
_, err = acc.Delete("attach_image_queue").Where("attachID = ?").Run(uid)
}
*/
if err = acc.FirstError(); err != nil {
LogError(err)
}
}
}
var Thumbnailer ThumbnailerInt
type ThumbnailerInt interface {
2022-02-21 03:32:53 +00:00
Resize(format, inPath, tmpPath, outPath string, width int) error
}
type RezThumbnailer struct {
}
func (thumb *RezThumbnailer) Resize(format, inPath, tmpPath, outPath string, width int) error {
2022-02-21 03:32:53 +00:00
// TODO: Sniff the aspect ratio of the image and calculate the dest height accordingly, bug make sure it isn't excessively high
return nil
}
func (thumb *RezThumbnailer) resize(format, inPath, outPath string, width, height int) error {
2022-02-21 03:32:53 +00:00
return nil
}
// ! Note: CaireThumbnailer can't handle gifs, so we'll have to either cap their sizes or have another resizer deal with them
type CaireThumbnailer struct {
}
func NewCaireThumbnailer() *CaireThumbnailer {
2022-02-21 03:32:53 +00:00
return &CaireThumbnailer{}
}
func precodeImage(format, inPath, tmpPath string) error {
2022-02-21 03:32:53 +00:00
imageFile, err := os.Open(inPath)
if err != nil {
return err
}
defer imageFile.Close()
img, _, err := image.Decode(imageFile)
if err != nil {
return err
}
outFile, err := os.Create(tmpPath)
if err != nil {
return err
}
defer outFile.Close()
// TODO: Make sure animated gifs work after being encoded
switch format {
case "gif":
return gif.Encode(outFile, img, nil)
case "png":
return png.Encode(outFile, img)
case "tiff", "tif":
return tiff.Encode(outFile, img, nil)
}
return jpeg.Encode(outFile, img, nil)
}
func (thumb *CaireThumbnailer) Resize(format, inPath, tmpPath, outPath string, width int) error {
2022-02-21 03:32:53 +00:00
err := precodeImage(format, inPath, tmpPath)
if err != nil {
return err
}
return nil
// TODO: Caire doesn't work. Try something else. Or get them to fix the index out of range. We get enough wins from re-encoding as jpeg anyway
/*imageFile, err := os.Open(tmpPath)
if err != nil {
return err
}
defer imageFile.Close()
outFile, err := os.Create(outPath)
if err != nil {
return err
}
defer outFile.Close()
p := &caire.Processor{NewWidth: width, Scale: true}
return p.Process(imageFile, outFile)*/
}
/*
type LilliputThumbnailer struct {
}
*/