// 预览派生与进程内缓存:只缓存不可变图片字节,权限必须由调用方每次读取前另行检查。 package platform import ( "bytes" "container/list" "context" "crypto/sha256" "encoding/binary" "errors" "fmt" "image" "image/color" "image/jpeg" "image/png" "sync" "golang.org/x/image/draw" ) // assetPreviewResult 只包含编码字节和 MIME,可与原图共用只读切片,禁止调用者原地修改。 type assetPreviewResult struct { data []byte mime string } // assetPreviewEntry 存储在 LRU 链表中,key 同时作为 map 索引,便于常数时间淘汰。 type assetPreviewEntry struct { key string value assetPreviewResult } // 缓存最多保留 32 MiB/128 项编码结果,互斥锁只覆盖索引操作,不覆盖解码缩放。 var previewMemory = struct { sync.Mutex entries map[string]*list.Element order *list.List bytes int }{entries: make(map[string]*list.Element), order: list.New()} // previewSlots 将所有预览完整解码限制为单并发,避免多个大图同时分配像素内存。 var previewSlots = make(chan struct{}, 1) // previewWidth 仅接受原图或固定 1024 预览,不允许任意宽度组合造成无界缓存键。 func previewWidth(variant, width string) (int, error) { if variant == "" && width == "" { return 0, nil } if variant == "preview" && (width == "" || width == "1024") { return 1024, nil } return 0, errors.New("invalid_asset_variant") } // Cache only immutable bytes, after the caller checks current asset permission. // Bound both decoded concurrency and retained encoded data. // cachedAssetPreview 用原图摘要与宽度做键,命中即提升 LRU;等待执行槽可随请求取消。 func cachedAssetPreview(ctx context.Context, encoded []byte, mime string, width int) (assetPreviewResult, error) { key := fmt.Sprintf("%x:%d", sha256.Sum256(encoded), width) previewMemory.Lock() if entry := previewMemory.entries[key]; entry != nil { previewMemory.order.MoveToFront(entry) result := entry.Value.(assetPreviewEntry).value previewMemory.Unlock() return result, nil } previewMemory.Unlock() select { case previewSlots <- struct{}{}: case <-ctx.Done(): return assetPreviewResult{}, ctx.Err() } defer func() { <-previewSlots }() // Another request may have finished this same preview while we waited. previewMemory.Lock() if entry := previewMemory.entries[key]; entry != nil { result := entry.Value.(assetPreviewEntry).value previewMemory.order.MoveToFront(entry) previewMemory.Unlock() return result, nil } previewMemory.Unlock() result, err := makeAssetPreview(encoded, mime, width) if err != nil { return result, err } // 单项过大仍可响应,但不留在缓存;其余按字节和项数双预算淘汰末尾最久未用项。 if len(result.data) > 8<<20 { return result, nil } previewMemory.Lock() defer previewMemory.Unlock() for previewMemory.bytes+len(result.data) > 32<<20 || previewMemory.order.Len() >= 128 { tail := previewMemory.order.Back() if tail == nil { break } old := tail.Value.(assetPreviewEntry) previewMemory.bytes -= len(old.value.data) delete(previewMemory.entries, old.key) previewMemory.order.Remove(tail) } previewMemory.entries[key] = previewMemory.order.PushFront(assetPreviewEntry{key, result}) previewMemory.bytes += len(result.data) return result, nil } // makeAssetPreview 保留 GIF 动画和足够小的原图,其余应用 EXIF 后等比例缩至最长边预算。 func makeAssetPreview(encoded []byte, mime string, width int) (assetPreviewResult, error) { original := assetPreviewResult{encoded, mime} // Keep animation intact. Original bytes remain the canonical AI/download input. if mime == "image/gif" { return original, nil } config, _, err := image.DecodeConfig(bytes.NewReader(encoded)) if err != nil { return original, err } if config.Width <= 0 || config.Height <= 0 || int64(config.Width)*int64(config.Height) > assetPixelLimit { return original, errors.New("invalid_image_dimensions") } if config.Width <= width && config.Height <= width && len(encoded) <= 64<<10 { return original, nil } source, _, err := image.Decode(bytes.NewReader(encoded)) if err != nil { return original, err } orientation := jpegOrientation(encoded) if orientation != 1 { source = orientedAsset{source, orientation} } bounds := source.Bounds() w, h := bounds.Dx(), bounds.Dy() if w > width || h > width { if w >= h { h = max(1, h*width/w) w = width } else { w = max(1, w*width/h) h = width } } resized := image.NewNRGBA(image.Rect(0, 0, w, h)) draw.CatmullRom.Scale(resized, resized.Bounds(), source, source.Bounds(), draw.Src, nil) var output bytes.Buffer outputMime := "image/png" // 不透明预览编码 JPEG 以减体积,透明预览保留 PNG;原图字节始终不被覆盖。 if resized.Opaque() { err = jpeg.Encode(&output, resized, &jpeg.Options{Quality: 82}) outputMime = "image/jpeg" } else { err = png.Encode(&output, resized) } if err != nil { return original, err } // 无需修正方向且重编码没有变小时直接用原图,避免更大派生文件。 if output.Len() >= len(encoded) && orientation == 1 { return original, nil } return assetPreviewResult{output.Bytes(), outputMime}, nil } // JPEG EXIF orientation is applied to previews instead of silently rotating a // phone photograph after its EXIF metadata is removed by the image encoder. // jpegOrientation 仅解析 JPEG APP1 中 TIFF 的 Orientation,逐层检查长度,异常/缺省均返回正常方向一。 func jpegOrientation(data []byte) int { if len(data) < 4 || data[0] != 0xff || data[1] != 0xd8 { return 1 } for at := 2; at+4 <= len(data); { if data[at] != 0xff { return 1 } marker := data[at+1] if marker == 0xda || marker == 0xd9 { return 1 } length := int(binary.BigEndian.Uint16(data[at+2 : at+4])) if length < 2 || at+2+length > len(data) { return 1 } part := data[at+4 : at+2+length] if marker == 0xe1 && len(part) >= 14 && string(part[:6]) == "Exif\x00\x00" { tiff := part[6:] var order binary.ByteOrder switch string(tiff[:2]) { case "II": order = binary.LittleEndian case "MM": order = binary.BigEndian default: return 1 } if order.Uint16(tiff[2:4]) != 42 { return 1 } offset := int(order.Uint32(tiff[4:8])) if offset < 8 || offset+2 > len(tiff) { return 1 } count := int(order.Uint16(tiff[offset : offset+2])) for i := 0; i < count; i++ { entry := offset + 2 + i*12 if entry+12 > len(tiff) { return 1 } if order.Uint16(tiff[entry:entry+2]) == 0x112 && order.Uint16(tiff[entry+2:entry+4]) == 3 && order.Uint32(tiff[entry+4:entry+8]) == 1 { value := int(order.Uint16(tiff[entry+8 : entry+10])) if value >= 1 && value <= 8 { return value } return 1 } } } at += 2 + length } return 1 } // orientedAsset 是只读坐标适配视图,不复制像素;5–8 方向旋转后宽高交换。 type orientedAsset struct { image.Image orientation int } // Bounds 报告纠正方向后的零起点矩形,供缩放器计算目标比例。 func (im orientedAsset) Bounds() image.Rectangle { b := im.Image.Bounds() if im.orientation >= 5 { return image.Rect(0, 0, b.Dy(), b.Dx()) } return image.Rect(0, 0, b.Dx(), b.Dy()) } // ColorModel 继承原图颜色模型,实际像素读取交由 At 做反向坐标映射。 func (im orientedAsset) ColorModel() color.Model { return im.Image.ColorModel() } // At 将显示坐标映回原图,再补 Bounds.Min,覆盖 EXIF 八种旋转/镜像组合。 func (im orientedAsset) At(x, y int) color.Color { b := im.Image.Bounds() w, h := b.Dx(), b.Dy() switch im.orientation { case 2: x = w - 1 - x case 3: x, y = w-1-x, h-1-y case 4: y = h - 1 - y case 5: x, y = y, x case 6: x, y = y, h-1-x case 7: x, y = w-1-y, h-1-x case 8: x, y = w-1-y, x } return im.Image.At(b.Min.X+x, b.Min.Y+y) }