Libvips image loading

build.sbt

@@ -106,6 +106,7 @@ lazy val commonLib = project("common-lib").settings(
     "com.gu" %% "thrift-serializer" % "5.0.2",
     "org.scalaz" %% "scalaz-core" % "7.3.8",
     "org.im4java" % "im4java" % "1.4.0",
+    "app.photofox.vips-ffm" % "vips-ffm-core" % "1.9.8",
     "com.gu" % "kinesis-logback-appender" % "2.1.3",
     "net.logstash.logback" % "logstash-logback-encoder" % "5.0",
     logback, // play-logback; needed when running the scripts
@@ -245,7 +246,7 @@ def playProject(projectName: String, port: Int, path: Option[String] = None): Pr
     .enablePlugins(PlayScala, BuildInfoPlugin, DockerPlugin)
     .dependsOn(restLib)
     .settings(commonSettings ++ buildInfo ++ Seq(
-      dockerBaseImage := "eclipse-temurin:11",
+      dockerBaseImage := "eclipse-temurin:25",
       dockerExposedPorts := Seq(port),
       playDefaultPort := port,
 
@@ -288,6 +289,6 @@ def playImageLoaderProject(projectName: String, port: Int, path: Option[String]
         "-Dpidfile.path=/dev/null",
         s"-Dconfig.file=/opt/docker/conf/application.conf",
         s"-Dlogger.file=/opt/docker/conf/logback.xml",
-        "-XX:+PrintCommandLineFlags"
+        "-XX:+PrintCommandLineFlags", "-XX:MaxRAMPercentage=20"
   )))
 }

cloudbuild.yaml

@@ -14,9 +14,10 @@ steps:
     dir: 'kahuna'
     args: [ 'run', 'dist' ]
 
-  - name: 'gcr.io/$PROJECT_ID/scala-sbt:1.6.2-jdk-11'
+  - name: 'gcr.io/$PROJECT_ID/scala-sbt:1.11.7-jdk-25'
     args: ['docker:publishLocal']
-
+    env:
+    - 'DOCKER_API_VERSION=1.41'
   - name: 'gcr.io/cloud-builders/docker'
     args: ['tag', 'auth:0.1', 'eu.gcr.io/$PROJECT_ID/auth:$BRANCH_NAME']
   - name: 'gcr.io/cloud-builders/docker'

common-lib/src/main/scala/com/gu/mediaservice/lib/imaging/ImageOperations.scala

@@ -1,15 +1,17 @@
 package com.gu.mediaservice.lib.imaging
 
-import java.io._
-import org.im4java.core.IMOperation
+import app.photofox.vipsffm.enums.{VipsIntent, VipsInterpretation}
+import app.photofox.vipsffm.{VImage, VipsHelper, VipsOption}
+import com.gu.mediaservice.lib.BrowserViewableImage
 import com.gu.mediaservice.lib.Files._
-import com.gu.mediaservice.lib.{BrowserViewableImage, StorableThumbImage}
-import com.gu.mediaservice.lib.imaging.ImageOperations.{optimisedMimeType, thumbMimeType}
-import com.gu.mediaservice.lib.imaging.im4jwrapper.ImageMagick.{addDestImage, addImage, format, runIdentifyCmd}
+import com.gu.mediaservice.lib.imaging.ImageOperations.thumbMimeType
 import com.gu.mediaservice.lib.imaging.im4jwrapper.{ExifTool, ImageMagick}
 import com.gu.mediaservice.lib.logging.{GridLogging, LogMarker, Stopwatch, addLogMarkers}
 import com.gu.mediaservice.model._
+import org.im4java.core.IMOperation
 
+import java.io._
+import java.lang.foreign.Arena
 import scala.concurrent.{ExecutionContext, Future}
 import scala.sys.process._
 
@@ -158,77 +160,106 @@ class ImageOperations(playPath: String) extends GridLogging {
       throw new UnsupportedCropOutputTypeException
   }
 
