mirror of
https://github.com/superseriousbusiness/gotosocial
synced 2024-12-13 09:08:24 +01:00
5e2bf0bdca
* [chore] Remove years from all license headers Years or year ranges aren't required in license headers. Many projects have removed them in recent years and it avoids a bit of yearly toil. In many cases our copyright claim was also a bit dodgy since we added the 2021-2023 header to files created after 2021 but you can't claim copyright into the past that way. * [chore] Add license header check This ensures a license header is always added to any new file. This avoids maintainers/reviewers needing to remember to check for and ask for it in case a contribution doesn't include it. * [chore] Add missing license headers * [chore] Further updates to license header * Use the more common // indentend comment format * Remove the hack we had for the linter now that we use the // format * Add SPDX license identifier
185 lines
5.5 KiB
Go
185 lines
5.5 KiB
Go
// GoToSocial
|
|
// Copyright (C) GoToSocial Authors admin@gotosocial.org
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package media
|
|
|
|
import (
|
|
"bufio"
|
|
"image"
|
|
"image/color"
|
|
"image/draw"
|
|
"image/jpeg"
|
|
"image/png"
|
|
"io"
|
|
"sync"
|
|
|
|
"github.com/buckket/go-blurhash"
|
|
"github.com/disintegration/imaging"
|
|
"github.com/superseriousbusiness/gotosocial/internal/iotools"
|
|
|
|
// import to init webp encode/decoding.
|
|
_ "golang.org/x/image/webp"
|
|
)
|
|
|
|
var (
|
|
// pngEncoder provides our global PNG encoding with
|
|
// specified compression level, and memory pooled buffers.
|
|
pngEncoder = png.Encoder{
|
|
CompressionLevel: png.DefaultCompression,
|
|
BufferPool: &pngEncoderBufferPool{},
|
|
}
|
|
|
|
// jpegBufferPool is a memory pool of byte buffers for JPEG encoding.
|
|
jpegBufferPool = sync.Pool{
|
|
New: func() any {
|
|
return bufio.NewWriter(nil)
|
|
},
|
|
}
|
|
)
|
|
|
|
// gtsImage is a thin wrapper around the standard library image
|
|
// interface to provide our own useful helper functions for image
|
|
// size and aspect ratio calculations, streamed encoding to various
|
|
// types, and creating reduced size thumbnail images.
|
|
type gtsImage struct{ image image.Image }
|
|
|
|
// blankImage generates a blank image of given dimensions.
|
|
func blankImage(width int, height int) *gtsImage {
|
|
// create a rectangle with the same dimensions as the video
|
|
img := image.NewRGBA(image.Rect(0, 0, width, height))
|
|
|
|
// fill the rectangle with our desired fill color.
|
|
draw.Draw(img, img.Bounds(), &image.Uniform{
|
|
color.RGBA{42, 43, 47, 0},
|
|
}, image.Point{}, draw.Src)
|
|
|
|
return >sImage{image: img}
|
|
}
|
|
|
|
// decodeImage will decode image from reader stream and return image wrapped in our own gtsImage{} type.
|
|
func decodeImage(r io.Reader, opts ...imaging.DecodeOption) (*gtsImage, error) {
|
|
img, err := imaging.Decode(r, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return >sImage{image: img}, nil
|
|
}
|
|
|
|
// Width returns the image width in pixels.
|
|
func (m *gtsImage) Width() uint32 {
|
|
return uint32(m.image.Bounds().Size().X)
|
|
}
|
|
|
|
// Height returns the image height in pixels.
|
|
func (m *gtsImage) Height() uint32 {
|
|
return uint32(m.image.Bounds().Size().Y)
|
|
}
|
|
|
|
// Size returns the total number of image pixels.
|
|
func (m *gtsImage) Size() uint64 {
|
|
return uint64(m.image.Bounds().Size().X) *
|
|
uint64(m.image.Bounds().Size().Y)
|
|
}
|
|
|
|
// AspectRatio returns the image ratio of width:height.
|
|
func (m *gtsImage) AspectRatio() float32 {
|
|
return float32(m.image.Bounds().Size().X) /
|
|
float32(m.image.Bounds().Size().Y)
|
|
}
|
|
|
|
// Thumbnail returns a small sized copy of gtsImage{}, limited to 512x512 if not small enough.
|
|
func (m *gtsImage) Thumbnail() *gtsImage {
|
|
const (
|
|
// max thumb
|
|
// dimensions.
|
|
maxWidth = 512
|
|
maxHeight = 512
|
|
)
|
|
|
|
// Check the receiving image is within max thumnail bounds.
|
|
if m.Width() <= maxWidth && m.Height() <= maxHeight {
|
|
return >sImage{image: imaging.Clone(m.image)}
|
|
}
|
|
|
|
// Image is too large, needs to be resized to thumbnail max.
|
|
img := imaging.Fit(m.image, maxWidth, maxHeight, imaging.Linear)
|
|
return >sImage{image: img}
|
|
}
|
|
|
|
// Blurhash calculates the blurhash for the receiving image data.
|
|
func (m *gtsImage) Blurhash() (string, error) {
|
|
// for generating blurhashes, it's more cost effective to
|
|
// lose detail since it's blurry, so make a tiny version.
|
|
tiny := imaging.Resize(m.image, 32, 0, imaging.NearestNeighbor)
|
|
|
|
// Encode blurhash from resized version
|
|
return blurhash.Encode(4, 3, tiny)
|
|
}
|
|
|
|
// ToJPEG creates a new streaming JPEG encoder from receiving image, and a size ptr
|
|
// which stores the number of bytes written during the image encoding process.
|
|
func (m *gtsImage) ToJPEG(opts *jpeg.Options) io.Reader {
|
|
return iotools.StreamWriteFunc(func(w io.Writer) error {
|
|
// Get encoding buffer
|
|
bw := getJPEGBuffer(w)
|
|
|
|
// Encode JPEG to buffered writer.
|
|
err := jpeg.Encode(bw, m.image, opts)
|
|
|
|
// Replace buffer.
|
|
//
|
|
// NOTE: jpeg.Encode() already
|
|
// performs a bufio.Writer.Flush().
|
|
putJPEGBuffer(bw)
|
|
|
|
return err
|
|
})
|
|
}
|
|
|
|
// ToPNG creates a new streaming PNG encoder from receiving image, and a size ptr
|
|
// which stores the number of bytes written during the image encoding process.
|
|
func (m *gtsImage) ToPNG() io.Reader {
|
|
return iotools.StreamWriteFunc(func(w io.Writer) error {
|
|
return pngEncoder.Encode(w, m.image)
|
|
})
|
|
}
|
|
|
|
// getJPEGBuffer fetches a reset JPEG encoding buffer from global JPEG buffer pool.
|
|
func getJPEGBuffer(w io.Writer) *bufio.Writer {
|
|
buf, _ := jpegBufferPool.Get().(*bufio.Writer)
|
|
buf.Reset(w)
|
|
return buf
|
|
}
|
|
|
|
// putJPEGBuffer resets the given bufio writer and places in global JPEG buffer pool.
|
|
func putJPEGBuffer(buf *bufio.Writer) {
|
|
buf.Reset(nil)
|
|
jpegBufferPool.Put(buf)
|
|
}
|
|
|
|
// pngEncoderBufferPool implements png.EncoderBufferPool.
|
|
type pngEncoderBufferPool sync.Pool
|
|
|
|
func (p *pngEncoderBufferPool) Get() *png.EncoderBuffer {
|
|
buf, _ := (*sync.Pool)(p).Get().(*png.EncoderBuffer)
|
|
return buf
|
|
}
|
|
|
|
func (p *pngEncoderBufferPool) Put(buf *png.EncoderBuffer) {
|
|
(*sync.Pool)(p).Put(buf)
|
|
}
|