Method loadOrCache

processor/vipsprocessor/cache.go:53–163

loadOrCache returns a cached blob for the given image path, using the image cache. Cache key is image path only, so the same source serves all requested sizes. If load is non-nil and blob is nil, load is called inside the singleflight to fetch the blob, deduplicating network requests across concurre

(
	blob *imagor.Blob, imagePath string, n int, load imagor.LoadFunc,
)

// Returns (nil, nil, nil) if cache is disabled or the source is animated
// (multi-page structure cannot be preserved in the cache).
func (v *Processor) loadOrCache(
	blob *imagor.Blob, imagePath string, n int, load imagor.LoadFunc,
) (*imagor.Blob, *imagor.Blob, error) {
	if v.cache == nil {
		return nil, nil, nil
	}

	// Fast path: cache hit — return immediately without singleflight overhead.
	if memBlob, ok := v.cache.Get(imagePath); ok {
		return memBlob, nil, nil
	}

	// Deduplicate concurrent cache misses for the same image path.
	result, err, _ := v.cacheSF.Do(imagePath, func() (any, error) {
		// Re-check after acquiring the singleflight group.
		if memBlob, ok := v.cache.Get(imagePath); ok {
			return &loadOrCacheResult{memBlob: memBlob}, nil
		}

		// If blob not provided, fetch it inside the singleflight so concurrent
		// cache misses share a single network request.
		if blob == nil {
			if load == nil {
				return &loadOrCacheResult{}, nil
			}
			var err error
			blob, err = load(imagePath)
			if err != nil {
				return nil, err
			}
		}

		// Decode at maxW×maxH with SizeDown. Fresh context so the VipsSource
		// is released immediately after serialization.
		decodeCtx := withContext(context.Background())

		img, err := v.NewThumbnail(decodeCtx, blob, v.CacheMaxWidth, v.CacheMaxHeight,
			vips.InterestingNone, vips.SizeDown, n, 1, 0)
		if err != nil {
			contextDone(decodeCtx)
			return nil, err
		}

		// Animated source: multi-page structure cannot be preserved in the cache.
		// Return the original blob so the caller can serve it directly.
		if img.Height() != img.PageHeight() {
			img.Close()
			contextDone(decodeCtx)
			return &loadOrCacheResult{origBlob: blob}, nil
		}

		// Static image: serialize to Go-owned bytes, release libvips resources.
		// Storage format is controlled by CacheFormat:
		//   BlobTypeWEBP → WebpsaveBuffer (lossy, smaller memory, slight quality difference)
		//   BlobTypePNG  → PngsaveBuffer (lossless, smaller memory, pixel-identical)
		//   default      → WriteToMemory (raw pixels, fastest hit, most memory)
		imgW, imgH := img.Width(), img.PageHeight()