Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

5.1 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

package heif

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"image"
	"image/jpeg"
	"io"
	"os"
	"runtime"

	"github.com/disintegration/imaging"
	goheic "github.com/siyuan-note/siyuan/kernel/heif/internal/h265heic"
)

const (
	thumbnailWidth   = 520
	previewQuality   = 90
	thumbnailQuality = 85
	MaxInputBytes    = 32 * 1024 * 1024
	maxDimension     = 65535
	desktopMaxPixels = 50_000_000
	mobileMaxPixels  = 12_500_000
	// 解码层仅接受至多 10-bit 4:2:0、无透明通道的单 slice 图像;这里按解码面、CTU 表、
	// NRGBA 和一次合并变换预留每像素 16 字节,再单独预留源文件、RBSP 副本与 JPEG 输出。
	workingBytesPerPixel = 16
	desktopWorkingBudget = 960 * 1024 * 1024
	mobileWorkingBudget  = 320 * 1024 * 1024
	desktopOutputReserve = 96 * 1024 * 1024
	mobileOutputReserve  = 32 * 1024 * 1024
)

var (
	ErrInputTooLarge = errors.New("HEIF image exceeds the input size limit")
	ErrImageTooLarge = errors.New("HEIF image exceeds the dimension limit")
	ErrInvalidMode   = errors.New("invalid HEIF conversion mode")

	conversionSlots = make(chan struct{}, 1)
	maxPixels       = platformMaxPixels()
)

func platformMaxPixels() int {
	if runtime.GOOS == "android" || runtime.GOOS == "ios" {
		return pixelsWithinBudget(mobileWorkingBudget, mobileOutputReserve, mobileMaxPixels)
	}
	return pixelsWithinBudget(desktopWorkingBudget, desktopOutputReserve, desktopMaxPixels)
}

func ReadFileLimited(path string, maxBytes int64) ([]byte, error) {
	if maxBytes <= 0 {
		return nil, ErrInputTooLarge
	}
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	data, err := io.ReadAll(io.LimitReader(file, maxBytes+1))
	if err != nil {
		return nil, err
	}
	if int64(len(data)) > maxBytes {
		return nil, ErrInputTooLarge
	}
	return data, nil
}

func pixelsWithinBudget(workingBudget, outputReserve, hardLimit int) int {
	available := workingBudget - 2*MaxInputBytes - outputReserve
	if available <= 0 {
		return 0
	}
	return min(available/workingBytesPerPixel, hardLimit)
}

type Mode string

const (
	ModePreview   Mode = "preview"
	ModeThumbnail Mode = "thumb"
)

// Convert 将 HEIF 转换为 JPEG,复用预览的尺寸、内存和并发限制,不写入缓存。
func Convert(ctx context.Context, source []byte, mode Mode) ([]byte, error) {
	if len(source) == 0 {
		return nil, errors.New("empty HEIF image")
	}
	if len(source) > MaxInputBytes {
		return nil, ErrInputTooLarge
	}
	if mode != ModePreview && mode != ModeThumbnail {
		return nil, ErrInvalidMode
	}

	select {
	case conversionSlots <- struct{}{}:
		defer func() {
			<-conversionSlots
		}()
	case <-ctx.Done():
		return nil, ctx.Err()
	}
	conversionContext, cancel := context.WithTimeout(ctx, conversionTimeout)
	defer cancel()

	img, err := decodeImage(source)
	if err != nil {
		return nil, err
	}
	if !validDimensions(img.Bounds().Dx(), img.Bounds().Dy()) {
		return nil, ErrImageTooLarge
	}
	if err = conversionContext.Err(); err != nil {
		return nil, err
	}
	if mode == ModeThumbnail && img.Bounds().Dx() > thumbnailWidth {
		img = imaging.Resize(img, thumbnailWidth, 0, imaging.Lanczos)
	}
	if err = conversionContext.Err(); err != nil {
		return nil, err
	}

	quality := previewQuality
	if mode == ModeThumbnail {
		quality = thumbnailQuality
	}
	output := bytes.NewBuffer(make([]byte, 0, estimatedJPEGSize(img)))
	if err = jpeg.Encode(output, img, &jpeg.Options{Quality: quality}); err != nil {
		return nil, fmt.Errorf("encode HEIF preview: %w", err)
	}
	if err = conversionContext.Err(); err != nil {
		return nil, err
	}
	return output.Bytes(), nil
}

func ImageSize(source []byte) (width, height int, err error) {
	if len(source) == 0 {
		return 0, 0, errors.New("empty HEIF image")
	}
	if len(source) > MaxInputBytes {
		return 0, 0, ErrInputTooLarge
	}
	conversionSlots <- struct{}{}
	defer func() {
		<-conversionSlots
	}()
	img, err := decodeImage(source)
	if err != nil {
		return 0, 0, err
	}
	width, height = img.Bounds().Dx(), img.Bounds().Dy()
	if !validDimensions(width, height) {
		return 0, 0, ErrImageTooLarge
	}
	return width, height, nil
}

func decodeImage(source []byte) (img image.Image, err error) {
	defer func() {
		if recovered := recover(); recovered != nil {
			img = nil
			err = fmt.Errorf("decode HEIF image: %v", recovered)
		}
	}()

	config, err := goheic.DecodeConfigBytes(source)
	if err != nil {
		return nil, fmt.Errorf("read HEIF image dimensions: %w", err)
	}
	if !validDimensions(config.Width, config.Height) {
		return nil, ErrImageTooLarge
	}

	img, err = goheic.DecodeBytes(source, goheic.Options{
		AutoRotate:     true,
		FrameSizeLimit: maxPixels,
		Threads:        1,
	})
	if err != nil {
		return nil, fmt.Errorf("decode HEIF image: %w", err)
	}
	return img, nil
}

func validDimensions(width, height int) bool {
	return width > 0 && height > 0 && width <= maxDimension && height <= maxDimension &&
		uint64(width)*uint64(height) <= uint64(maxPixels)
}

func estimatedJPEGSize(img image.Image) int {
	pixels := int64(img.Bounds().Dx()) * int64(img.Bounds().Dy())
	estimate := min(max(pixels/2, 64*1024), 32*1024*1024)
	return int(estimate)
}