[performance] handle emoji refreshes asynchronously when fetched as part of account|status dereferences (#4486)

# Description

Updates our dereferencer emoji handling to work asynchronously when going through the route of account or status dereferencing.

closes https://codeberg.org/superseriousbusiness/gotosocial/issues/4485

## Checklist

- [x] I/we have read the [GoToSocial contribution guidelines](https://codeberg.org/superseriousbusiness/gotosocial/src/branch/main/CONTRIBUTING.md).
- [x] I/we have discussed the proposed changes already, either in an issue on the repository, or in the Matrix chat.
- [x] I/we have not leveraged AI to create the proposed changes.
- [x] I/we have performed a self-review of added code.
- [x] I/we have written code that is legible and maintainable by others.
- [ ] I/we have commented the added code, particularly in hard-to-understand areas.
- [ ] I/we have made any necessary changes to documentation.
- [ ] I/we have added tests that cover new code.
- [ ] I/we have run tests and they pass locally with the changes.
- [x] I/we have run `go fmt ./...` and `golangci-lint run`.

Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4486
Co-authored-by: kim <grufwub@gmail.com>
Co-committed-by: kim <grufwub@gmail.com>

internal/federation/dereferencing/emoji.go

@@ -51,6 +51,7 @@ func (d *Dereferencer) GetEmoji(
 	remoteURL string,
 	info media.AdditionalEmojiInfo,
 	refresh bool,
+	async bool,
 ) (
 	*gtsmodel.Emoji,
 	error,
@@ -66,7 +67,7 @@ func (d *Dereferencer) GetEmoji(
 
 	if emoji != nil {
 		// This was an existing emoji, pass to refresh func.
-		return d.RefreshEmoji(ctx, emoji, info, refresh)
+		return d.RefreshEmoji(ctx, emoji, info, refresh, async)
 	}
 
 	if domain == "" {
@@ -112,6 +113,7 @@ func (d *Dereferencer) GetEmoji(
 				info,
 			)
 		},
+		async,
 	)
 }
 
@@ -130,6 +132,7 @@ func (d *Dereferencer) RefreshEmoji(
 	emoji *gtsmodel.Emoji,
 	info media.AdditionalEmojiInfo,
 	force bool,
+	async bool,
 ) (
 	*gtsmodel.Emoji,
 	error,
@@ -162,7 +165,7 @@ func (d *Dereferencer) RefreshEmoji(
 		// We still want to make sure
 		// the emoji is cached. Simply
 		// check whether emoji is cached.
-		return d.RecacheEmoji(ctx, emoji)
+		return d.RecacheEmoji(ctx, emoji, async)
 	}
 
 	// Can't refresh local.
@@ -207,6 +210,7 @@ func (d *Dereferencer) RefreshEmoji(
 				info,
 			)
 		},
+		async,
 	)
 }
 
@@ -222,6 +226,7 @@ func (d *Dereferencer) RefreshEmoji(
 func (d *Dereferencer) RecacheEmoji(
 	ctx context.Context,
 	emoji *gtsmodel.Emoji,
+	async bool,
 ) (
 	*gtsmodel.Emoji,
 	error,
@@ -272,23 +277,24 @@ func (d *Dereferencer) RecacheEmoji(
 				data,
 			)
 		},
+		async,
 	)
-
 }
 
 // processingEmojiSafely provides concurrency-safe processing of
 // an emoji with given shortcode+domain. if a copy of the emoji is
 // not already being processed, the given 'process' callback will
-// be used to generate new *media.ProcessingEmoji{} instance.
+// be used to generate new *media.ProcessingEmoji{} instance. async
+// determines whether to load it immediately, or in the background.
 func (d *Dereferencer) processEmojiSafely(
 	ctx context.Context,
 	shortcodeDomain string,
 	process func() (*media.ProcessingEmoji, error),
+	async bool,
 ) (
 	emoji *gtsmodel.Emoji,
 	err error,
 ) {
-
 	// Acquire map lock.
 	d.derefEmojisMu.Lock()
 
@@ -309,25 +315,34 @@ func (d *Dereferencer) processEmojiSafely(
 
 		// Add processing emoji media to hash map.
 		d.derefEmojis[shortcodeDomain] = processing
+	}
 
+	// Unlock map.
+	unlock()
+
+	if async {
+		emoji = processing.LoadAsync(func() {
+			// Remove on finish.
+			d.derefEmojisMu.Lock()
+			delete(d.derefEmojis, shortcodeDomain)
+			d.derefEmojisMu.Unlock()
+		})
+	} else {
 		defer func() {
 			// Remove on finish.
 			d.derefEmojisMu.Lock()
 			delete(d.derefEmojis, shortcodeDomain)
 			d.derefEmojisMu.Unlock()
 		}()
-	}
 
-	// Unlock map.
+		// Perform emoji load operation.
-	unlock()
+		emoji, err = processing.Load(ctx)
+		if err != nil {
+			err = gtserror.Newf("error loading emoji %s: %w", shortcodeDomain, err)
 
-	// Perform emoji load operation.
+			// TODO: in time we should return checkable flags by gtserror.Is___()
-	emoji, err = processing.Load(ctx)
+			// which can determine if loading error should allow remaining placeholder.
-	if err != nil {
+		}
-		err = gtserror.Newf("error loading emoji %s: %w", shortcodeDomain, err)
-
-		// TODO: in time we should return checkable flags by gtserror.Is___()
-		// which can determine if loading error should allow remaining placeholder.
 	}
 
 	return
@@ -364,7 +379,7 @@ func (d *Dereferencer) fetchEmojis(
 				URI:                  &placeholder.URI,
 				ImageRemoteURL:       &placeholder.ImageRemoteURL,
 				ImageStaticRemoteURL: &placeholder.ImageStaticRemoteURL,
-			}, force)
+			}, force, true)
 			if err != nil {
 				log.Errorf(ctx, "error refreshing emoji: %v", err)
 
@@ -396,6 +411,7 @@ func (d *Dereferencer) fetchEmojis(
 				ImageStaticRemoteURL: &placeholder.ImageStaticRemoteURL,
 			},
 			false,
+			true,
 		)
 		if err != nil {
 			if emoji == nil {

internal/federation/dereferencing/emoji_test.go

@@ -54,6 +54,7 @@ func (suite *EmojiTestSuite) TestDereferenceEmojiBlocking() {
 			VisibleInPicker:      &emojiVisibleInPicker,
 		},
 		false,
+		false,
 	)
 	suite.NoError(err)
 	suite.NotNil(emoji)

internal/gtsmodel/interactionpolicy.go

@@ -244,6 +244,12 @@ func (pr1 *PolicyRules) DifferentFrom(pr2 *PolicyRules) bool {
 		return true
 	}
 
+	// If they're both nil we don't
+	// need to check anything else.
+	if pr1 == nil && pr2 == nil {
+		return false
+	}
+
 	// Check if AutomaticApproval
 	// differs between the two.
 	if slices.Compare(

internal/media/imaging.go

@@ -21,6 +21,8 @@ import (
 	"image"
 	"image/color"
 	"math"
+
+	"code.superseriousbusiness.org/gotosocial/internal/gtserror"
 )
 
 // NOTE:
@@ -73,15 +75,15 @@ func resizeDownLinear(img image.Image, width, height int) image.Image {
 
 // flipH flips the image horizontally (left to right).
 func flipH(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.w
+	dstW := srcW
-	dstH := src.h
+	dstH := srcH
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcY := y
-		src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])
+		scanImage(img, 0, srcY, srcW, srcY+1, dst.Pix[i:i+rowSize])
 		reverse(dst.Pix[i : i+rowSize])
 	}
 	return dst
@@ -89,45 +91,45 @@ func flipH(img image.Image) image.Image {
 
 // flipV flips the image vertically (from top to bottom).
 func flipV(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.w
+	dstW := srcW
-	dstH := src.h
+	dstH := srcH
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcY := dstH - y - 1
-		src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])
+		scanImage(img, 0, srcY, srcW, srcY+1, dst.Pix[i:i+rowSize])
 	}
 	return dst
 }
 
 // rotate90 rotates the image 90 counter-clockwise.
 func rotate90(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.h
+	dstW := srcH
-	dstH := src.w
+	dstH := srcW
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcX := dstH - y - 1
-		src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])
+		scanImage(img, srcX, 0, srcX+1, srcH, dst.Pix[i:i+rowSize])
 	}
 	return dst
 }
 
 // rotate180 rotates the image 180 counter-clockwise.
 func rotate180(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.w
+	dstW := srcW
-	dstH := src.h
+	dstH := srcH
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcY := dstH - y - 1
-		src.scan(0, srcY, src.w, srcY+1, dst.Pix[i:i+rowSize])
+		scanImage(img, 0, srcY, srcW, srcY+1, dst.Pix[i:i+rowSize])
 		reverse(dst.Pix[i : i+rowSize])
 	}
 	return dst