-  val thumbUnsharpRadius = 0.5d
-  val thumbUnsharpSigma = 0.5d
-  val thumbUnsharpAmount = 0.8d
   val interlacedHow = "Line"
   val backgroundColour = "#333333"
 
   /**
-    * Given a source file containing an image (the 'browser viewable' file),
-    * construct a thumbnail file in the provided temp directory, and return
-    * the file with metadata about it.
-    * @param browserViewableImage
-    * @param width Desired with of thumbnail
-    * @param qual Desired quality of thumbnail
-    * @param outputFile Location to create thumbnail file
-    * @param iccColourSpace (Approximately) number of colours to use
-    * @param colourModel Colour model - eg RGB or CMYK
-    * @return The file created and the mimetype of the content of that file, in a future.
-    */
-  def createThumbnail(browserViewableImage: BrowserViewableImage,
-                      width: Int,
-                      qual: Double = 100d,
-                      outputFile: File,
-                      iccColourSpace: Option[String],
-                      colourModel: Option[String],
-                      orientationMetadata: Option[OrientationMetadata]
-  )(implicit logMarker: LogMarker): Future[(File, MimeType)] = {
-    val stopwatch = Stopwatch.start
+   * Given a source file containing an image (the 'browser viewable' file),
+   * construct a thumbnail file in the provided temp directory, and return
+   * the file with metadata about it.
+   *
+   * @param browserViewableImage
+   * @param width               Desired with of thumbnail
+   * @param qual                Desired quality of thumbnail
+   * @param outputFile          Location to create thumbnail file
+   * @param orientationMetadata OrientationMetadata for rotation correction
+   * @return The file created and the mimetype of the content of that file and it's dimensions, in a future.
+   */
+  def createThumbnailVips(browserViewableImage: BrowserViewableImage,
+                          width: Int,
+                          qual: Double = 100d,
+                          outputFile: File,
+                          orientationMetadata: Option[OrientationMetadata]
+                         )(implicit logMarker: LogMarker): Future[(File, MimeType, Option[Dimensions])] = {
+    Future {
+      val stopwatch = Stopwatch.start
+      val arena = Arena.ofConfined
+
+      try {
+        val thumbnail = VImage.thumbnail(arena, browserViewableImage.file.getAbsolutePath, width,
+          VipsOption.Boolean("auto-rotate", false),
+          VipsOption.Enum("intent", VipsIntent.INTENT_PERCEPTUAL),
+          VipsOption.String("export-profile", "srgb")
+        )
+
+        val inMemoryCopy = VImage.pngloadBuffer(arena, thumbnail.pngsaveBuffer(VipsOption.Int("compression", 0)))
+
+        val rotated = orientationMetadata.map(_.orientationCorrection()).map { angle =>
+          logger.info("Rotating thumbnail: " + angle)
+          inMemoryCopy.rotate(angle)
+        }.getOrElse {
+          inMemoryCopy
+        }
+        logger.info("Created thumbnail: " + rotated.getWidth + "x" + rotated.getHeight)
+        saveImageToFile(rotated, Jpeg, qual.toInt, outputFile)
 
-    val cropSource     = addImage(browserViewableImage.file)
-    val orientated     = orient(cropSource, orientationMetadata)
-    val thumbnailed    = thumbnail(orientated)(width)
-    val corrected      = correctColour(thumbnailed)(iccColourSpace, colourModel, browserViewableImage.isTransformedFromSource)
-    val converted      = applyOutputProfile(corrected, optimised = true)
-    val stripped       = stripMeta(converted)
-    val profiled       = applyOutputProfile(stripped, optimised = true)
-    val withBackground = setBackgroundColour(profiled)(backgroundColour)
-    val flattened      = flatten(withBackground)
-    val unsharpened    = unsharp(flattened)(thumbUnsharpRadius, thumbUnsharpSigma, thumbUnsharpAmount)
-    val qualified      = quality(unsharpened)(qual)
-    val interlaced     = interlace(qualified)(interlacedHow)
-    val addOutput      = {file:File => addDestImage(interlaced)(file)}
-    for {
-      _          <- runConvertCmd(addOutput(outputFile), useImageMagick = browserViewableImage.mimeType == Tiff)
-      _ = logger.info(addLogMarkers(stopwatch.elapsed), "Finished creating thumbnail")
-    } yield (outputFile, thumbMimeType)
+        val thumbDimensions = Some(Dimensions(rotated.getWidth, rotated.getHeight))
+        arena.close()
+
+        logger.info(addLogMarkers(stopwatch.elapsed), "Finished creating thumbnail")
+        (outputFile, thumbMimeType, thumbDimensions)
+
+      } catch {
+        case e: Throwable =>
+          arena.close()
+          throw e
+      }
+
+    }.recoverWith {
+      case e: Throwable =>
+        logger.error("Error creating thumbnail", e)
+        Future.failed(e)
+    }
   }
 
-  /**
-    * Given a source file containing a file which requires optimising to make it suitable for viewing in
-    * a browser, construct a new image file in the provided temp directory, and return
-    * * the file with metadata about it.
-    * @param sourceFile File containing browser viewable (ie not too big or colourful) image
-    * @param sourceMimeType Mime time of browser viewable file
-    * @param tempDir Location to create optimised file
-    * @return The file created and the mimetype of the content of that file, in a future.
-    */
-  def transformImage(sourceFile: File, sourceMimeType: Option[MimeType], tempDir: File)(implicit logMarker: LogMarker): Future[(File, MimeType)] = {
-    val stopwatch = Stopwatch.start
-    for {
-      // png suffix is used by imagemagick to infer the required type
-      outputFile      <- createTempFile(s"transformed-", optimisedMimeType.fileExtension, tempDir)
-      transformSource = addImage(sourceFile)
-      converted       = applyOutputProfile(transformSource, optimised = true)
-      stripped        = stripMeta(converted)
-      profiled        = applyOutputProfile(stripped, optimised = true)
-      depthAdjusted   = depth(profiled)(8)
-      addOutput       = addDestImage(depthAdjusted)(outputFile)
-      _               <- runConvertCmd(addOutput, useImageMagick = sourceMimeType.contains(Tiff))
-      _               <- checkForOutputFileChange(outputFile)
-      _ = logger.info(addLogMarkers(stopwatch.elapsed), "Finished creating browser-viewable image")
-    } yield (outputFile, optimisedMimeType)
+  def saveImageToFile(image: VImage, mimeType: MimeType, qual: Double, outputFile: File, quantise: Boolean = false): File = {
+    logger.info(s"Saving image as $mimeType to file: " + outputFile.getAbsolutePath)
+    mimeType match {
+      case Jpeg =>
+        image.jpegsave(outputFile.getAbsolutePath,
+          VipsOption.Int("Q", qual.toInt),
+          //VipsOption.Boolean("optimize-scans", true),
+          VipsOption.Boolean("optimize-coding", true),
+          //VipsOption.Boolean("interlace", true),
+          //VipsOption.Boolean("trellis-quant", true),
+          // VipsOption.Int("quant-table", 3),
+          VipsOption.Boolean("strip", true)
+        )
+        outputFile
+
+      case Png =>
+        // We are allowed to quantise PNG crops but not the master
+        if (quantise) {
+          image.pngsave(outputFile.getAbsolutePath,
+            VipsOption.Boolean("palette", true),
+            VipsOption.Int("Q", qual.toInt),
+            VipsOption.Int("effort", 1),
+            //VipsOption.Int("compression", 6),
+            VipsOption.Int("bitdepth", 8),
+            VipsOption.Boolean("strip", true)
+          )
+        } else {
+          image.pngsave(outputFile.getAbsolutePath,
+            //VipsOption.Int("compression", 6),
+            VipsOption.Boolean("strip", true)
+          )
+        }
+        outputFile
+
+      case _ =>
+        logger.error(s"Save to $mimeType is not supported.")
+        throw new UnsupportedCropOutputTypeException
+    }
   }
 
   // When a layered tiff is unpacked, the temp file (blah.something) is moved
@@ -264,65 +295,58 @@ class ImageOperations(playPath: String) extends GridLogging {
 
 }
 
-object ImageOperations {
+object ImageOperations extends GridLogging {
   val thumbMimeType = Jpeg
   val optimisedMimeType = Png
-  def identifyColourModel(sourceFile: File, mimeType: MimeType)(implicit ec: ExecutionContext, logMarker: LogMarker): Future[Option[String]] = {
-    // TODO: use mimeType to lookup other properties once we support other formats
 
-    mimeType match {
-      case Jpeg =>
-        val source = addImage(sourceFile)
-        val formatter = format(source)("%[JPEG-Colorspace-Name]")
-
-        for {
-          output <- runIdentifyCmd(formatter, false)
-          colourModel = output.headOption
-        } yield colourModel match {
-          case Some("GRAYSCALE") => Some("Greyscale")
-          case Some("CMYK") => Some("CMYK")
-          case _ => Some("RGB")
-        }
-      case Tiff =>
-        val op = new IMOperation()
-        val formatter = format(op)("%[colorspace]")
-        val withSource = addDestImage(formatter)(sourceFile)
-
-        for {
-          output <- runIdentifyCmd(withSource, true)
-          colourModel = output.headOption
-        } yield colourModel match {
-          case Some("sRGB") => Some("RGB")
-          case Some("Gray") => Some("Greyscale")
-          case Some("CIELab") => Some("LAB")
-          // IM returns doubles for TIFFs with transparency…
-          case Some("sRGBsRGB") => Some("RGB")
-          case Some("GrayGray") => Some("Greyscale")
-          case Some("CIELabCIELab") => Some("LAB")
-          case Some("CMYKCMYK") => Some("CMYK")
-          // …and triples for TIFFs with transparency and alpha channel(s). I think.
-          case Some("sRGBsRGBsRGB") => Some("RGB")
-          case Some("GrayGrayGray") => Some("Greyscale")
-          case Some("CIELabCIELabCIELab") => Some("LAB")
-          case Some("CMYKCMYKCMYK") => Some("CMYK")
-          case _ => colourModel
+  def getImageInformation(sourceFile: File)(implicit ec: ExecutionContext, logMarker: LogMarker): Future[(Option[Dimensions], Option[OrientationMetadata], Option[String], Map[String, String])] = {
+    val stopwatch = Stopwatch.start
+    Future {
+      var dimensions: Option[Dimensions] = None
+      var maybeExifOrientationWhichTransformsImage: Option[OrientationMetadata] = None
+      var colourModel: Option[String] = None
+      var colourModelInformation: Map[String, String] = Map.empty
+
+      val arena = Arena.ofConfined
+      try {
+        val image = VImage.newFromFile(arena, sourceFile.getAbsolutePath)
+
+        dimensions = Some(Dimensions(width = image.getWidth, height = image.getHeight))
+
+        val exifOrientation = VipsHelper.image_get_orientation(image.getUnsafeStructAddress)
+        val orientation = Some(OrientationMetadata(
+          exifOrientation = Some(exifOrientation)
+        ))
+        maybeExifOrientationWhichTransformsImage = Seq(orientation).flatten.find(_.transformsImage())
+
+        // TODO better way to go straight from int to enum?
+        val maybeInterpretation = VipsInterpretation.values().toSeq.find(_.getRawValue == VipsHelper.image_get_interpretation(image.getUnsafeStructAddress))
+        colourModel = maybeInterpretation match {
+          case Some(VipsInterpretation.INTERPRETATION_B_W) => Some("Greyscale")
+          case Some(VipsInterpretation.INTERPRETATION_CMYK) => Some("CMYK")
+          case Some(VipsInterpretation.INTERPRETATION_LAB) => Some("LAB")
+          case Some(VipsInterpretation.INTERPRETATION_LABS) => Some("LAB")
+          case Some(VipsInterpretation.INTERPRETATION_RGB16) => Some("RGB")
+          case Some(VipsInterpretation.INTERPRETATION_sRGB) => Some("RGB")
+          case _ => None
         }
-      case Png =>
-        val op = new IMOperation()
-        val formatter = format(op)("%[colorspace]")
-        val withSource = addDestImage(formatter)(sourceFile)
-
-        for {
-          output <- runIdentifyCmd(withSource, true)
-          colourModel = output.headOption
-        } yield colourModel match {
-          case Some("sRGB") => Some("RGB")
-          case Some("Gray") => Some("Greyscale")
-          case _ => Some("RGB")
+
+        colourModelInformation = Map {
+          "hasAlpha" -> image.hasAlpha.toString
         }
-      case _ =>
-        // assume that the colour model is RGB for other image types
-        Future.successful(Some("RGB"))
+      } catch {
+        case e: Exception =>
+          logger.error("Error during getImageInformation", e)
+          arena.close()
+          throw e
+      }
+      arena.close()
+
+      (dimensions, maybeExifOrientationWhichTransformsImage, colourModel, colourModelInformation)
+    }.map { result =>
+      logger.info(addLogMarkers(stopwatch.elapsed), "Finished getImageInformation")
+      result
     }
   }
+
 }