Add support for libvips compiled with OpenJPEG

src/common.cc

@@ -157,6 +157,10 @@ namespace sharp {
   bool IsGif(std::string const &str) {
     return EndsWith(str, ".gif") || EndsWith(str, ".GIF");
   }
+  bool IsJp2(std::string const &str) {
+    return EndsWith(str, ".jp2") || EndsWith(str, ".jpx") || EndsWith(str, ".j2k") || EndsWith(str, ".j2c")
+      || EndsWith(str, ".JP2") || EndsWith(str, ".JPX") || EndsWith(str, ".J2K") || EndsWith(str, ".J2C");
+  }
   bool IsTiff(std::string const &str) {
     return EndsWith(str, ".tif") || EndsWith(str, ".tiff") || EndsWith(str, ".TIF") || EndsWith(str, ".TIFF");
   }
@@ -190,6 +194,7 @@ namespace sharp {
       case ImageType::WEBP: id = "webp"; break;
       case ImageType::TIFF: id = "tiff"; break;
       case ImageType::GIF: id = "gif"; break;
+      case ImageType::JP2: id = "jp2"; break;
       case ImageType::SVG: id = "svg"; break;
       case ImageType::HEIF: id = "heif"; break;
       case ImageType::PDF: id = "pdf"; break;
@@ -226,6 +231,8 @@ namespace sharp {
     { "VipsForeignLoadGifBuffer", ImageType::GIF },
     { "VipsForeignLoadNsgifFile", ImageType::GIF },
     { "VipsForeignLoadNsgifBuffer", ImageType::GIF },
+    { "VipsForeignLoadJp2kBuffer", ImageType::JP2 },
+    { "VipsForeignLoadJp2kFile", ImageType::JP2 },
     { "VipsForeignLoadSvgFile", ImageType::SVG },
     { "VipsForeignLoadSvgBuffer", ImageType::SVG },
     { "VipsForeignLoadHeifFile", ImageType::HEIF },
@@ -287,6 +294,7 @@ namespace sharp {
       imageType == ImageType::WEBP ||
       imageType == ImageType::MAGICK ||
       imageType == ImageType::GIF ||
+      imageType == ImageType::JP2 ||
       imageType == ImageType::TIFF ||
       imageType == ImageType::HEIF ||
       imageType == ImageType::PDF;

src/common.h

@@ -116,6 +116,7 @@ namespace sharp {
     JPEG,
     PNG,
     WEBP,
+    JP2,
     TIFF,
     GIF,
     SVG,
@@ -142,6 +143,7 @@ namespace sharp {
   bool IsJpeg(std::string const &str);
   bool IsPng(std::string const &str);
   bool IsWebp(std::string const &str);
+  bool IsJp2(std::string const &str);
   bool IsGif(std::string const &str);
   bool IsTiff(std::string const &str);
   bool IsHeic(std::string const &str);

src/pipeline.cc

@@ -791,6 +791,22 @@ class PipelineWorker : public Napi::AsyncWorker {
           } else {
             baton->channels = std::min(baton->channels, 3);
           }
+        } else if (baton->formatOut == "jp2" || (baton->formatOut == "input"
+          && inputImageType == sharp::ImageType::JP2)) {
+          // Write JP2 to Buffer
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          VipsArea *area = reinterpret_cast<VipsArea*>(image.jp2ksave_buffer(VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth)));
+          baton->bufferOut = static_cast<char*>(area->data);
+          baton->bufferOutLength = area->length;
+          area->free_fn = nullptr;
+          vips_area_unref(area);
+          baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (baton->formatOut == "input" &&
           (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
            inputImageType == sharp::ImageType::SVG))) {
@@ -922,13 +938,14 @@ class PipelineWorker : public Napi::AsyncWorker {
         bool const isWebp = sharp::IsWebp(baton->fileOut);
         bool const isGif = sharp::IsGif(baton->fileOut);
         bool const isTiff = sharp::IsTiff(baton->fileOut);
+        bool const isJp2 = sharp::IsJp2(baton->fileOut);
         bool const isHeif = sharp::IsHeif(baton->fileOut);
         bool const isDz = sharp::IsDz(baton->fileOut);
         bool const isDzZip = sharp::IsDzZip(baton->fileOut);
         bool const isV = sharp::IsV(baton->fileOut);
         bool const mightMatchInput = baton->formatOut == "input";
         bool const willMatchInput = mightMatchInput &&
-         !(isJpeg || isPng || isWebp || isGif || isTiff || isHeif || isDz || isDzZip || isV);
+         !(isJpeg || isPng || isWebp || isGif || isTiff || isJp2 || isHeif || isDz || isDzZip || isV);
 
         if (baton->formatOut == "jpeg" || (mightMatchInput && isJpeg) ||
           (willMatchInput && inputImageType == sharp::ImageType::JPEG)) {
@@ -948,6 +965,18 @@ class PipelineWorker : public Napi::AsyncWorker {
             ->set("optimize_coding", baton->jpegOptimiseCoding));
           baton->formatOut = "jpeg";
           baton->channels = std::min(baton->channels, 3);
+        } else if (baton->formatOut == "jp2" || (mightMatchInput && isJp2) ||
+          (willMatchInput && (inputImageType == sharp::ImageType::JP2))) {
+          // Write JP2 to file
+          sharp::AssertImageTypeDimensions(image, sharp::ImageType::JP2);
+          image.jp2ksave(const_cast<char*>(baton->fileOut.data()), VImage::option()
+            ->set("Q", baton->jp2Quality)
+            ->set("lossless", baton->jp2Lossless)
+            ->set("subsample_mode", baton->jp2ChromaSubsampling == "4:4:4"
+              ? VIPS_FOREIGN_SUBSAMPLE_OFF : VIPS_FOREIGN_SUBSAMPLE_ON)
+            ->set("tile_height", baton->jp2TileHeight)
+            ->set("tile_width", baton->jp2TileWidth));
+            baton->formatOut = "jp2";
         } else if (baton->formatOut == "png" || (mightMatchInput && isPng) || (willMatchInput &&
           (inputImageType == sharp::ImageType::PNG || (inputImageType == sharp::ImageType::GIF && !supportsGifOutput) ||
            inputImageType == sharp::ImageType::SVG))) {
@@ -1438,6 +1467,11 @@ Napi::Value pipeline(const Napi::CallbackInfo& info) {
   baton->pngQuality = sharp::AttrAsUint32(options, "pngQuality");
   baton->pngBitdepth = sharp::AttrAsUint32(options, "pngBitdepth");
   baton->pngDither = sharp::AttrAsDouble(options, "pngDither");
+  baton->jp2Quality = sharp::AttrAsUint32(options, "jp2Quality");
+  baton->jp2Lossless = sharp::AttrAsBool(options, "jp2Lossless");
+  baton->jp2TileHeight = sharp::AttrAsUint32(options, "jp2TileHeight");
+  baton->jp2TileWidth = sharp::AttrAsUint32(options, "jp2TileWidth");
+  baton->jp2ChromaSubsampling = sharp::AttrAsStr(options, "jp2ChromaSubsampling");
   baton->webpQuality = sharp::AttrAsUint32(options, "webpQuality");
   baton->webpAlphaQuality = sharp::AttrAsUint32(options, "webpAlphaQuality");
   baton->webpLossless = sharp::AttrAsBool(options, "webpLossless");

src/pipeline.h

@@ -149,6 +149,11 @@ struct PipelineBaton {
   int pngQuality;
   int pngBitdepth;
   double pngDither;
+  int jp2Quality;
+  bool jp2Lossless;
+  int jp2TileHeight;
+  int jp2TileWidth;
+  std::string jp2ChromaSubsampling;
   int webpQuality;
   int webpAlphaQuality;
   bool webpNearLossless;
@@ -280,6 +285,11 @@ struct PipelineBaton {
     pngQuality(100),
     pngBitdepth(8),
     pngDither(1.0),
+    jp2Quality(80),
+    jp2Lossless(false),
+    jp2TileHeight(512),
+    jp2TileWidth(512),
+    jp2ChromaSubsampling("4:4:4"),
     webpQuality(80),
     webpAlphaQuality(100),
     webpNearLossless(false),

src/utilities.cc

@@ -115,7 +115,7 @@ Napi::Value format(const Napi::CallbackInfo& info) {
   Napi::Object format = Napi::Object::New(env);
   for (std::string const f : {
     "jpeg", "png", "webp", "tiff", "magick", "openslide", "dz",
-    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips"
+    "ppm", "fits", "gif", "svg", "heif", "pdf", "vips", "jp2k"
   }) {
     // Input
     Napi::Boolean hasInputFile =