@@ -135,15 +137,15 @@ func rotate180(img image.Image) image.Image {
 
 // rotate270 rotates the image 270 counter-clockwise.
 func rotate270(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.h
+	dstW := srcH
-	dstH := src.w
+	dstH := srcW
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcX := y
-		src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])
+		scanImage(img, srcX, 0, srcX+1, srcH, dst.Pix[i:i+rowSize])
 		reverse(dst.Pix[i : i+rowSize])
 	}
 	return dst
@@ -151,30 +153,30 @@ func rotate270(img image.Image) image.Image {
 
 // transpose flips the image horizontally and rotates 90 counter-clockwise.
 func transpose(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.h
+	dstW := srcH
-	dstH := src.w
+	dstH := srcW
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcX := y
-		src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])
+		scanImage(img, srcX, 0, srcX+1, srcH, dst.Pix[i:i+rowSize])
 	}
 	return dst
 }
 
 // transverse flips the image vertically and rotates 90 counter-clockwise.
 func transverse(img image.Image) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dstW := src.h
+	dstW := srcH
-	dstH := src.w
+	dstH := srcW
 	rowSize := dstW * 4
 	dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
 	for y := 0; y < dstH; y++ {
 		i := y * dst.Stride
 		srcX := dstH - y - 1
-		src.scan(srcX, 0, srcX+1, src.h, dst.Pix[i:i+rowSize])
+		scanImage(img, srcX, 0, srcX+1, srcH, dst.Pix[i:i+rowSize])
 		reverse(dst.Pix[i : i+rowSize])
 	}
 	return dst
