updates to cmake build for windows

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
 
 #  build-linux-and-analyze:
   build-linux:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     permissions:
       actions: read
       contents: read
@@ -94,7 +94,7 @@ jobs:
         run: |
           ${{ env.VCPKG_ROOT }}/vcpkg update
           ${{ env.VCPKG_ROOT }}/vcpkg version
-          ${{ env.VCPKG_ROOT }}/vcpkg install curl:x64-windows libffi:x64-windows openssl:x64-windows libpng:x64-windows libjpeg-turbo:x64-windows libgd:x64-windows
+          ${{ env.VCPKG_ROOT }}/vcpkg install curl:x64-windows libffi:x64-windows openssl:x64-windows libgd:x64-windows
           ${{ env.VCPKG_ROOT }}/vcpkg list
       - name: Save vcpkg dependencies cache
         id: vcpkg-cache-save

.github/workflows/release.yml

@@ -7,7 +7,7 @@ on:
 jobs:
 
   build-linux:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
       - name: Setup cmake
@@ -91,7 +91,7 @@ jobs:
         run: |
           ${{ env.VCPKG_ROOT }}/vcpkg update
           ${{ env.VCPKG_ROOT }}/vcpkg version
-          ${{ env.VCPKG_ROOT }}/vcpkg install curl:x64-windows libffi:x64-windows openssl:x64-windows libpng:x64-windows libjpeg-turbo:x64-windows libgd:x64-windows
+          ${{ env.VCPKG_ROOT }}/vcpkg install curl:x64-windows libffi:x64-windows openssl:x64-windows libgd:x64-windows
           ${{ env.VCPKG_ROOT }}/vcpkg list
       - name: Compile
         run: |

packages/clib/CMakeLists.txt

@@ -45,10 +45,10 @@ if(NOT WIN32)
     target_include_directories(clib PRIVATE "${FFI_ROOT}/include")
     target_link_libraries(clib libffi)
 else()
-    find_package(unofficial-libffi CONFIG REQUIRED)
+    find_package(PkgConfig)
     find_path(FFI_INCLUDE_DIR ffi.h)
-    target_include_directories(clib PRIVATE ${FFI_INCLUDE_DIR})
-    target_link_libraries(clib unofficial::libffi::libffi)
+    pkg_check_modules(LIBFFI REQUIRED IMPORTED_TARGET libffi)
+    target_link_libraries(main PRIVATE PkgConfig::LIBFFI)
 endif()
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")

packages/imagine/CMakeLists.txt

@@ -23,17 +23,11 @@ add_library(imagine SHARED imagine.c)
 target_link_libraries(imagine libblade)
 add_dependencies(imagine blade)
 
-
-if(NOT WIN32)
-    include(FindGD.cmake)
-    target_include_directories(imagine PRIVATE ${GD_INCLUDE_DIR})
-    target_link_libraries(imagine ${GD_LIBRARIES})
-else()
-    find_package(libgd REQUIRED)
-    find_path(GD_INCLUDE_DIR gd.h)
-    target_include_directories(imagine PRIVATE ${GD_INCLUDE_DIR})
-    target_link_libraries(imagine libgd::libgd)
-endif()
+find_package(PkgConfig)
+pkg_check_modules(LIBGD REQUIRED IMPORTED_TARGET gdlib)
+find_path(GD_INCLUDE_DIR gd.h)
+target_include_directories(imagine PRIVATE ${GD_INCLUDE_DIR})
+target_link_libraries(imagine PkgConfig::LIBGD)
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")

packages/imagine/imagine.c

@@ -146,6 +146,33 @@ DECLARE_MODULE_METHOD(imagine__fromwtga) {
   RETURN_PTR(image);
 }
 
