gosora/common/thumbnailer.go

package common

import (
	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"os"
	"strconv"

	"github.com/Azareal/Gosora/query_gen"
	"github.com/pkg/errors"
)

func ThumbTask(thumbChan chan bool) {
	for {
		// Put this goroutine to sleep until we have work to do
		<-thumbChan

		// TODO: Use a real queue
		// TODO: Transactions? Self-repairing?
		acc := qgen.NewAcc()
		err := acc.Select("users_avatar_queue").Columns("uid").Limit("0,5").EachInt(func(uid int) error {
			// TODO: Do a bulk user fetch instead?
			user, 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(user.RawAvatar) < 2 || user.RawAvatar[1] == '.' {
				_, _ = acc.Delete("users_avatar_queue").Where("uid = ?").Run(uid)
				return nil
			}
			_, err = os.Stat("./uploads/avatar_" + strconv.Itoa(user.ID) + user.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 user.RawAvatar[0] != '.' {
				return nil
			}
			/*if user.RawAvatar == ".gif" {
				return nil
			}*/
			if user.RawAvatar != ".png" && user.RawAvatar != ".jpg" && user.RawAvatar != ".jpeg" && user.RawAvatar != ".gif" {
				return nil
			}

			err = Thumbnailer.Resize(user.RawAvatar[1:], "./uploads/avatar_"+strconv.Itoa(user.ID)+user.RawAvatar, "./uploads/avatar_"+strconv.Itoa(user.ID)+"_tmp"+user.RawAvatar, "./uploads/avatar_"+strconv.Itoa(user.ID)+"_w48"+user.RawAvatar, 48)
			if err != nil {
				return errors.WithStack(err)
			}

			err = user.ChangeAvatar("." + user.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 {
	Resize(format string, inPath string, tmpPath string, outPath string, width int) error
}

type RezThumbnailer struct {
}

func (thumb *RezThumbnailer) Resize(format string, inPath string, tmpPath string, outPath string, width int) error {
	// 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 string, inPath string, outPath string, width int, height int) error {
	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 {
	return &CaireThumbnailer{}
}

func precodeImage(format string, inPath string, tmpPath string) error {
	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
	if format == "gif" {
		return gif.Encode(outFile, img, nil)
	} else if format == "png" {
		return png.Encode(outFile, img)
	}
	return jpeg.Encode(outFile, img, nil)
}

func (thumb *CaireThumbnailer) Resize(format string, inPath string, tmpPath string, outPath string, width int) error {
	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 {

}
*/