@@ -182,12 +184,12 @@ func transverse(img image.Image) image.Image {
 
 // resizeHorizontalLinear resizes image to given width using linear resampling.
 func resizeHorizontalLinear(img image.Image, dstWidth int) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dst := image.NewRGBA(image.Rect(0, 0, dstWidth, src.h))
+	dst := image.NewRGBA(image.Rect(0, 0, dstWidth, srcH))
-	weights := precomputeWeightsLinear(dstWidth, src.w)
+	weights := precomputeWeightsLinear(dstWidth, srcW)
-	scanLine := make([]uint8, src.w*4)
+	scanLine := make([]uint8, srcW*4)
-	for y := 0; y < src.h; y++ {
+	for y := 0; y < srcH; y++ {
-		src.scan(0, y, src.w, y+1, scanLine)
+		scanImage(img, 0, y, srcW, y+1, scanLine)
 		j0 := y * dst.Stride
 		for x := range weights {
 			var r, g, b, a float64
@@ -201,13 +203,12 @@ func resizeHorizontalLinear(img image.Image, dstWidth int) image.Image {
 				a += aw
 			}
 			if a != 0 {
-				aInv := 1 / a
 				j := j0 + x*4
 				d := dst.Pix[j : j+4 : j+4]
-				d[0] = clampFloat(r * aInv)
+				d[0] = clampFloatTo8(r / a)
-				d[1] = clampFloat(g * aInv)
+				d[1] = clampFloatTo8(g / a)
-				d[2] = clampFloat(b * aInv)
+				d[2] = clampFloatTo8(b / a)
-				d[3] = clampFloat(a)
+				d[3] = clampFloatTo8(a)
 			}
 		}
 	}
@@ -216,12 +217,12 @@ func resizeHorizontalLinear(img image.Image, dstWidth int) image.Image {
 
 // resizeVerticalLinear resizes image to given height using linear resampling.
 func resizeVerticalLinear(img image.Image, height int) image.Image {
-	src := newScanner(img)
+	srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy()
-	dst := image.NewNRGBA(image.Rect(0, 0, src.w, height))
+	dst := image.NewNRGBA(image.Rect(0, 0, srcW, height))
-	weights := precomputeWeightsLinear(height, src.h)
+	weights := precomputeWeightsLinear(height, srcH)
-	scanLine := make([]uint8, src.h*4)
+	scanLine := make([]uint8, srcH*4)
-	for x := 0; x < src.w; x++ {
+	for x := 0; x < srcW; x++ {
-		src.scan(x, 0, x+1, src.h, scanLine)
+		scanImage(img, x, 0, x+1, srcH, scanLine)
 		for y := range weights {
 			var r, g, b, a float64
 			for _, w := range weights[y] {
@@ -234,13 +235,12 @@ func resizeVerticalLinear(img image.Image, height int) image.Image {
 				a += aw
 			}
 			if a != 0 {
-				aInv := 1 / a
 				j := y*dst.Stride + x*4
 				d := dst.Pix[j : j+4 : j+4]
-				d[0] = clampFloat(r * aInv)
+				d[0] = clampFloatTo8(r / a)
-				d[1] = clampFloat(g * aInv)
+				d[1] = clampFloatTo8(g / a)
-				d[2] = clampFloat(b * aInv)
+				d[2] = clampFloatTo8(b / a)
-				d[3] = clampFloat(a)
+				d[3] = clampFloatTo8(a)
 			}
 		}
 	}
@@ -263,13 +263,14 @@ func precomputeWeightsLinear(dstSize, srcSize int) [][]indexWeight {
 	out := make([][]indexWeight, dstSize)
 	tmp := make([]indexWeight, 0, dstSize*int(ru+2)*2)
 
-	for v := 0; v < dstSize; v++ {
+	for v := 0; v < len(out); v++ {
 		fu := (float64(v)+0.5)*du - 0.5
 
 		begin := int(math.Ceil(fu - ru))
 		if begin < 0 {
 			begin = 0
 		}
+
 		end := int(math.Floor(fu + ru))
 		if end > srcSize-1 {
 			end = srcSize - 1
@@ -280,9 +281,13 @@ func precomputeWeightsLinear(dstSize, srcSize int) [][]indexWeight {
 			w := resampleLinear((float64(u) - fu) / scale)
 			if w != 0 {
 				sum += w
-				tmp = append(tmp, indexWeight{index: u, weight: w})
+				tmp = append(tmp, indexWeight{
+					index:  u,
+					weight: w,
+				})
 			}
 		}
+
 		if sum != 0 {
 			for i := range tmp {
 				tmp[i].weight /= sum
@@ -305,204 +310,209 @@ func resampleLinear(x float64) float64 {
 	return 0
 }
 
-// scanner wraps an image.Image for
+// scan scans the given rectangular region of the image into dst.
-// easier size access and image type
+func scanImage(img image.Image, x1, y1, x2, y2 int, dst []uint8) {
-// agnostic access to data at coords.
+	switch img := img.(type) {
-type scanner struct {
+	case *image.NRGBA:
-	image   image.Image
+		scanNRGBA(img, x1, y1, x2, y2, dst)
-	w, h    int
+	case *image.NRGBA64:
-	palette []color.NRGBA
+		scanNRGBA64(img, x1, y1, x2, y2, dst)
+	case *image.RGBA:
+		scanRGBA(img, x1, y1, x2, y2, dst)
+	case *image.RGBA64:
+		scanRGBA64(img, x1, y1, x2, y2, dst)
+	case *image.Gray:
+		scanGray(img, x1, y1, x2, y2, dst)
+	case *image.Gray16:
+		scanGray16(img, x1, y1, x2, y2, dst)
+	case *image.YCbCr:
+		scanYCbCr(img, x1, y1, x2, y2, dst)
+	case *image.Paletted:
+		scanPaletted(img, x1, y1, x2, y2, dst)
+	default:
+		scanAny(img, x1, y1, x2, y2, dst)
+	}
 }
 
-// newScanner wraps an image.Image in scanner{} type.
+func scanNRGBA(img *image.NRGBA, x1, y1, x2, y2 int, dst []uint8) {
-func newScanner(img image.Image) *scanner {
+	size := (x2 - x1) * 4
-	b := img.Bounds()
+	j := 0
-	s := &scanner{
+	i := y1*img.Stride + x1*4
-		image: img,
+	if size == 4 {
-
+		for y := y1; y < y2; y++ {
-		w: b.Dx(),
+			d := dst[j : j+4 : j+4]
-		h: b.Dy(),
+			s := img.Pix[i : i+4 : i+4]
-	}
+			d[0] = s[0]
-	if img, ok := img.(*image.Paletted); ok {
+			d[1] = s[1]
-		s.palette = make([]color.NRGBA, len(img.Palette))
+			d[2] = s[2]
-		for i := 0; i < len(img.Palette); i++ {
+			d[3] = s[3]
-			s.palette[i] = color.NRGBAModel.Convert(img.Palette[i]).(color.NRGBA)
+			j += size
+			i += img.Stride
+		}
+	} else {
+		for y := y1; y < y2; y++ {
+			copy(dst[j:j+size], img.Pix[i:i+size])
+			j += size
+			i += img.Stride
 		}
 	}
-	return s
 }
 
-// scan scans the given rectangular region of the image into dst.
+func scanNRGBA64(img *image.NRGBA64, x1, y1, x2, y2 int, dst []uint8) {
-func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
+	if img == nil {
-	switch img := s.image.(type) {
+		panic(gtserror.New("nil check elimination"))
-	case *image.NRGBA:
+	}
-		size := (x2 - x1) * 4
+	j := 0
-		j := 0
+	for y := y1; y < y2; y++ {
-		i := y1*img.Stride + x1*4
+		i := y*img.Stride + x1*8
-		if size == 4 {
+		for x := x1; x < x2; x++ {
-			for y := y1; y < y2; y++ {
+			s := img.Pix[i : i+8 : i+8]
-				d := dst[j : j+4 : j+4]
+			d := dst[j : j+4 : j+4]
+			d[0] = s[0]
+			d[1] = s[2]
+			d[2] = s[4]
+			d[3] = s[6]
+			j += 4
+			i += 8
+		}
+	}
+}
+
+func scanRGBA(img *image.RGBA, x1, y1, x2, y2 int, dst []uint8) {
+	if img == nil {
+		panic(gtserror.New("nil check elimination"))
+	}
+	j := 0
+	for y := y1; y < y2; y++ {
+		i := y*img.Stride + x1*4
+		for x := x1; x < x2; x++ {
+			d := dst[j : j+4 : j+4]
+			a := img.Pix[i+3]
+			switch a {
+			case 0:
+				d[0] = 0
+				d[1] = 0
+				d[2] = 0
+				d[3] = a
+			case 0xff:
 				s := img.Pix[i : i+4 : i+4]
 				d[0] = s[0]
 				d[1] = s[1]
 				d[2] = s[2]
-				d[3] = s[3]
+				d[3] = a
-				j += size
+			default:
-				i += img.Stride
+				s := img.Pix[i : i+4 : i+4]
-			}
+				r16 := uint16(s[0])
-		} else {
+				g16 := uint16(s[1])
-			for y := y1; y < y2; y++ {
+				b16 := uint16(s[2])
-				copy(dst[j:j+size], img.Pix[i:i+size])
+				a16 := uint16(a)
-				j += size
+				d[0] = uint8(r16 * 0xff / a16) // #nosec G115 -- Overflow desired.
-				i += img.Stride
+				d[1] = uint8(g16 * 0xff / a16) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(b16 * 0xff / a16) // #nosec G115 -- Overflow desired.
+				d[3] = a
 			}
+			j += 4
+			i += 4
 		}
+	}
+}
 
-	case *image.NRGBA64:
+func scanRGBA64(img *image.RGBA64, x1, y1, x2, y2 int, dst []uint8) {
-		j := 0
+	if img == nil {
-		for y := y1; y < y2; y++ {
+		panic(gtserror.New("nil check elimination"))
-			i := y*img.Stride + x1*8
+	}
-			for x := x1; x < x2; x++ {
+	j := 0
-				s := img.Pix[i : i+8 : i+8]
+	for y := y1; y < y2; y++ {
-				d := dst[j : j+4 : j+4]
+		i := y*img.Stride + x1*8
+		for x := x1; x < x2; x++ {
+			s := img.Pix[i : i+8 : i+8]
+			d := dst[j : j+4 : j+4]
+			a := s[6]
+			switch a {
+			case 0:
+				d[0] = 0
+				d[1] = 0
+				d[2] = 0
+			case 0xff:
 				d[0] = s[0]
 				d[1] = s[2]
 				d[2] = s[4]
-				d[3] = s[6]
+			default:
-				j += 4
+				r32 := uint32(s[0])<<8 | uint32(s[1])
-				i += 8
+				g32 := uint32(s[2])<<8 | uint32(s[3])
+				b32 := uint32(s[4])<<8 | uint32(s[5])
+				a32 := uint32(s[6])<<8 | uint32(s[7])
+				d[0] = uint8((r32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
+				d[1] = uint8((g32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
+				d[2] = uint8((b32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
 			}
+			d[3] = a
+			j += 4
+			i += 8
 		}
+	}
+}
 
-	case *image.RGBA:
+func scanGray(img *image.Gray, x1, y1, x2, y2 int, dst []uint8) {
-		j := 0
+	if img == nil {
-		for y := y1; y < y2; y++ {
+		panic(gtserror.New("nil check elimination"))
-			i := y*img.Stride + x1*4
+	}
-			for x := x1; x < x2; x++ {
+	j := 0
-				d := dst[j : j+4 : j+4]
+	for y := y1; y < y2; y++ {
-				a := img.Pix[i+3]
+		i := y*img.Stride + x1
-				switch a {
+		for x := x1; x < x2; x++ {
-				case 0:
+			c := img.Pix[i]
-					d[0] = 0
+			d := dst[j : j+4 : j+4]
-					d[1] = 0
+			d[0] = c
-					d[2] = 0
+			d[1] = c
-					d[3] = a
+			d[2] = c
-				case 0xff:
+			d[3] = 0xff
-					s := img.Pix[i : i+4 : i+4]
+			j += 4
-					d[0] = s[0]
+			i++
-					d[1] = s[1]
-					d[2] = s[2]
-					d[3] = a
-				default:
-					s := img.Pix[i : i+4 : i+4]
-					r16 := uint16(s[0])
-					g16 := uint16(s[1])
-					b16 := uint16(s[2])
-					a16 := uint16(a)
-					d[0] = uint8(r16 * 0xff / a16) // #nosec G115 -- Overflow desired.
-					d[1] = uint8(g16 * 0xff / a16) // #nosec G115 -- Overflow desired.
-					d[2] = uint8(b16 * 0xff / a16) // #nosec G115 -- Overflow desired.
-					d[3] = a
-				}
-				j += 4
-				i += 4
-			}
 		}
+	}
+}
 
-	case *image.RGBA64:
+func scanGray16(img *image.Gray16, x1, y1, x2, y2 int, dst []uint8) {
-		j := 0
+	if img == nil {
-		for y := y1; y < y2; y++ {
+		panic(gtserror.New("nil check elimination"))
-			i := y*img.Stride + x1*8
+	}
-			for x := x1; x < x2; x++ {
+	j := 0
-				s := img.Pix[i : i+8 : i+8]
+	for y := y1; y < y2; y++ {
-				d := dst[j : j+4 : j+4]
+		i := y*img.Stride + x1*2
-				a := s[6]
+		for x := x1; x < x2; x++ {
-				switch a {
+			c := img.Pix[i]
-				case 0:
+			d := dst[j : j+4 : j+4]
-					d[0] = 0
+			d[0] = c
-					d[1] = 0
+			d[1] = c
-					d[2] = 0
+			d[2] = c
-				case 0xff:
+			d[3] = 0xff
-					d[0] = s[0]
+			j += 4
-					d[1] = s[2]
+			i += 2
-					d[2] = s[4]
-				default:
-					r32 := uint32(s[0])<<8 | uint32(s[1])
-					g32 := uint32(s[2])<<8 | uint32(s[3])
-					b32 := uint32(s[4])<<8 | uint32(s[5])
-					a32 := uint32(s[6])<<8 | uint32(s[7])
-					d[0] = uint8((r32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
-					d[1] = uint8((g32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
-					d[2] = uint8((b32 * 0xffff / a32) >> 8) // #nosec G115 -- Overflow desired.
-				}
-				d[3] = a
-				j += 4
-				i += 8
-			}
 		}
+	}
+}
 
-	case *image.Gray:
+func scanYCbCr(img *image.YCbCr, x1, y1, x2, y2 int, dst []uint8) {
-		j := 0
+	j := 0
-		for y := y1; y < y2; y++ {
-			i := y*img.Stride + x1
-			for x := x1; x < x2; x++ {
-				c := img.Pix[i]
-				d := dst[j : j+4 : j+4]
-				d[0] = c
-				d[1] = c
-				d[2] = c
-				d[3] = 0xff
-				j += 4
-				i++
-			}
-		}
 
-	case *image.Gray16:
+	x1 += img.Rect.Min.X
-		j := 0
+	x2 += img.Rect.Min.X
-		for y := y1; y < y2; y++ {
+	y1 += img.Rect.Min.Y
-			i := y*img.Stride + x1*2
+	y2 += img.Rect.Min.Y
-			for x := x1; x < x2; x++ {
-				c := img.Pix[i]
-				d := dst[j : j+4 : j+4]
-				d[0] = c
-				d[1] = c
-				d[2] = c
-				d[3] = 0xff
-				j += 4
-				i += 2
-			}
-		}
 
-	case *image.YCbCr:
+	hy := img.Rect.Min.Y / 2
-		j := 0
+	hx := img.Rect.Min.X / 2
-		x1 += img.Rect.Min.X
-		x2 += img.Rect.Min.X
-		y1 += img.Rect.Min.Y
-		y2 += img.Rect.Min.Y
 
-		hy := img.Rect.Min.Y / 2
+	switch img.SubsampleRatio {
-		hx := img.Rect.Min.X / 2
+	case image.YCbCrSubsampleRatio420:
 		for y := y1; y < y2; y++ {
 			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
 
-			var yBase int
+			yBase := (y/2 - hy) * img.CStride
-			switch img.SubsampleRatio {
-			case image.YCbCrSubsampleRatio444, image.YCbCrSubsampleRatio422:
-				yBase = (y - img.Rect.Min.Y) * img.CStride
-			case image.YCbCrSubsampleRatio420, image.YCbCrSubsampleRatio440:
-				yBase = (y/2 - hy) * img.CStride
-			}
 
 			for x := x1; x < x2; x++ {
-				var ic int
+				ic := yBase + (x/2 - hx)
-				switch img.SubsampleRatio {
-				case image.YCbCrSubsampleRatio444, image.YCbCrSubsampleRatio440:
-					ic = yBase + (x - img.Rect.Min.X)
-				case image.YCbCrSubsampleRatio422, image.YCbCrSubsampleRatio420:
-					ic = yBase + (x/2 - hx)
-				default:
-					ic = img.COffset(x, y)
-				}
 
 				yy1 := int32(img.Y[iy]) * 0x10101
 				cb1 := int32(img.Cb[ic]) - 128
@@ -540,78 +550,296 @@ func (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) {
 			}
 		}
 
-	case *image.Paletted:
+	case image.YCbCrSubsampleRatio422:
-		j := 0
 		for y := y1; y < y2; y++ {
-			i := y*img.Stride + x1
+			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
+
+			yBase := (y - img.Rect.Min.Y) * img.CStride
+
 			for x := x1; x < x2; x++ {
-				c := s.palette[img.Pix[i]]
+				ic := yBase + (x/2 - hx)
+
+				yy1 := int32(img.Y[iy]) * 0x10101
+				cb1 := int32(img.Cb[ic]) - 128
+				cr1 := int32(img.Cr[ic]) - 128
+
+				r := yy1 + 91881*cr1
+				if uint32(r)&0xff000000 == 0 { //nolint:gosec
+					r >>= 16
+				} else {
+					r = ^(r >> 31)
+				}
+
+				g := yy1 - 22554*cb1 - 46802*cr1
+				if uint32(g)&0xff000000 == 0 { //nolint:gosec
+					g >>= 16
+				} else {
+					g = ^(g >> 31)
+				}
+
+				b := yy1 + 116130*cb1
+				if uint32(b)&0xff000000 == 0 { //nolint:gosec
+					b >>= 16
+				} else {
+					b = ^(b >> 31)
+				}
+
 				d := dst[j : j+4 : j+4]
-				d[0] = c.R
+				d[0] = uint8(r) // #nosec G115 -- Overflow desired.
-				d[1] = c.G
+				d[1] = uint8(g) // #nosec G115 -- Overflow desired.
-				d[2] = c.B
+				d[2] = uint8(b) // #nosec G115 -- Overflow desired.
-				d[3] = c.A
+				d[3] = 0xff
+
+				iy++
+				j += 4
+			}
+		}
+
+	case image.YCbCrSubsampleRatio440:
+		for y := y1; y < y2; y++ {
+			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
+
+			yBase := (y/2 - hy) * img.CStride
+
+			for x := x1; x < x2; x++ {
+				ic := yBase + (x - img.Rect.Min.X)
+
+				yy1 := int32(img.Y[iy]) * 0x10101
+				cb1 := int32(img.Cb[ic]) - 128
+				cr1 := int32(img.Cr[ic]) - 128
+
+				r := yy1 + 91881*cr1
+				if uint32(r)&0xff000000 == 0 { //nolint:gosec
+					r >>= 16
+				} else {
+					r = ^(r >> 31)
+				}
+
+				g := yy1 - 22554*cb1 - 46802*cr1
+				if uint32(g)&0xff000000 == 0 { //nolint:gosec
+					g >>= 16
+				} else {
+					g = ^(g >> 31)
+				}
+
+				b := yy1 + 116130*cb1
+				if uint32(b)&0xff000000 == 0 { //nolint:gosec
+					b >>= 16
+				} else {
+					b = ^(b >> 31)
+				}
+
+				d := dst[j : j+4 : j+4]
+				d[0] = uint8(r) // #nosec G115 -- Overflow desired.
+				d[1] = uint8(g) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(b) // #nosec G115 -- Overflow desired.
+				d[3] = 0xff
+
+				iy++
+				j += 4
+			}
+		}
+
+	case image.YCbCrSubsampleRatio444:
+		for y := y1; y < y2; y++ {
+			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
+
+			yBase := (y - img.Rect.Min.Y) * img.CStride
+
+			for x := x1; x < x2; x++ {
+				ic := yBase + (x - img.Rect.Min.X)
+
+				yy1 := int32(img.Y[iy]) * 0x10101
+				cb1 := int32(img.Cb[ic]) - 128
+				cr1 := int32(img.Cr[ic]) - 128
+
+				r := yy1 + 91881*cr1
+				if uint32(r)&0xff000000 == 0 { //nolint:gosec
+					r >>= 16
+				} else {
+					r = ^(r >> 31)
+				}
+
+				g := yy1 - 22554*cb1 - 46802*cr1
+				if uint32(g)&0xff000000 == 0 { //nolint:gosec
+					g >>= 16
+				} else {
+					g = ^(g >> 31)
+				}
+
+				b := yy1 + 116130*cb1
+				if uint32(b)&0xff000000 == 0 { //nolint:gosec
+					b >>= 16
+				} else {
+					b = ^(b >> 31)
+				}
+
+				d := dst[j : j+4 : j+4]
+				d[0] = uint8(r) // #nosec G115 -- Overflow desired.
+				d[1] = uint8(g) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(b) // #nosec G115 -- Overflow desired.
+				d[3] = 0xff
+
+				iy++
 				j += 4
-				i++
 			}
 		}
 
 	default:
-		j := 0
-		b := s.image.Bounds()
-		x1 += b.Min.X
-		x2 += b.Min.X
-		y1 += b.Min.Y
-		y2 += b.Min.Y
 		for y := y1; y < y2; y++ {
+			iy := (y-img.Rect.Min.Y)*img.YStride + (x1 - img.Rect.Min.X)
 			for x := x1; x < x2; x++ {
-				r16, g16, b16, a16 := s.image.At(x, y).RGBA()
+				ic := img.COffset(x, y)
-				d := dst[j : j+4 : j+4]
+
-				switch a16 {
+				yy1 := int32(img.Y[iy]) * 0x10101
-				case 0xffff:
+				cb1 := int32(img.Cb[ic]) - 128
-					d[0] = uint8(r16 >> 8) // #nosec G115 -- Overflow desired.
+				cr1 := int32(img.Cr[ic]) - 128
-					d[1] = uint8(g16 >> 8) // #nosec G115 -- Overflow desired.
+
-					d[2] = uint8(b16 >> 8) // #nosec G115 -- Overflow desired.
+				r := yy1 + 91881*cr1
-					d[3] = 0xff
+				if uint32(r)&0xff000000 == 0 { //nolint:gosec
-				case 0:
+					r >>= 16
-					d[0] = 0
+				} else {
-					d[1] = 0
+					r = ^(r >> 31)
-					d[2] = 0
-					d[3] = 0
-				default:
-					d[0] = uint8(((r16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
-					d[1] = uint8(((g16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
-					d[2] = uint8(((b16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
-					d[3] = uint8(a16 >> 8)                    // #nosec G115 -- Overflow desired.
 				}
+
+				g := yy1 - 22554*cb1 - 46802*cr1
+				if uint32(g)&0xff000000 == 0 { //nolint:gosec
+					g >>= 16
+				} else {
+					g = ^(g >> 31)
+				}
+
+				b := yy1 + 116130*cb1
+				if uint32(b)&0xff000000 == 0 { //nolint:gosec
+					b >>= 16
+				} else {
+					b = ^(b >> 31)
+				}
+
+				d := dst[j : j+4 : j+4]
+				d[0] = uint8(r) // #nosec G115 -- Overflow desired.
+				d[1] = uint8(g) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(b) // #nosec G115 -- Overflow desired.
+				d[3] = 0xff
+
+				iy++
 				j += 4
 			}
 		}
 	}
 }
 
+func scanPaletted(img *image.Paletted, x1, y1, x2, y2 int, dst []uint8) {
+	var palette [256]color.NRGBA
+	if len(palette) < len(img.Palette) {
+		panic(gtserror.New("bound check elimination"))
+	}
+	for i := 0; i < len(img.Palette); i++ {
+		palette[i] = colorToNRGBA(img.Palette[i])
+	}
+	j := 0
+	for y := y1; y < y2; y++ {
+		i := y*img.Stride + x1
+		for x := x1; x < x2; x++ {
+			c := palette[img.Pix[i]]
+			d := dst[j : j+4 : j+4]
+			d[0] = c.R
+			d[1] = c.G
+			d[2] = c.B
+			d[3] = c.A
+			j += 4
+			i++
+		}
+	}
+}
+
+// inlined from: image/color.NRGBAModel.Convert()
+func colorToNRGBA(c color.Color) color.NRGBA {
+	if c, ok := c.(color.NRGBA); ok {
+		return c
+	}
+	r, g, b, a := c.RGBA()
+	if a == 0xffff {
+		return color.NRGBA{
+			uint8(r >> 8), // #nosec G115 -- from stdlib
+			uint8(g >> 8), // #nosec G115 -- from stdlib
+			uint8(b >> 8), // #nosec G115 -- from stdlib
+			0xff,
+		}
+	}
+	if a == 0 {
+		return color.NRGBA{
+			0,
+			0,
+			0,
+			0,
+		}
+	}
+	// Since Color.RGBA returns an alpha-premultiplied color,
+	// we should have r <= a && g <= a && b <= a.
+	r = (r * 0xffff) / a
+	g = (g * 0xffff) / a
+	b = (b * 0xffff) / a
+	return color.NRGBA{
+		uint8(r >> 8), // #nosec G115 -- from stdlib
+		uint8(g >> 8), // #nosec G115 -- from stdlib
+		uint8(b >> 8), // #nosec G115 -- from stdlib
+		uint8(a >> 8), // #nosec G115 -- from stdlib
+	}
+}
+
+func scanAny(img image.Image, x1, y1, x2, y2 int, dst []uint8) {
+	j := 0
+	b := img.Bounds()
+	x1 += b.Min.X
+	x2 += b.Min.X
+	y1 += b.Min.Y
+	y2 += b.Min.Y
+	for y := y1; y < y2; y++ {
+		for x := x1; x < x2; x++ {
+			r16, g16, b16, a16 := img.At(x, y).RGBA()
+			d := dst[j : j+4 : j+4]
+			switch a16 {
+			case 0xffff:
+				d[0] = uint8(r16 >> 8) // #nosec G115 -- Overflow desired.
+				d[1] = uint8(g16 >> 8) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(b16 >> 8) // #nosec G115 -- Overflow desired.
+				d[3] = 0xff
+			case 0:
+				d[0] = 0
+				d[1] = 0
+				d[2] = 0
+				d[3] = 0
+			default:
+				d[0] = uint8(((r16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
+				d[1] = uint8(((g16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
+				d[2] = uint8(((b16 * 0xffff) / a16) >> 8) // #nosec G115 -- Overflow desired.
+				d[3] = uint8(a16 >> 8)                    // #nosec G115 -- Overflow desired.
+			}
+			j += 4
+		}
+	}
+}
+
 // reverse reverses the data
 // in contained pixel slice.
-func reverse(pix []uint8) {
+func reverse(pix8 []uint8) {
-	if len(pix) <= 4 {
+	if len(pix8) <= 4 || len(pix8)%4 != 0 {
 		return
 	}
-	i := 0
+	for i, j := 0, len(pix8)-4; i < j; i, j = i+4, j-4 {
-	j := len(pix) - 4
+		di := pix8[i : i+4 : i+4]
-	for i < j {
+		dj := pix8[j : j+4 : j+4]
-		pi := pix[i : i+4 : i+4]
+		di[0], dj[0] = dj[0], di[0]
-		pj := pix[j : j+4 : j+4]
+		di[1], dj[1] = dj[1], di[1]
-		pi[0], pj[0] = pj[0], pi[0]
+		di[2], dj[2] = dj[2], di[2]
-		pi[1], pj[1] = pj[1], pi[1]
+		di[3], dj[3] = dj[3], di[3]
-		pi[2], pj[2] = pj[2], pi[2]
-		pi[3], pj[3] = pj[3], pi[3]
-		i += 4
-		j -= 4
 	}
 }
 
-// clampFloat rounds and clamps float64 value to fit into uint8.
+// clampFloatTo8 rounds and clamps
-func clampFloat(x float64) uint8 {
+// float64 value to fit into uint8.
+func clampFloatTo8(x float64) uint8 {
 	v := int64(x + 0.5)
 	if v > 255 {
 		return 255

internal/media/imaging_test.go

@@ -0,0 +1,157 @@
+// 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 (
+	"fmt"
+	"image"
+	"image/gif"
+	"image/jpeg"
+	"image/png"
+	"io"
+	"path"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/image/webp"
+)
+
+func BenchmarkFlipH(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = flipH(img)
+	})
+}
+
+func BenchmarkFlipV(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = flipV(img)
+	})
+}
+
+func BenchmarkRotate90(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = rotate90(img)
+	})
+}
+
+func BenchmarkRotate180(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = rotate180(img)
+	})
+}
+
+func BenchmarkRotate270(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = rotate270(img)
+	})
+}
+
+func BenchmarkTranspose(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = transpose(img)
+	})
+}
+
+func BenchmarkTransverse(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = transverse(img)
+	})
+}
+
+func BenchmarkResizeHorizontalLinear(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = resizeHorizontalLinear(img, 64)
+	})
+}
+
+func BenchmarkResizeVerticalLinear(b *testing.B) {
+	benchmarkFunc(b, func(img image.Image) {
+		_ = resizeVerticalLinear(img, 64)
+	})
+}
+
+func benchmarkFunc(b *testing.B, fn func(image.Image)) {
+	b.Helper()
+	for _, testcase := range []struct {
+		Path   string
+		Decode func(io.Reader) (image.Image, error)
+	}{
+		{
+			Path:   "./test/big-panda.gif",
+			Decode: gif.Decode,
+		},
+		{
+			Path:   "./test/clock-original.gif",
+			Decode: gif.Decode,
+		},
+		{
+			Path:   "./test/test-jpeg.jpg",
+			Decode: jpeg.Decode,
+		},
+		{
+			Path:   "./test/test-png-noalphachannel.png",
+			Decode: png.Decode,
+		},
+		{
+			Path:   "./test/test-png-alphachannel.png",
+			Decode: png.Decode,
+		},
+		{
+			Path:   "./test/rainbow-original.png",
+			Decode: png.Decode,
+		},
+		{
+			Path:   "./test/nb-flag-original.webp",
+			Decode: webp.Decode,
+		},
+	} {
+		file, err := openRead(testcase.Path)
+		if err != nil {
+			panic(err)
+		}
+
+		img, err := testcase.Decode(file)
+		if err != nil {
+			panic(err)
+		}
+
+		info, err := file.Stat()
+		if err != nil {
+			panic(err)
+		}
+
+		file.Close()
+
+		testname := fmt.Sprintf("ext=%s type=%s size=%d",
+			strings.TrimPrefix(path.Ext(testcase.Path), "."),
+			strings.TrimPrefix(reflect.TypeOf(img).String(), "*image."),
+			info.Size(),
+		)
+
+		b.Run(testname, func(b *testing.B) {
+			b.Helper()
+			b.ResetTimer()
+			b.RunParallel(func(pb *testing.PB) {
+				for pb.Next() {
+					fn(img)
+				}
+			})
+		})
+	}
+}

internal/media/probe.go

@@ -138,17 +138,29 @@ func readOrientation(r *os.File) int {
 		orientationTag = 0x0112
 	)
 
-	// Setup a discard read buffer.
+	// Setup a read buffer.
-	buf := new(byteutil.Buffer)
+	var buf byteutil.Buffer
-	buf.Guarantee(32)
+	buf.B = make([]byte, 0, 64)
 
 	// discard simply reads into buf.
 	discard := func(n int) error {
-		buf.Guarantee(n) // ensure big enough
+		buf.Guarantee(n)
 		_, err := io.ReadFull(r, buf.B[:n])
 		return err
 	}
 
+	// readUint16 reads uint16 bytes into buffer then parses.
+	readUint16 := func(b binary.ByteOrder) (uint16, error) {
+		_, err := io.ReadFull(r, buf.B[:2])
+		return b.Uint16(buf.B[:2]), err
+	}
+
+	// readUint32 reads uint32 bytes into buffer then parses.
+	readUint32 := func(b binary.ByteOrder) (uint32, error) {
+		_, err := io.ReadFull(r, buf.B[:4])
+		return b.Uint32(buf.B[:4]), err
+	}
+
 	// Skip past JPEG SOI marker.
 	if err := discard(2); err != nil {
 		return orientationUnspecified
@@ -157,13 +169,13 @@ func readOrientation(r *os.File) int {
 	// Find JPEG
 	// APP1 marker.
 	for {
-		var marker, size uint16
+		marker, err := readUint16(binary.BigEndian)
-
+		if err != nil {
-		if err := binary.Read(r, binary.BigEndian, &marker); err != nil {
 			return orientationUnspecified
 		}
 
-		if err := binary.Read(r, binary.BigEndian, &size); err != nil {
+		size, err := readUint16(binary.BigEndian)
+		if err != nil {
 			return orientationUnspecified
 		}
 
@@ -184,11 +196,9 @@ func readOrientation(r *os.File) int {
 		}
 	}
 
-	// Check if EXIF
+	// Check if EXIF header is present.
-	// header is present.
+	header, err := readUint32(binary.BigEndian)
-	var header uint32
+	if err != nil {
-
-	if err := binary.Read(r, binary.BigEndian, &header); err != nil {
 		return orientationUnspecified
 	}
 
@@ -200,17 +210,13 @@ func readOrientation(r *os.File) int {
 		return orientationUnspecified
 	}
 
-	// Read byte
+	// Read byte order info.
-	// order info.
+	byteOrderTag, err := readUint16(binary.BigEndian)
-	var (
+	if err != nil {
-		byteOrderTag uint16
-		byteOrder    binary.ByteOrder
-	)
-
-	if err := binary.Read(r, binary.BigEndian, &byteOrderTag); err != nil {
 		return orientationUnspecified
 	}
 
+	var byteOrder binary.ByteOrder
 	switch byteOrderTag {
 	case byteOrderBE:
 		byteOrder = binary.BigEndian
@@ -224,11 +230,9 @@ func readOrientation(r *os.File) int {
 		return orientationUnspecified
 	}
 
-	// Skip the
+	// Skip the EXIF offset.
-	// EXIF offset.
+	offset, err := readUint32(byteOrder)
-	var offset uint32
+	if err != nil {
-
-	if err := binary.Read(r, byteOrder, &offset); err != nil {
 		return orientationUnspecified
 	}
 
@@ -240,19 +244,16 @@ func readOrientation(r *os.File) int {
 		return orientationUnspecified
 	}
 
-	// Read the
+	// Read the number of tags.
-	// number of tags.
+	numTags, err := readUint16(byteOrder)
-	var numTags uint16
+	if err != nil {
-
-	if err := binary.Read(r, byteOrder, &numTags); err != nil {
 		return orientationUnspecified
 	}
 
 	// Find the orientation tag.
 	for i := 0; i < int(numTags); i++ {
-		var tag uint16
+		tag, err := readUint16(byteOrder)
-
+		if err != nil {
-		if err := binary.Read(r, byteOrder, &tag); err != nil {
 			return orientationUnspecified
 		}
 
@@ -267,9 +268,8 @@ func readOrientation(r *os.File) int {
 			return orientationUnspecified
 		}
 
-		var val uint16
+		val, err := readUint16(byteOrder)
-
+		if err != nil {
-		if err := binary.Read(r, byteOrder, &val); err != nil {
 			return orientationUnspecified
 		}
 

internal/media/processingemoji.go

@@ -44,11 +44,6 @@ type ProcessingEmoji struct {
 	mgr       *Manager          // mgr instance (access to db / storage)
 }
 
-// ID returns the ID of the underlying emoji.
-func (p *ProcessingEmoji) ID() string {
-	return p.emoji.ID // immutable, safe outside mutex.
-}
-
 // LoadEmoji blocks until the static and fullsize image has been processed, and then returns the completed emoji.
 func (p *ProcessingEmoji) Load(ctx context.Context) (*gtsmodel.Emoji, error) {
 	emoji, done, err := p.load(ctx)
@@ -63,6 +58,33 @@ func (p *ProcessingEmoji) Load(ctx context.Context) (*gtsmodel.Emoji, error) {
 	return emoji, err
 }
 
+func (p *ProcessingEmoji) LoadAsync(deferred func()) *gtsmodel.Emoji {
+	p.mgr.state.Workers.Dereference.Queue.Push(func(ctx context.Context) {
+		if deferred != nil {
+			defer deferred()
+		}
+
+		if _, _, err := p.load(ctx); err != nil {
+			log.Errorf(ctx, "error loading emoji: %v", err)
+		}
+	})
+
+	// Placeholder returns a copy of internally stored processing placeholder,
+	// returning only the fields that may be known *before* completion,
+	// and as such all fields which are safe to concurrently read.
+	placeholder := new(gtsmodel.Emoji)
+	placeholder.ID = p.emoji.ID
+	placeholder.Shortcode = p.emoji.Shortcode
+	placeholder.Domain = p.emoji.Domain
+	placeholder.Cached = new(bool)
+	placeholder.ImageRemoteURL = p.emoji.ImageRemoteURL
+	placeholder.ImageStaticRemoteURL = p.emoji.ImageStaticRemoteURL
+	placeholder.Disabled = p.emoji.Disabled
+	placeholder.VisibleInPicker = p.emoji.VisibleInPicker
+	placeholder.CategoryID = p.emoji.CategoryID
+	return placeholder
+}
+
 // load is the package private form of load() that is wrapped to catch context canceled.
 func (p *ProcessingEmoji) load(ctx context.Context) (
 	emoji *gtsmodel.Emoji,

internal/middleware/ratelimit.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"code.superseriousbusiness.org/gotosocial/internal/gtserror"
+	"code.superseriousbusiness.org/gotosocial/internal/log"
 	"code.superseriousbusiness.org/gotosocial/internal/util"
 	"github.com/gin-gonic/gin"
 	"github.com/ulule/limiter/v3"
@@ -78,30 +79,43 @@ func RateLimit(limit int, except []netip.Prefix) gin.HandlerFunc {
 		// Use Gin's heuristic for determining
 		// clientIP, which accounts for reverse
 		// proxies and trusted proxies setting.
-		clientIP := netip.MustParseAddr(c.ClientIP())
+		clientIP := c.ClientIP()
+
+		// ClientIP must be parseable.
+		ip, err := netip.ParseAddr(clientIP)
+		if err != nil {
+			log.Warnf(
+				c.Request.Context(),
+				"cannot do rate limiting for this request as client IP %s could not be parsed;"+
+					" your upstream reverse proxy may be misconfigured: %v",
+				err,
+			)
+			c.Next()
+			return
+		}
 
 		// Check if this IP is exempt from rate
 		// limits and skip further checks if so.
 		for _, prefix := range except {
-			if prefix.Contains(clientIP) {
+			if prefix.Contains(ip) {
 				c.Next()
 				return
 			}
 		}
 
-		if clientIP.Is6() {
+		if ip.Is6() {
 			// Convert to "net" package IP for mask.
-			asIP := net.IP(clientIP.AsSlice())
+			asIP := net.IP(ip.AsSlice())
 
 			// Apply coarse IPv6 mask.
 			asIP = asIP.Mask(ipv6Mask)
 
 			// Convert back to netip.Addr from net.IP.
-			clientIP, _ = netip.AddrFromSlice(asIP)
+			ip, _ = netip.AddrFromSlice(asIP)
 		}
 
 		// Fetch rate limit info for this (masked) clientIP.
-		context, err := limiter.Get(c, clientIP.String())
+		context, err := limiter.Get(c, ip.String())
 		if err != nil {
 			// Since we use an in-memory cache now,
 			// it's actually impossible for this to

internal/processing/admin/emoji.go

@@ -293,6 +293,7 @@ func (p *Processor) emojiUpdateCopy(
 	// Ensure target emoji is locally cached.
 	target, err := p.federator.RecacheEmoji(ctx,
 		target,
+		false,
 	)
 	if err != nil {
 		err := gtserror.Newf("error recaching emoji %s: %w", target.ImageRemoteURL, err)

internal/processing/media/getfile.go

@@ -247,6 +247,7 @@ func (p *Processor) getEmojiContent(
 	emoji, err = p.federator.RecacheEmoji(
 		ctx,
 		emoji,
+		false,
 	)
 	if err != nil {
 		err := gtserror.Newf("error recaching emoji: %w", err)

internal/typeutils/internaltoas.go

@@ -2438,8 +2438,8 @@ func (c *Converter) InteractionReqToASAuthorization(
 }
 
 // appendASInteractionAuthorization is a utility function
-// that sets `approvedBy`, and `likeAuthorization`,
+// that sets `approvedBy`, and (if possible) `likeAuthorization`,
-// `replyAuthorization`, or `announceAuthorization`.
+// `replyAuthorization`, and/or `announceAuthorization`.
 func (c *Converter) appendASInteractionAuthorization(
 	ctx context.Context,
 	approvedByURIStr string,
@@ -2458,11 +2458,28 @@ func (c *Converter) appendASInteractionAuthorization(
 		gtscontext.SetBarebones(ctx),
 		approvedByURIStr,
 	)
-	if err != nil {
+	if err != nil && !errors.Is(err, db.ErrNoEntries) {
 		return gtserror.Newf("db error checking for int req: %w", err)
 	}
 
-	// Make sure it's actually accepted.
+	// If the interaction request is nil,
+	// that means we originally sent out
+	// the interaction request impolitely,
+	// and it was accepted impolitely.
+	// Ie., behavior from <= v0.20.0.
+	//
+	// If this is so, just set `approvedBy`
+	// to given approvedByURIStr and bail,
+	// as there's nothing else we can do.
+	if intReq == nil {
+		if wap, ok := t.(ap.WithApprovedBy); ok {
+			ap.SetApprovedBy(wap, approvedByURI)
+		}
+		return nil
+	}
+
+	// Make sure interaction request
+	// has actually been accepted.
 	if !intReq.IsAccepted() {
 		return gtserror.Newf(
 			"approvedByURIStr %s corresponded to not-accepted interaction request %s",