+DECLARE_MODULE_METHOD(imagine__fromwtiff) {
+  ENFORCE_ARG_COUNT(fromwtiff, 1);
+  ENFORCE_ARG_TYPE(fromwtiff, 0, IS_FILE);
+
+  gdImagePtr image = gdImageCreateFromTiff(AS_FILE(args[0])->file);
+  CHECK_IMAGE(image);
+  RETURN_PTR(image);
+}
+
+DECLARE_MODULE_METHOD(imagine__fromwwebp) {
+  ENFORCE_ARG_COUNT(fromwwebp, 1);
+  ENFORCE_ARG_TYPE(fromwwebp, 0, IS_FILE);
+
+  gdImagePtr image = gdImageCreateFromWebp(AS_FILE(args[0])->file);
+  CHECK_IMAGE(image);
+  RETURN_PTR(image);
+}
+
+DECLARE_MODULE_METHOD(imagine__fromwavif) {
+  ENFORCE_ARG_COUNT(fromwavif, 1);
+  ENFORCE_ARG_TYPE(fromwavif, 0, IS_FILE);
+
+  gdImagePtr image = gdImageCreateFromAvif(AS_FILE(args[0])->file);
+  CHECK_IMAGE(image);
+  RETURN_PTR(image);
+}
+
 DECLARE_MODULE_METHOD(imagine__fromfile) {
   ENFORCE_ARG_COUNT(fromfile, 1);
   ENFORCE_ARG_TYPE(fromfile, 0, IS_STRING);
@@ -956,6 +983,45 @@ DECLARE_MODULE_METHOD(imagine__wbmp) {
   RETURN;
 }
 
+DECLARE_MODULE_METHOD(imagine__tiff) {
+  ENFORCE_ARG_COUNT(tiff, 2);
+  ENFORCE_ARG_TYPE(tiff, 0, IS_PTR);
+  ENFORCE_ARG_TYPE(tiff, 1, IS_FILE);
+
+  gdImagePtr image = (gdImagePtr)AS_PTR(args[0])->pointer;
+  CHECK_IMAGE_PTR(image);
+
+  gdImageTiff(image, AS_FILE(args[1])->file);
+  RETURN;
+}
+
+DECLARE_MODULE_METHOD(imagine__webp) {
+  ENFORCE_ARG_COUNT(webp, 3);
+  ENFORCE_ARG_TYPE(webp, 0, IS_PTR);
+  ENFORCE_ARG_TYPE(webp, 1, IS_FILE);
+  ENFORCE_ARG_TYPE(webp, 2, IS_NUMBER);
+
+  gdImagePtr image = (gdImagePtr)AS_PTR(args[0])->pointer;
+  CHECK_IMAGE_PTR(image);
+
+  gdImageWebpEx(image, AS_FILE(args[1])->file, AS_NUMBER(args[2]));
+  RETURN;
+}
+
+DECLARE_MODULE_METHOD(imagine__avif) {
+  ENFORCE_ARG_COUNT(avif, 4);
+  ENFORCE_ARG_TYPE(avif, 0, IS_PTR);
+  ENFORCE_ARG_TYPE(avif, 1, IS_FILE);
+  ENFORCE_ARG_TYPE(avif, 2, IS_NUMBER);
+  ENFORCE_ARG_TYPE(avif, 3, IS_NUMBER);
+
+  gdImagePtr image = (gdImagePtr)AS_PTR(args[0])->pointer;
+  CHECK_IMAGE_PTR(image);
+
+  gdImageAvifEx(image, AS_FILE(args[1])->file, AS_NUMBER(args[2]), AS_NUMBER(args[3]));
+  RETURN;
+}
+
 DECLARE_MODULE_METHOD(imagine__filltoborder) {
   ENFORCE_ARG_COUNT(filltoborder, 5);
   ENFORCE_ARG_TYPE(filltoborder, 0, IS_PTR);
@@ -1617,7 +1683,10 @@ CREATE_MODULE_LOADER(imagine) {
       {"fromgif",   true,  GET_MODULE_METHOD(imagine__fromgif)},
       {"frombmp",   true,  GET_MODULE_METHOD(imagine__frombmp)},
       {"fromwbmp",   true,  GET_MODULE_METHOD(imagine__fromwbmp)},
-      {"fromwtga",   true,  GET_MODULE_METHOD(imagine__fromwtga)},
+      {"fromtga",   true,  GET_MODULE_METHOD(imagine__fromwtga)},
+      {"fromtiff",   true,  GET_MODULE_METHOD(imagine__fromwtiff)},
+      {"fromwebp",   true,  GET_MODULE_METHOD(imagine__fromwwebp)},
+      {"fromavif",   true,  GET_MODULE_METHOD(imagine__fromwavif)},
       {"fromfile",   true,  GET_MODULE_METHOD(imagine__fromfile)},
 
       // pixels
@@ -1665,6 +1734,9 @@ CREATE_MODULE_LOADER(imagine) {
       {"jpeg",   true,  GET_MODULE_METHOD(imagine__jpeg)},
       {"bmp",   true,  GET_MODULE_METHOD(imagine__bmp)},
       {"wbmp",   true,  GET_MODULE_METHOD(imagine__wbmp)},
+      {"tiff",   true,  GET_MODULE_METHOD(imagine__tiff)},
+      {"webp",   true,  GET_MODULE_METHOD(imagine__webp)},
+      {"avif",   true,  GET_MODULE_METHOD(imagine__avif)},
 
       // processing
       {"filltoborder",   true,  GET_MODULE_METHOD(imagine__filltoborder)},

packages/imagine/imagine/comparisons.b

@@ -4,52 +4,52 @@ import _imagine
 /**
  * Actual image IS different
  */
-var CMP_IMAGE = _imagine.CMP_IMAGE
+var CMP_IMAGE = 1
 
 
 /**
  * Number of colors in pallette differ
  */
-var CMP_NUM_COLORS = _imagine.CMP_NUM_COLORS
+var CMP_NUM_COLORS = 2
 
 
 /**
  * Image colors differ
  */
-var CMP_COLOR = _imagine.CMP_COLOR
+var CMP_COLOR = 4
 
 
 /**
  * Image width differs
  */
-var CMP_SIZE_X = _imagine.CMP_SIZE_X
+var CMP_SIZE_X = 8
 
 
 /**
  * Image heights differ
  */
-var CMP_SIZE_Y = _imagine.CMP_SIZE_Y
+var CMP_SIZE_Y = 16
 
 
 /**
  * Transparent color differs
  */
-var CMP_TRANSPARENT = _imagine.CMP_TRANSPARENT
+var CMP_TRANSPARENT = 32
 
 
 /**
  * Background color differs
  */
-var CMP_BACKGROUND = _imagine.CMP_BACKGROUND
+var CMP_BACKGROUND = 64
 
 
 /**
  * Interlaced setting differs
  */
-var CMP_INTERLACE = _imagine.CMP_INTERLACE
+var CMP_INTERLACE = 128
 
 
 /**
  * Truecolor vs palette differs
  */
-var CMP_TRUECOLOR = _imagine.CMP_TRUECOLOR
+var CMP_TRUECOLOR = 256

packages/imagine/imagine/crops.b

@@ -4,28 +4,28 @@ import _imagine
 /**
  * Same as CROP_TRANSPARENT
  */
-var CROP_DEFAULT = _imagine.CROP_DEFAULT
+var CROP_DEFAULT = 0
 
 
 /**
  * Crop using the transparent color
  */
-var CROP_TRANSPARENT = _imagine.CROP_TRANSPARENT
+var CROP_TRANSPARENT = 1
 
 
 /**
  * Crop black borders
  */
-var CROP_BLACK = _imagine.CROP_BLACK
+var CROP_BLACK = 2
 
 
 /**
  * Crop white borders
  */
-var CROP_WHITE = _imagine.CROP_WHITE
+var CROP_WHITE = 3
 
 
 /**
  * Crop using colors of the 4 corners
  */
-var CROP_SIDES = _imagine.CROP_SIDES
+var CROP_SIDES = 4

packages/imagine/imagine/image.b

@@ -180,6 +180,81 @@ class Image {
     return ImageResource(_imagine.fromtga(src))
   }
 
+  /**
+   * Creates an image from a TIFF file.
+   * 
+   * @param {string|file} src
+   * @returns {ImageResource}
+   */
+  static from_tiff(src) {
+    if !is_string(src) and !is_file(src) 
+      die Exception('string path or file expected, ${typeof(src)} given')
+
+    if is_string(src) {
+      src = file(src)
+    }
+
+    if !src.exists() {
+      die Exception('file not found')
+    }
+
+    if src.mode().index_of('r') == -1{
+      die Exception('file not readable')
+    }
+
+    return ImageResource(_imagine.fromtiff(src))
+  }
+
+  /**
+   * Creates an image from a WEBP file.
+   * 
+   * @param {string|file} src
+   * @returns {ImageResource}
+   */
+  static from_webp(src) {
+    if !is_string(src) and !is_file(src) 
+      die Exception('string path or file expected, ${typeof(src)} given')
+
+    if is_string(src) {
+      src = file(src)
+    }
+
+    if !src.exists() {
+      die Exception('file not found')
+    }
+
+    if src.mode().index_of('r') == -1{
+      die Exception('file not readable')
+    }
+
+    return ImageResource(_imagine.fromwebp(src))
+  }
+
+  /**
+   * Creates an image from a AVIF file.
+   * 
+   * @param {string|file} src
+   * @returns {ImageResource}
+   */
+  static from_avif(src) {
+    if !is_string(src) and !is_file(src) 
+      die Exception('string path or file expected, ${typeof(src)} given')
+
+    if is_string(src) {
+      src = file(src)
+    }
+
+    if !src.exists() {
+      die Exception('file not found')
+    }
+
+    if src.mode().index_of('r') == -1{
+      die Exception('file not readable')
+    }
+
+    return ImageResource(_imagine.fromavif(src))
+  }
+
   /**
    * Creates an image from any supported image file.
    * As long as the file type is supported by Imagine,

packages/imagine/imagine/quants.b

@@ -3,22 +3,22 @@ import _imagine
 /**
  * QUANT_LIQ if libimagequant is available, QUANT_JQUANT otherwise.
  */
-var QUANT_DEFAULT = _imagine.QUANT_DEFAULT
+var QUANT_DEFAULT = 0
 
 
 /**
  * libjpeg's old median cut. Fast, but only uses 16-bit color.
  */
-var QUANT_JQUANT = _imagine.QUANT_JQUANT
+var QUANT_JQUANT = 1
 
 
 /**
  * NeuQuant - approximation using Kohonen neural network.
  */
-var QUANT_NEUQUANT = _imagine.QUANT_NEUQUANT
+var QUANT_NEUQUANT = 2
 
 
 /**
  * A combination of algorithms used in libimagequant aiming for the highest quality at cost of speed.
  */
-var QUANT_LIQ = _imagine.QUANT_LIQ
+var QUANT_LIQ = 3