PasteFerry (隔空贴): clipboard and file sync across macOS, Windows and Linux. Direct-first, end-to-end encrypted. Optional official access: no server to host. Independent self-hosting remains available.
Dart airdrop-alternativeclipboardclipboard-sharingclipboard-synccopy-pastecross-platformend-to-end-encryptionfile-syncfile-transferfluttergolanglinuxmacosnat-traversalp2pself-hostedtailscaleuniversal-clipboardwebrtcwindows
package theme
import (
"bytes"
"crypto/sha256"
"encoding/binary"
"encoding/hex"
"errors"
"image"
"image/color"
"image/draw"
_ "image/gif" // 注册 GIF 解码器:动图只取第一帧
"image/jpeg"
"image/png"
"io"
"math"
"os"
"path/filepath"
"regexp"
"sort"
"strings"
"github.com/baiyuze/pasteferry/client-core/internal/imagepreview"
)
// 背景图(design/themes.md 第 7 节)。只用 Go 自带的解码器(内存安全):PNG、JPEG、GIF;
// HEIC、TIFF 在 Mac 上先由系统转成 PNG。重新编码时 EXIF 等元数据都不写回去——照片里常有 GPS 坐标,
// 分享主题时不能把位置带出去;拍摄方向先按 EXIF 转正。
const (
maxBackgroundSource = 20 << 20 // 输入最大 20 MB
maxBackgroundPixels = 64 << 20 // 愿意解码的最大像素数
maxBackgroundSide = 3840 // 存下来的长边上限
blurredSide = 960 // 模糊版的长边
tileSide = 512 // 不超过这么大的 PNG 当作平铺小图(像素画),原样保留 PNG
)
var ErrNotImage = errors.New("不是能处理的图片(支持 PNG、JPEG、GIF)")
var shaRef = regexp.MustCompile(`^[0-9a-f]{64}$`)
// BackgroundInfo 是导入后的背景图与它的分析结果
type BackgroundInfo struct {
SHA256 string
Width, Height int
Format string // jpeg、png
Luminance float64
LuminanceSpread float64
Colors []string
MinScrimDark float64
MinScrimLight float64
}
// ImportBackground 导入一张背景图:data 为空时读 path。同一张图导入两次得到同一个 sha256
func (s *Store) ImportBackground(data []byte, path string) (BackgroundInfo, error) {
if len(data) == 0 {
var err error
if data, err = readImageFile(path); err != nil {
return BackgroundInfo{}, err
}
}
if len(data) > maxBackgroundSource {
return BackgroundInfo{}, ErrNotImage
}
cfg, format, err := image.DecodeConfig(bytes.NewReader(data))
if err != nil || cfg.Width <= 0 || cfg.Height <= 0 || int64(cfg.Width)*int64(cfg.Height) > maxBackgroundPixels {
return BackgroundInfo{}, ErrNotImage
}
src, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return BackgroundInfo{}, ErrNotImage
}
img := toRGBA(src)
if format == "jpeg" {
img = orient(img, jpegOrientation(data))
}
var main []byte
outFormat := "jpeg"
w, h := img.Rect.Dx(), img.Rect.Dy()
if format == "png" && w <= tileSide && h <= tileSide {
outFormat = "png"
if main, err = encodePNG(img); err != nil {
return BackgroundInfo{}, err
}
} else {
if w, h = fitInside(w, h, maxBackgroundSide); w != img.Rect.Dx() || h != img.Rect.Dy() {
img = scale(img, w, h)
}
if main, err = encodeJPEG(onWhite(img), 88); err != nil {
return BackgroundInfo{}, err
}
}
sum := sha256.Sum256(main)
sha := hex.EncodeToString(sum[:])
bw, bh := fitInside(w, h, blurredSide)
blurred := blur(onWhite(scale(img, bw, bh)), max(2, bw/80))
blurData, err := encodeJPEG(blurred, 80)
if err != nil {
return BackgroundInfo{}, err
}
s.mu.Lock()
defer s.mu.Unlock()
if err := os.MkdirAll(s.backgrounds, 0o700); err != nil {
return BackgroundInfo{}, err
}
if err := writeAtomic(s.backgroundPath(sha, outFormat, false), main); err != nil {
return BackgroundInfo{}, err
}
if err := writeAtomic(s.backgroundPath(sha, "jpeg", true), blurData); err != nil {
return BackgroundInfo{}, err
}
info := analyze(img)
info.SHA256, info.Width, info.Height, info.Format = sha, w, h, outFormat
return info, nil
}
func (s *Store) backgroundPath(sha, format string, blurred bool) string {
switch {
case blurred:
return filepath.Join(s.backgrounds, sha+".blur.jpg")
case format == "png":
return filepath.Join(s.backgrounds, sha+".png")
default:
return filepath.Join(s.backgrounds, sha+".jpg")
}
}
// Background 返回背景图的字节与格式
func (s *Store) Background(sha string, blurred bool) ([]byte, string, error) {
if !shaRef.MatchString(sha) {
return nil, "", ErrNotFound
}
if blurred {
data, err := os.ReadFile(s.backgroundPath(sha, "jpeg", true))
if errors.Is(err, os.ErrNotExist) {
return nil, "", ErrNotFound
}
return data, "jpeg", err
}
for _, f := range []string{"jpeg", "png"} {
data, err := os.ReadFile(s.backgroundPath(sha, f, false))
if err == nil {
return data, f, nil
}
if !errors.Is(err, os.ErrNotExist) {
return nil, "", err
}
}
return nil, "", ErrNotFound
}
// AnalyzeBackground 重新分析一张已导入的背景图。分析的是保存下来的文件(重新编码过),
// 结果与导入时的可能差一点点
func (s *Store) AnalyzeBackground(sha string) (BackgroundInfo, error) {
data, format, err := s.Background(sha, false)
if err != nil {
return BackgroundInfo{}, err
}
src, _, err := image.Decode(bytes.NewReader(data))
if err != nil {
return BackgroundInfo{}, ErrNotImage
}
img := toRGBA(src)
info := analyze(img)
info.SHA256, info.Width, info.Height, info.Format = sha, img.Rect.Dx(), img.Rect.Dy(), format
return info, nil
}
func (s *Store) hasBackground(sha string) bool {
for _, f := range []string{"jpeg", "png"} {
if _, err := os.Stat(s.backgroundPath(sha, f, false)); err == nil {
return true
}
}
return false
}
// DeleteBackground 删掉一张背景图;还有自定义主题引用它时返回 ErrInUse
func (s *Store) DeleteBackground(sha string) error {
if !shaRef.MatchString(sha) {
return ErrNotFound
}
s.mu.Lock()
defer s.mu.Unlock()
if !s.hasBackground(sha) {
return ErrNotFound
}
infos, err := s.List()
if err != nil {
return err
}
for _, info := range infos {
if info.Builtin {
continue
}
t, _, err := s.load(info.ID)
if err != nil {
continue
}
for _, img := range s.userImages(t) {
if img == sha {
return ErrInUse
}
}
}
for _, p := range []string{s.backgroundPath(sha, "jpeg", false), s.backgroundPath(sha, "png", false), s.backgroundPath(sha, "jpeg", true)} {
if err := os.Remove(p); err != nil && !errors.Is(err, os.ErrNotExist) {
return err
}
}
return nil
}
// ─────────────────────────── 图片处理 ───────────────────────────
func readImageFile(path string) ([]byte, error) {
if path == "" || !imagepreview.Previewable(path) {
return nil, ErrNotImage
}
src, err := imagepreview.Prepare(path)
if err != nil {
return nil, ErrNotImage
}
switch strings.ToLower(filepath.Ext(src)) {
case ".png", ".jpg", ".jpeg", ".gif":
default:
return nil, ErrNotImage
}
f, err := os.Open(src)
if err != nil {
return nil, err
}
defer f.Close()
data, err := io.ReadAll(io.LimitReader(f, maxBackgroundSource+1))
if err != nil {
return nil, err
}
if len(data) > maxBackgroundSource {
return nil, ErrNotImage
}
return data, nil
}
func toRGBA(src image.Image) *image.RGBA {
b := src.Bounds()
dst := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
draw.Draw(dst, dst.Rect, src, b.Min, draw.Src)
return dst
}
// jpegOrientation 读 JPEG 里 EXIF 的拍摄方向(1 到 8),读不到时是 1
func jpegOrientation(data []byte) int {
if len(data) < 4 || data[0] != 0xFF || data[1] != 0xD8 {
return 1
}
i := 2
for i+4 <= len(data) {
if data[i] != 0xFF {
return 1
}
marker := data[i+1]
if marker == 0xDA || marker == 0xD9 { // 图像数据开始了,后面不会再有 EXIF
return 1
}
size := int(binary.BigEndian.Uint16(data[i+2:]))
if size < 2 || i+2+size > len(data) {
return 1
}
seg := data[i+4 : i+2+size]
if marker == 0xE1 && len(seg) > 14 && string(seg[:6]) == "Exif\x00\x00" {
return tiffOrientation(seg[6:])
}
i += 2 + size
}
return 1
}
func tiffOrientation(t []byte) int {
if len(t) < 8 {
return 1
}
var bo binary.ByteOrder
switch string(t[:2]) {
case "II":
bo = binary.LittleEndian
case "MM":
bo = binary.BigEndian
default:
return 1
}
off := int(bo.Uint32(t[4:]))
if off+2 > len(t) {
return 1
}
n := int(bo.Uint16(t[off:]))
for k := 0; k < n; k++ {
e := off + 2 + k*12
if e+12 > len(t) {
return 1
}
if bo.Uint16(t[e:]) == 0x0112 {
if v := int(bo.Uint16(t[e+8:])); v >= 1 && v <= 8 {
return v
}
return 1
}
}
return 1
}
// orient 按 EXIF 方向把图转正
func orient(src *image.RGBA, o int) *image.RGBA {
if o <= 1 || o > 8 {
return src
}
w, h := src.Rect.Dx(), src.Rect.Dy()
dw, dh := w, h
if o >= 5 {
dw, dh = h, w
}
dst := image.NewRGBA(image.Rect(0, 0, dw, dh))
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
var dx, dy int
switch o {
case 2:
dx, dy = w-1-x, y
case 3:
dx, dy = w-1-x, h-1-y
case 4:
dx, dy = x, h-1-y
case 5:
dx, dy = y, x
case 6:
dx, dy = h-1-y, x
case 7:
dx, dy = h-1-y, w-1-x
case 8:
dx, dy = y, w-1-x
}
dst.SetRGBA(dx, dy, src.RGBAAt(x, y))
}
}
return dst
}
// fitInside 是把 w×h 缩到长边不超过 limit 后的尺寸(不放大)
func fitInside(w, h, limit int) (int, int) {
if w <= limit && h <= limit {
return w, h
}
if w >= h {
return limit, max(1, h*limit/w)
}
return max(1, w*limit/h), limit
}
// scale 缩放到 w×h:缩小时按区域取平均(盒式滤波),放大时取最近的像素
func scale(src *image.RGBA, w, h int) *image.RGBA {
r := src.Rect
dst := image.NewRGBA(image.Rect(0, 0, w, h))
sw, sh := r.Dx(), r.Dy()
for dy := 0; dy < h; dy++ {
y0, y1 := dy*sh/h, (dy+1)*sh/h
if y1 <= y0 {
y1 = y0 + 1
}
for dx := 0; dx < w; dx++ {
x0, x1 := dx*sw/w, (dx+1)*sw/w
if x1 <= x0 {
x1 = x0 + 1
}
var rs, gs, bs, as, n uint32
for yy := y0; yy < y1; yy++ {
for xx := x0; xx < x1; xx++ {
c := src.RGBAAt(xx, yy)
rs, gs, bs, as = rs+uint32(c.R), gs+uint32(c.G), bs+uint32(c.B), as+uint32(c.A)
n++
}
}
dst.SetRGBA(dx, dy, color.RGBA{uint8(rs / n), uint8(gs / n), uint8(bs / n), uint8(as / n)})
}
}
return dst
}
// blur 三遍盒式模糊,接近高斯模糊
func blur(img *image.RGBA, radius int) *image.RGBA {
for range 3 {
img = boxBlur(img, radius, true)
img = boxBlur(img, radius, false)
}
return img
}
func boxBlur(src *image.RGBA, r int, horizontal bool) *image.RGBA {
w, h := src.Rect.Dx(), src.Rect.Dy()
dst := image.NewRGBA(src.Rect)
lines, length := h, w
if !horizontal {
lines, length = w, h
}
at := func(line, i int) color.RGBA {
i = min(max(i, 0), length-1)
if horizontal {
return src.RGBAAt(i, line)
}
return src.RGBAAt(line, i)
}
n := uint32(2*r + 1)
for line := 0; line < lines; line++ {
var rs, gs, bs, as uint32
for i := -r; i <= r; i++ {
c := at(line, i)
rs, gs, bs, as = rs+uint32(c.R), gs+uint32(c.G), bs+uint32(c.B), as+uint32(c.A)
}
for i := 0; i < length; i++ {
out := color.RGBA{uint8(rs / n), uint8(gs / n), uint8(bs / n), uint8(as / n)}
if horizontal {
dst.SetRGBA(i, line, out)
} else {
dst.SetRGBA(line, i, out)
}
in, gone := at(line, i+r+1), at(line, i-r)
rs += uint32(in.R) - uint32(gone.R)
gs += uint32(in.G) - uint32(gone.G)
bs += uint32(in.B) - uint32(gone.B)
as += uint32(in.A) - uint32(gone.A)
}
}
return dst
}
// onWhite 把透明的部分垫上白色(JPEG 没有透明)
func onWhite(img *image.RGBA) *image.RGBA {
for i := 0; i+3 < len(img.Pix); i += 4 {
a := uint32(img.Pix[i+3])
if a == 255 {
continue
}
for c := 0; c < 3; c++ {
img.Pix[i+c] = uint8((uint32(img.Pix[i+c])*a + 255*(255-a)) / 255)
}
img.Pix[i+3] = 255
}
return img
}
func encodeJPEG(img image.Image, quality int) ([]byte, error) {
var buf bytes.Buffer
if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func encodePNG(img image.Image) ([]byte, error) {
var buf bytes.Buffer
if err := png.Encode(&buf, img); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
// ─────────────────────────── 分析 ───────────────────────────
// analyze 在缩成长边 64 的小图上算亮度与主色
func analyze(img *image.RGBA) BackgroundInfo {
w, h := fitInside(img.Rect.Dx(), img.Rect.Dy(), 64)
small := onWhite(scale(img, w, h))
lums := make([]float64, 0, w*h)
pixels := make([]RGBA, 0, w*h)
var sum float64
type bucket struct {
r, g, b, n int
}
buckets := map[int]*bucket{}
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
c := small.RGBAAt(x, y)
l := RGBA{c.R, c.G, c.B, 255}.Luminance()
lums = append(lums, l)
pixels = append(pixels, RGBA{c.R, c.G, c.B, 255})
sum += l
// 每个通道分 8 档,同一档的颜色算一种
key := int(c.R>>5)<<6 | int(c.G>>5)<<3 | int(c.B>>5)
bk := buckets[key]
if bk == nil {
bk = &bucket{}
buckets[key] = bk
}
bk.r, bk.g, bk.b, bk.n = bk.r+int(c.R), bk.g+int(c.G), bk.b+int(c.B), bk.n+1
}
}
n := float64(len(lums))
mean := sum / n
var variance float64
for _, l := range lums {
variance += (l - mean) * (l - mean)
}
list := make([]*bucket, 0, len(buckets))
for _, b := range buckets {
list = append(list, b)
}
sort.Slice(list, func(i, j int) bool { return list[i].n > list[j].n })
var colors []string
var picked []RGBA
for _, b := range list {
c := RGBA{uint8(b.r / b.n), uint8(b.g / b.n), uint8(b.b / b.n), 255}
close := false
for _, p := range picked {
if colorDistance(c, p) < 48 {
close = true
break
}
}
if close {
continue
}
picked = append(picked, c)
colors = append(colors, c.Hex())
if len(colors) == 5 {
break
}
}
// 相近的颜色合并后不到 3 种:图本来就很单一,按占比补齐
for _, b := range list {
if len(colors) >= 3 {
break
}
hex := RGBA{uint8(b.r / b.n), uint8(b.g / b.n), uint8(b.b / b.n), 255}.Hex()
if !contains(colors, hex) {
colors = append(colors, hex)
}
}
return BackgroundInfo{
Luminance: round3(mean),
LuminanceSpread: round3(math.Sqrt(variance / n)),
Colors: colors,
MinScrimDark: round3(minScrim(pixels, RGBA{0, 0, 0, 255}, RGBA{255, 255, 255, 255})),
MinScrimLight: round3(minScrim(pixels, RGBA{255, 255, 255, 255}, RGBA{0, 0, 0, 255})),
}
}
// minScrim 是遮罩至少多浓,text 颜色的字在 90% 的区域达到 4.5:1(最亮、最暗的零星小块不算)。
// 界面按 sRGB 数值把遮罩叠在图上,这里也一样算,不能按线性亮度混合:那样算出的遮罩偏淡
func minScrim(pixels []RGBA, scrim, text RGBA) float64 {
need := make([]float64, len(pixels))
for i, p := range pixels {
lo, hi := 0.0, 1.0
if Contrast(text, p) >= 4.5 {
hi = 0
}
for k := 0; k < 14 && hi > 0; k++ {
mid := (lo + hi) / 2
if Contrast(text, mix(p, scrim, mid)) >= 4.5 {
hi = mid
} else {
lo = mid
}
}
need[i] = hi
}
sort.Float64s(need)
return need[int(0.9*float64(len(need)-1))]
}
// mix 按 sRGB 数值把 b 以 a 的浓度叠在 p 上
func mix(p, b RGBA, a float64) RGBA {
m := func(x, y uint8) uint8 { return uint8(math.Round(float64(x)*(1-a) + float64(y)*a)) }
return RGBA{m(p.R, b.R), m(p.G, b.G), m(p.B, b.B), 255}
}
func colorDistance(a, b RGBA) float64 {
dr, dg, db := float64(a.R)-float64(b.R), float64(a.G)-float64(b.G), float64(a.B)-float64(b.B)
return math.Sqrt(dr*dr + dg*dg + db*db)
}
func contains(list []string, v string) bool {
for _, s := range list {
if s == v {
return true
}
}
return false
}
func round3(v float64) float64 { return math.Round(v*1000) / 1000 }