Initial QSfera import

Server/vendor/github.com/davidbyttow/govips/v2/vips/govips.go

@@ -0,0 +1,288 @@
+// Package vips provides go bindings for libvips, a fast image processing library.
+package vips
+
+// #cgo pkg-config: vips
+// #include <vips/vips.h>
+// #include "govips.h"
+import "C"
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+)
+
+const (
+	defaultConcurrencyLevel = 1
+	defaultMaxCacheMem      = 50 * 1024 * 1024
+	defaultMaxCacheSize     = 100
+	defaultMaxCacheFiles    = 0
+)
+
+var (
+	// Version is the full libvips version string (x.y.z)
+	Version = C.GoString(C.vips_version_string())
+
+	// MajorVersion is the libvips major component of the version string (x in x.y.z)
+	MajorVersion = int(C.vips_version(0))
+
+	// MinorVersion is the libvips minor component of the version string (y in x.y.z)
+	MinorVersion = int(C.vips_version(1))
+
+	// MicroVersion is the libvips micro component of the version string (z in x.y.z)
+	// Also known as patch version
+	MicroVersion = int(C.vips_version(2))
+
+	running             = false
+	hasShutdown         = false
+	initLock            sync.Mutex
+	statCollectorDone   chan struct{}
+	once                sync.Once
+	typeLoaders         = make(map[string]ImageType)
+	supportedImageTypes = make(map[ImageType]bool)
+)
+
+// Config allows fine-tuning of libvips library
+type Config struct {
+	ConcurrencyLevel int
+	MaxCacheFiles    int
+	MaxCacheMem      int
+	MaxCacheSize     int
+	ReportLeaks      bool
+	CacheTrace       bool
+	CollectStats     bool
+}
+
+// Startup sets up the libvips support and ensures the versions are correct. Pass in nil for
+// default configuration.
+func Startup(config *Config) error {
+	if hasShutdown {
+		return errors.New("govips cannot be stopped and restarted")
+	}
+
+	initLock.Lock()
+	defer initLock.Unlock()
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	if running {
+		govipsLog("govips", LogLevelInfo, "warning libvips already started")
+		return nil
+	}
+
+	if MajorVersion < 8 {
+		return errors.New("govips requires libvips version 8.10+")
+	}
+
+	if MajorVersion == 8 && MinorVersion < 10 {
+		return errors.New("govips requires libvips version 8.10+")
+	}
+
+	cName := C.CString("govips")
+	defer freeCString(cName)
+
+	// Initialize govips logging handler and verbosity filter to historical default
+	if !currentLoggingOverridden {
+		govipsLoggingSettings(nil, LogLevelInfo)
+	}
+
+	// Override default glib logging handler to intercept logging messages
+	enableLogging()
+
+	err := C.vips_init(cName)
+	if err != 0 {
+		return fmt.Errorf("failed to start vips code=%v", err)
+	}
+
+	running = true
+
+	if config != nil {
+		if config.CollectStats {
+			statCollectorDone = collectStats()
+		}
+
+		C.vips_leak_set(toGboolean(config.ReportLeaks))
+
+		if config.ConcurrencyLevel >= 0 {
+			C.vips_concurrency_set(C.int(config.ConcurrencyLevel))
+		} else {
+			C.vips_concurrency_set(defaultConcurrencyLevel)
+		}
+
+		if config.MaxCacheFiles >= 0 {
+			C.vips_cache_set_max_files(C.int(config.MaxCacheFiles))
+		} else {
+			C.vips_cache_set_max_files(defaultMaxCacheFiles)
+		}
+
+		if config.MaxCacheMem >= 0 {
+			C.vips_cache_set_max_mem(C.size_t(config.MaxCacheMem))
+		} else {
+			C.vips_cache_set_max_mem(defaultMaxCacheMem)
+		}
+
+		if config.MaxCacheSize >= 0 {
+			C.vips_cache_set_max(C.int(config.MaxCacheSize))
+		} else {
+			C.vips_cache_set_max(defaultMaxCacheSize)
+		}
+
+		C.vips_cache_set_trace(toGboolean(config.CacheTrace))
+	} else {
+		C.vips_concurrency_set(defaultConcurrencyLevel)
+		C.vips_cache_set_max(defaultMaxCacheSize)
+		C.vips_cache_set_max_mem(defaultMaxCacheMem)
+		C.vips_cache_set_max_files(defaultMaxCacheFiles)
+		C.vips_cache_set_trace(toGboolean(false))
+	}
+
+	govipsLog("govips", LogLevelInfo, fmt.Sprintf("vips %s started with concurrency=%d cache_max_files=%d cache_max_mem=%d cache_max=%d",
+		Version,
+		int(C.vips_concurrency_get()),
+		int(C.vips_cache_get_max_files()),
+		int(C.vips_cache_get_max_mem()),
+		int(C.vips_cache_get_max())))
+
+	initTypes()
+	return nil
+}
+
+func enableLogging() {
+	C.vips_set_logging_handler()
+}
+
+func disableLogging() {
+	C.vips_unset_logging_handler()
+}
+
+// consoleLogging overrides the Govips logging handler and makes glib
+// use its default logging handler which outputs everything to console.
+// Needed for CI unit testing due to a macOS bug in Go (doesn't clean cgo callbacks on exit)
+func consoleLogging() {
+	C.vips_default_logging_handler()
+}
+
+// Shutdown libvips
+func Shutdown() {
+	hasShutdown = true
+
+	if statCollectorDone != nil {
+		statCollectorDone <- struct{}{}
+	}
+
+	initLock.Lock()
+	defer initLock.Unlock()
+
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	if !running {
+		govipsLog("govips", LogLevelInfo, "warning libvips not started")
+		return
+	}
+
+	if temporaryDirectory != "" {
+		os.RemoveAll(temporaryDirectory)
+	}
+
+	C.vips_shutdown()
+	disableLogging()
+	running = false
+}
+
+// ShutdownThread clears the cache for for the given thread. This needs to be
+// called when a thread using vips exits.
+func ShutdownThread() {
+	C.vips_thread_shutdown()
+}
+
+// ClearCache drops the whole operation cache, handy for leak tracking.
+func ClearCache() {
+	C.vips_cache_drop_all()
+}
+
+// PrintCache prints the whole operation cache to stdout for debugging purposes.
+func PrintCache() {
+	C.vips_cache_print()
+}
+
+// PrintObjectReport outputs all of the current internal objects in libvips
+func PrintObjectReport(label string) {
+	govipsLog("govips", LogLevelInfo, fmt.Sprintf("\n=======================================\nvips live objects: %s...\n", label))
+	C.vips_object_print_all()
+	govipsLog("govips", LogLevelInfo, "=======================================\n\n")
+}
+
+// MemoryStats is a data structure that houses various memory statistics from ReadVipsMemStats()
+type MemoryStats struct {
+	Mem     int64
+	MemHigh int64
+	Files   int64
+	Allocs  int64
+}
+
+var openImageRefs atomic.Int64
+
+// OpenImageRefs returns the number of ImageRef instances that haven't been closed.
+func OpenImageRefs() int64 {
+	return openImageRefs.Load()
+}
+
+// AssertNoLeaks fails the test if any ImageRef instances remain open.
+// Call this at the end of tests to catch leaked images.
+func AssertNoLeaks(t testing.TB) {
+	t.Helper()
+	n := openImageRefs.Load()
+	if n != 0 {
+		t.Errorf("govips: %d ImageRef(s) not closed (leaked)", n)
+	}
+}
+
+// ReadVipsMemStats returns various memory statistics such as allocated memory and open files.
+func ReadVipsMemStats(stats *MemoryStats) {
+	stats.Mem = int64(C.vips_tracked_get_mem())
+	stats.MemHigh = int64(C.vips_tracked_get_mem_highwater())
+	stats.Allocs = int64(C.vips_tracked_get_allocs())
+	stats.Files = int64(C.vips_tracked_get_files())
+}
+
+func startupIfNeeded() error {
+	if !running {
+		govipsLog("govips", LogLevelInfo, "libvips was forcibly started automatically, consider calling Startup/Shutdown yourself")
+		if err := Startup(nil); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// InitTypes initializes caches and figures out which image types are supported
+func initTypes() {
+	once.Do(func() {
+		cType := C.CString("VipsOperation")
+		defer freeCString(cType)
+
+		for k, v := range ImageTypes {
+			name := strings.ToLower("VipsForeignLoad" + v)
+			typeLoaders[name] = k
+			typeLoaders[name+"buffer"] = k
+
+			cFunc := C.CString(v + "load")
+			//noinspection GoDeferInLoop
+			defer freeCString(cFunc)
+
+			ret := C.vips_type_find(cType, cFunc)
+
+			supportedImageTypes[k] = int(ret) != 0
+
+			if supportedImageTypes[k] {
+				govipsLog("govips", LogLevelInfo, fmt.Sprintf("registered image type loader type=%s", v))
+			}
+		}
+	})
+}