From baf2c54730c4740e5603198fade7da34a4956c7a Mon Sep 17 00:00:00 2001 From: kim Date: Wed, 8 Oct 2025 11:12:12 +0200 Subject: [PATCH] [performance] add benchmarks for native Go imaging code, small tweaks to reduce nil and boundary checks, some loop unrolling (#4482) Reviewed-on: https://codeberg.org/superseriousbusiness/gotosocial/pulls/4482 Co-authored-by: kim Co-committed-by: kim --- internal/media/imaging.go | 762 +++++++++++++++++++++------------ internal/media/imaging_test.go | 157 +++++++ internal/media/probe.go | 74 ++-- 3 files changed, 689 insertions(+), 304 deletions(-) create mode 100644 internal/media/imaging_test.go diff --git a/internal/media/imaging.go b/internal/media/imaging.go index 6a0fa694c..d575a37f7 100644 --- a/internal/media/imaging.go +++ b/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) - dstW := src.w - dstH := src.h + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcW + 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) - dstW := src.w - dstH := src.h + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcW + 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) - dstW := src.h - dstH := src.w + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcH + 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) - dstW := src.w - dstH := src.h + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcW + 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) - dstW := src.h - dstH := src.w + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcH + 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) - dstW := src.h - dstH := src.w + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcH + 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) - dstW := src.h - dstH := src.w + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dstW := srcH + 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) - dst := image.NewRGBA(image.Rect(0, 0, dstWidth, src.h)) - weights := precomputeWeightsLinear(dstWidth, src.w) - scanLine := make([]uint8, src.w*4) - for y := 0; y < src.h; y++ { - src.scan(0, y, src.w, y+1, scanLine) + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dst := image.NewRGBA(image.Rect(0, 0, dstWidth, srcH)) + weights := precomputeWeightsLinear(dstWidth, srcW) + scanLine := make([]uint8, srcW*4) + for y := 0; y < srcH; y++ { + 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[1] = clampFloat(g * aInv) - d[2] = clampFloat(b * aInv) - d[3] = clampFloat(a) + d[0] = clampFloatTo8(r / a) + d[1] = clampFloatTo8(g / a) + d[2] = clampFloatTo8(b / 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) - dst := image.NewNRGBA(image.Rect(0, 0, src.w, height)) - weights := precomputeWeightsLinear(height, src.h) - scanLine := make([]uint8, src.h*4) - for x := 0; x < src.w; x++ { - src.scan(x, 0, x+1, src.h, scanLine) + srcW, srcH := img.Bounds().Dx(), img.Bounds().Dy() + dst := image.NewNRGBA(image.Rect(0, 0, srcW, height)) + weights := precomputeWeightsLinear(height, srcH) + scanLine := make([]uint8, srcH*4) + for x := 0; x < srcW; x++ { + 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[1] = clampFloat(g * aInv) - d[2] = clampFloat(b * aInv) - d[3] = clampFloat(a) + d[0] = clampFloatTo8(r / a) + d[1] = clampFloatTo8(g / a) + d[2] = clampFloatTo8(b / 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 -// easier size access and image type -// agnostic access to data at coords. -type scanner struct { - image image.Image - w, h int - palette []color.NRGBA +// scan scans the given rectangular region of the image into dst. +func scanImage(img image.Image, x1, y1, x2, y2 int, dst []uint8) { + switch img := img.(type) { + case *image.NRGBA: + scanNRGBA(img, x1, y1, x2, y2, dst) + case *image.NRGBA64: + 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 newScanner(img image.Image) *scanner { - b := img.Bounds() - s := &scanner{ - image: img, - - w: b.Dx(), - h: b.Dy(), - } - if img, ok := img.(*image.Paletted); ok { - s.palette = make([]color.NRGBA, len(img.Palette)) - for i := 0; i < len(img.Palette); i++ { - s.palette[i] = color.NRGBAModel.Convert(img.Palette[i]).(color.NRGBA) +func scanNRGBA(img *image.NRGBA, x1, y1, x2, y2 int, dst []uint8) { + size := (x2 - x1) * 4 + j := 0 + i := y1*img.Stride + x1*4 + if size == 4 { + for y := y1; y < y2; y++ { + d := dst[j : j+4 : j+4] + s := img.Pix[i : i+4 : i+4] + d[0] = s[0] + d[1] = s[1] + d[2] = s[2] + d[3] = s[3] + 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 (s *scanner) scan(x1, y1, x2, y2 int, dst []uint8) { - switch img := s.image.(type) { - case *image.NRGBA: - size := (x2 - x1) * 4 - j := 0 - i := y1*img.Stride + x1*4 - if size == 4 { - for y := y1; y < y2; y++ { - d := dst[j : j+4 : j+4] +func scanNRGBA64(img *image.NRGBA64, 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*8 + for x := x1; x < x2; x++ { + s := img.Pix[i : i+8 : i+8] + 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] - 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 + 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.NRGBA64: - j := 0 - for y := y1; y < y2; y++ { - 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] +func scanRGBA64(img *image.RGBA64, 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*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] - j += 4 - i += 8 + 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.RGBA: - 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] = 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 - } +func scanGray(img *image.Gray, 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 + 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.RGBA64: - j := 0 - for y := y1; y < y2; y++ { - 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] - 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 - } +func scanGray16(img *image.Gray16, 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*2 + 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.Gray: - 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++ - } - } +func scanYCbCr(img *image.YCbCr, x1, y1, x2, y2 int, dst []uint8) { + j := 0 - case *image.Gray16: - j := 0 - for y := y1; y < y2; y++ { - i := y*img.Stride + x1*2 - 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 - } - } + x1 += img.Rect.Min.X + x2 += img.Rect.Min.X + y1 += img.Rect.Min.Y + y2 += img.Rect.Min.Y - case *image.YCbCr: - j := 0 - 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 + hx := img.Rect.Min.X / 2 - hy := img.Rect.Min.Y / 2 - hx := img.Rect.Min.X / 2 + switch img.SubsampleRatio { + 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 - 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 - } + yBase := (y/2 - hy) * img.CStride for x := x1; x < x2; x++ { - var ic int - 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) - } + ic := yBase + (x/2 - hx) 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: - j := 0 + case image.YCbCrSubsampleRatio422: 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[1] = c.G - d[2] = c.B - d[3] = c.A + 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.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() - 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. + ic := img.COffset(x, y) + + 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 } } } } +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) { - if len(pix) <= 4 { +func reverse(pix8 []uint8) { + if len(pix8) <= 4 || len(pix8)%4 != 0 { return } - i := 0 - j := len(pix) - 4 - for i < j { - pi := pix[i : i+4 : i+4] - pj := pix[j : j+4 : j+4] - pi[0], pj[0] = pj[0], pi[0] - pi[1], pj[1] = pj[1], pi[1] - pi[2], pj[2] = pj[2], pi[2] - pi[3], pj[3] = pj[3], pi[3] - i += 4 - j -= 4 + for i, j := 0, len(pix8)-4; i < j; i, j = i+4, j-4 { + di := pix8[i : i+4 : i+4] + dj := pix8[j : j+4 : j+4] + di[0], dj[0] = dj[0], di[0] + di[1], dj[1] = dj[1], di[1] + di[2], dj[2] = dj[2], di[2] + di[3], dj[3] = dj[3], di[3] } } -// clampFloat rounds and clamps float64 value to fit into uint8. -func clampFloat(x float64) uint8 { +// clampFloatTo8 rounds and clamps +// float64 value to fit into uint8. +func clampFloatTo8(x float64) uint8 { v := int64(x + 0.5) if v > 255 { return 255 diff --git a/internal/media/imaging_test.go b/internal/media/imaging_test.go new file mode 100644 index 000000000..f46268a7b --- /dev/null +++ b/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 . + +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) + } + }) + }) + } +} diff --git a/internal/media/probe.go b/internal/media/probe.go index c66254b90..5c07b04fb 100644 --- a/internal/media/probe.go +++ b/internal/media/probe.go @@ -138,17 +138,29 @@ func readOrientation(r *os.File) int { orientationTag = 0x0112 ) - // Setup a discard read buffer. - buf := new(byteutil.Buffer) - buf.Guarantee(32) + // Setup a read buffer. + var buf byteutil.Buffer + 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 - - if err := binary.Read(r, binary.BigEndian, &marker); err != nil { + marker, err := readUint16(binary.BigEndian) + if 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 - // header is present. - var header uint32 - - if err := binary.Read(r, binary.BigEndian, &header); err != nil { + // Check if EXIF header is present. + header, err := readUint32(binary.BigEndian) + if err != nil { return orientationUnspecified } @@ -200,17 +210,13 @@ func readOrientation(r *os.File) int { return orientationUnspecified } - // Read byte - // order info. - var ( - byteOrderTag uint16 - byteOrder binary.ByteOrder - ) - - if err := binary.Read(r, binary.BigEndian, &byteOrderTag); err != nil { + // Read byte order info. + byteOrderTag, err := readUint16(binary.BigEndian) + if 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 - // EXIF offset. - var offset uint32 - - if err := binary.Read(r, byteOrder, &offset); err != nil { + // Skip the EXIF offset. + offset, err := readUint32(byteOrder) + if err != nil { return orientationUnspecified } @@ -240,19 +244,16 @@ func readOrientation(r *os.File) int { return orientationUnspecified } - // Read the - // number of tags. - var numTags uint16 - - if err := binary.Read(r, byteOrder, &numTags); err != nil { + // Read the number of tags. + numTags, err := readUint16(byteOrder) + if err != nil { return orientationUnspecified } // Find the orientation tag. for i := 0; i < int(numTags); i++ { - var tag uint16 - - if err := binary.Read(r, byteOrder, &tag); err != nil { + tag, err := readUint16(byteOrder) + if err != nil { return orientationUnspecified } @@ -267,9 +268,8 @@ func readOrientation(r *os.File) int { return orientationUnspecified } - var val uint16 - - if err := binary.Read(r, byteOrder, &val); err != nil { + val, err := readUint16(byteOrder) + if err != nil { return orientationUnspecified }