gtsocial-umbx

scanner.go (5604B)

---

 package imaging
 
 import (
 	"image"
 	"image/color"
 )
 
 type scanner struct {
 	image   image.Image
 	w, h    int
 	palette []color.NRGBA
 }
 
 func newScanner(img image.Image) *scanner {
 	s := &scanner{
 		image: img,
 		w:     img.Bounds().Dx(),
 		h:     img.Bounds().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)
 		}
 	}
 	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]
 				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
 			}
 		}
 
 	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]
 				d[0] = s[0]
 				d[1] = s[2]
 				d[2] = s[4]
 				d[3] = s[6]
 				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)
 					d[1] = uint8(g16 * 0xff / a16)
 					d[2] = uint8(b16 * 0xff / a16)
 					d[3] = a
 				}
 				j += 4
 				i += 4
 			}
 		}
 
 	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)
 					d[1] = uint8((g32 * 0xffff / a32) >> 8)
 					d[2] = uint8((b32 * 0xffff / a32) >> 8)
 				}
 				d[3] = a
 				j += 4
 				i += 8
 			}
 		}
 
 	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++
 			}
 		}
 
 	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
 			}
 		}
 
 	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
 		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
 			}
 
 			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)
 				}
 
 				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 {
 					r >>= 16
 				} else {
 					r = ^(r >> 31)
 				}
 
 				g := yy1 - 22554*cb1 - 46802*cr1
 				if uint32(g)&0xff000000 == 0 {
 					g >>= 16
 				} else {
 					g = ^(g >> 31)
 				}
 
 				b := yy1 + 116130*cb1
 				if uint32(b)&0xff000000 == 0 {
 					b >>= 16
 				} else {
 					b = ^(b >> 31)
 				}
 
 				d := dst[j : j+4 : j+4]
 				d[0] = uint8(r)
 				d[1] = uint8(g)
 				d[2] = uint8(b)
 				d[3] = 0xff
 
 				iy++
 				j += 4
 			}
 		}
 
 	case *image.Paletted:
 		j := 0
 		for y := y1; y < y2; y++ {
 			i := y*img.Stride + x1
 			for x := x1; x < x2; x++ {
 				c := s.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++
 			}
 		}
 
 	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++ {
 			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)
 					d[1] = uint8(g16 >> 8)
 					d[2] = uint8(b16 >> 8)
 					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)
 					d[1] = uint8(((g16 * 0xffff) / a16) >> 8)
 					d[2] = uint8(((b16 * 0xffff) / a16) >> 8)
 					d[3] = uint8(a16 >> 8)
 				}
 				j += 4
 			}
 		}
 	}
 }