webp-ffi 0.4.0 → 1.0.0

data/ext/webp_ffi/tiffdec.c

@@ -1,48 +1,212 @@
 #include "./tiffdec.h"
+#include "./util.h"
 
+#include <stdarg.h>
+#include <sys/types.h>
 #include <tiffio.h>
+#include <tiffvers.h>
 
-int UtilReadTIFF(const char* const filename,
-                    WebPPicture* const pic, int keep_alpha) {
-  TIFF* const tif = TIFFOpen(filename, "r");
+// libtiff 4.5.0 added error and warning handlers per opened file.
+#if defined(TIFFLIB_AT_LEAST)
+#if TIFFLIB_AT_LEAST(4, 5, 0)
+#define UTIL_TIFF_HAS_OPEN_OPTIONS
+#endif
+#endif
+
+#ifdef UTIL_TIFF_HAS_OPEN_OPTIONS
+// libtiff prints errors and warnings to stderr by default. A library should
+// stay quiet. Returning 1 also stops libtiff from calling its global handlers.
+static int SilentTIFFHandler(TIFF* tif, void* user_data, const char* module,
+                             const char* fmt, va_list ap) {
+  (void)tif;
+  (void)user_data;
+  (void)module;
+  (void)fmt;
+  (void)ap;
+  return 1;
+}
+#endif
+
+// libtiff reads through these callbacks, so the same code works for files and
+// for in-memory data opened with fmemopen.
+static tmsize_t UtilTIFFRead(thandle_t handle, void* buffer, tmsize_t size) {
+  if (size <= 0) return 0;
+  return (tmsize_t)fread(buffer, 1, (size_t)size, (FILE*)handle);
+}
+
+static tmsize_t UtilTIFFWrite(thandle_t handle, void* buffer, tmsize_t size) {
+  (void)handle;
+  (void)buffer;
+  (void)size;
+  return 0;  // read only
+}
+
+static toff_t UtilTIFFSeek(thandle_t handle, toff_t offset, int whence) {
+  FILE* const file = (FILE*)handle;
+  if (fseeko(file, (off_t)offset, whence) != 0) return (toff_t)-1;
+  return (toff_t)ftello(file);
+}
+
+static int UtilTIFFClose(thandle_t handle) {
+  (void)handle;
+  return 0;  // the caller closes the file
+}
+
+static toff_t UtilTIFFSize(thandle_t handle) {
+  FILE* const file = (FILE*)handle;
+  const off_t position = ftello(file);
+  off_t size;
+  if (position < 0 || fseeko(file, 0, SEEK_END) != 0) return 0;
+  size = ftello(file);
+  fseeko(file, position, SEEK_SET);
+  return size < 0 ? 0 : (toff_t)size;
+}
+
+static int UtilTIFFMap(thandle_t handle, void** base, toff_t* size) {
+  (void)handle;
+  (void)base;
+  (void)size;
+  return 0;  // no memory mapping
+}
+
+static void UtilTIFFUnmap(thandle_t handle, void* base, toff_t size) {
+  (void)handle;
+  (void)base;
+  (void)size;
+}
+
+// "m" turns off memory mapping, which a FILE* can't provide
+static TIFF* OpenTIFF(FILE* const file) {
+#ifdef UTIL_TIFF_HAS_OPEN_OPTIONS
+  TIFF* tif;
+  TIFFOpenOptions* const opts = TIFFOpenOptionsAlloc();
+  if (opts == NULL) return NULL;
+  TIFFOpenOptionsSetErrorHandlerExtR(opts, SilentTIFFHandler, NULL);
+  TIFFOpenOptionsSetWarningHandlerExtR(opts, SilentTIFFHandler, NULL);
+  tif = TIFFClientOpenExt("webp-ffi", "rm", (thandle_t)file,
+                          UtilTIFFRead, UtilTIFFWrite, UtilTIFFSeek, UtilTIFFClose,
+                          UtilTIFFSize, UtilTIFFMap, UtilTIFFUnmap, opts);
+  TIFFOpenOptionsFree(opts);
+  return tif;
+#else
+  // Older libtiff only has process-wide handlers. Changing those would affect
+  // other code in the same process, so its messages still reach stderr.
+  return TIFFClientOpen("webp-ffi", "rm", (thandle_t)file,
+                        UtilTIFFRead, UtilTIFFWrite, UtilTIFFSeek, UtilTIFFClose,
+                        UtilTIFFSize, UtilTIFFMap, UtilTIFFUnmap);
+#endif
+}
+
+const char* UtilTIFFVersion(void) {
+  return TIFFGetVersion();
+}
+
+// libtiff's RGBA interface always returns premultiplied (associated) alpha,
+// whatever kind of alpha the file stores, so undo the multiplication.
+// Based on MultARGBRow in libwebp's imageio/tiffdec.c (taken from libwebp's
+// dsp/alpha_processing).
+#define MFIX 24    // 24bit fixed-point arithmetic
+#define HALF ((1u << MFIX) >> 1)
+
+static uint32_t Unmult(uint8_t x, uint32_t mult) {
+  const uint32_t v = (x * mult + HALF) >> MFIX;
+  return (v > 255u) ? 255u : v;
+}
+
+static uint32_t GetScale(uint32_t a) {
+  return (255u << MFIX) / a;
+}
+
+#undef MFIX
+#undef HALF
+
+static void UnmultiplyRow(uint8_t* ptr, uint32_t width) {
+  uint32_t x;
+  for (x = 0; x < width; ++x, ptr += 4) {
+    const uint32_t alpha = ptr[3];
+    if (alpha < 255) {
+      if (alpha == 0) {
+        ptr[0] = ptr[1] = ptr[2] = 0;
+      } else {
+        const uint32_t scale = GetScale(alpha);
+        ptr[0] = (uint8_t)Unmult(ptr[0], scale);
+        ptr[1] = (uint8_t)Unmult(ptr[1], scale);
+        ptr[2] = (uint8_t)Unmult(ptr[2], scale);
+      }
+    }
+  }
+}
+
+// True when the first extra sample is alpha, associated or not.
+static int HasAlphaSample(TIFF* const tif) {
+  uint16_t count = 0;
+  uint16_t* samples = NULL;
+  return TIFFGetField(tif, TIFFTAG_EXTRASAMPLES, &count, &samples) && count > 0 &&
+         samples != NULL && (samples[0] == EXTRASAMPLE_ASSOCALPHA ||
+                             samples[0] == EXTRASAMPLE_UNASSALPHA);
+}
+
+static int ExtractMetadataFromTIFF(TIFF* const tif, Metadata* const metadata) {
+  uint32_t length = 0;
+  void* data = NULL;
+  if (TIFFGetField(tif, TIFFTAG_ICCPROFILE, &length, &data) &&
+      !MetadataCopy(data, length, &metadata->iccp)) {
+    return 0;
+  }
+  length = 0;
+  data = NULL;
+  if (TIFFGetField(tif, TIFFTAG_XMLPACKET, &length, &data) &&
+      !MetadataCopy(data, length, &metadata->xmp)) {
+    return 0;
+  }
+  return 1;
+}
+
+int UtilReadTIFF(FILE* const in_file,
+                    WebPPicture* const pic, int keep_alpha,
+                    Metadata* const metadata) {
+  TIFF* const tif = OpenTIFF(in_file);
   uint32_t width, height;
   uint32_t* raster;
+  int stride;
+  size_t raster_size;
   int ok = 0;
-  int dircount = 1;
 
   if (tif == NULL) {
-    //fprintf(stderr, "Error! Cannot open TIFF file '%s'\n", filename);
     return 0;
   }
 
-  while (TIFFReadDirectory(tif)) ++dircount;
-
-  if (dircount > 1) {
-    fprintf(stderr, "Warning: multi-directory TIFF files are not supported.\n"
-                    "Only the first will be used, %d will be ignored.\n",
-                    dircount - 1);
+  // Multi-page TIFF files are not supported: only the first page is used.
+  if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) ||
+      !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height) ||
+      !UtilCheckImageSize(width, height, sizeof(*raster),
+                          &stride, &raster_size) ||
+      (metadata != NULL && !ExtractMetadataFromTIFF(tif, metadata))) {
+    TIFFClose(tif);
+    return 0;
   }
 
-  TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
-  TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
-  raster = (uint32_t*)_TIFFmalloc(width * height * sizeof(*raster));
+  raster = (uint32_t*)_TIFFmalloc(raster_size);
   if (raster != NULL) {
     if (TIFFReadRGBAImageOriented(tif, width, height, raster,
                                   ORIENTATION_TOPLEFT, 1)) {
-      const int stride = width * sizeof(*raster);
-      pic->width = width;
-      pic->height = height;
+      pic->width = (int)width;
+      pic->height = (int)height;
       // TIFF data is ABGR
 #ifdef __BIG_ENDIAN__
-      TIFFSwabArrayOfLong(raster, width * height);
+      TIFFSwabArrayOfLong(raster, raster_size / sizeof(*raster));
 #endif
+      if (keep_alpha && HasAlphaSample(tif)) {
+        uint32_t y;
+        for (y = 0; y < height; ++y) {
+          UnmultiplyRow((uint8_t*)raster + (size_t)y * stride, width);
+        }
+      }
       ok = keep_alpha
          ? WebPPictureImportRGBA(pic, (const uint8_t*)raster, stride)
          : WebPPictureImportRGBX(pic, (const uint8_t*)raster, stride);
     }
     _TIFFfree(raster);
-  } else {
-    //fprintf(stderr, "Error allocating TIFF RGBA memory!\n");
   }
 
   if (ok && keep_alpha == 2) {

data/ext/webp_ffi/tiffdec.h

@@ -3,21 +3,29 @@
 
 #include "webp/encode.h"
 #include "webp/decode.h"
+#include "./metadata.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// Reads a TIFF from 'filename', returning the decoded output in 'pic'.
+// Reads a TIFF from 'in_file', returning the decoded output in 'pic'.
 // If 'keep_alpha' is true and the TIFF has an alpha channel, the output is RGBA
-// otherwise it will be RGB.
+// otherwise it will be RGB. 'in_file' must be seekable and stays open.
+// When 'metadata' is not NULL, the ICC profile and XMP data are copied into it.
+// Like libwebp's own reader, EXIF is not read from TIFF files.
 // Returns true on success.
-int UtilReadTIFF(const char* const filename,
-             struct WebPPicture* const pic, int keep_alpha);
+int UtilReadTIFF(FILE* const in_file,
+             struct WebPPicture* const pic, int keep_alpha,
+             Metadata* const metadata);
 
 int UtilWriteTIFF(FILE* fout, const WebPDecBuffer* const buffer);
 int UtilWriteBMP(FILE* fout, const WebPDecBuffer* const buffer);
 
+// Version string of the libtiff in use. Prebuilt gems keep the bundled
+// libtiff symbols private, so the specs ask through this function.
+const char* UtilTIFFVersion(void);
+
 #ifdef __cplusplus
 }    // extern "C"
 #endif

data/ext/webp_ffi/util.c

@@ -1,3 +1,5 @@
+#include <limits.h>
+#include <sys/stat.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -14,6 +16,34 @@
 extern "C" {
 #endif
 
+// Same memory cap as the image readers in libwebp (imageio/imageio_util.c).
+#if SIZE_MAX > (1ULL << 34)
+#define UTIL_MAX_ALLOCABLE_MEMORY (1ULL << 34)
+#else
+#define UTIL_MAX_ALLOCABLE_MEMORY ((1ULL << 31) - (1 << 16))
+#endif
+#define UTIL_MAX_BYTES_PER_PIXEL 8
+
+int UtilCheckImageSize(uint64_t width, uint64_t height, uint64_t bytes_per_px,
+                       int* const stride, size_t* const size) {
+  uint64_t row_size, total_size;
+
+  if (width == 0 || height == 0) return 0;
+  if (bytes_per_px == 0 || bytes_per_px > UTIL_MAX_BYTES_PER_PIXEL) return 0;
+  // WebPPicture and the row strides passed to libwebp are plain ints.
+  if (width > INT_MAX || height > INT_MAX) return 0;
+
+  // Both products stay far below 2^64 because of the limits checked above.
+  row_size = width * bytes_per_px;
+  if (row_size > INT_MAX) return 0;
+  total_size = row_size * height;
+  if (total_size > UTIL_MAX_ALLOCABLE_MEMORY) return 0;
+
+  if (stride != NULL) *stride = (int)row_size;
+  if (size != NULL) *size = (size_t)total_size;
+  return 1;
+}
+
 static int UtilReadYUV(FILE* in_file, WebPPicture* const pic) {
   const int use_argb = pic->use_argb;
   const int uv_width = (pic->width + 1) / 2;
@@ -54,7 +84,9 @@ static InputFileFormat GetImageType(FILE* in_file) {
     return format;
   }
 
-  magic = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+  // shift unsigned values: buf[0] << 24 as an int overflows for bytes >= 0x80
+  magic = ((unsigned int)buf[0] << 24) | ((unsigned int)buf[1] << 16) |
+          ((unsigned int)buf[2] << 8) | buf[3];
   if (magic == 0x89504E47U) {
     format = iPNG_;
   } else if (magic >= 0xFFD8FF00U && magic <= 0xFFD8FFFFU) {
@@ -65,44 +97,53 @@ static InputFileFormat GetImageType(FILE* in_file) {
   return format;
 }
 
-int UtilReadPicture(const char* const filename, WebPPicture* const pic,
-                       int keep_alpha) {
+int UtilReadPictureFile(FILE* const in_file, WebPPicture* const pic,
+                        int keep_alpha, Metadata* const metadata) {
   int ok = 0;
-  FILE* in_file = fopen(filename, "rb");
-  if (in_file == NULL) {
-    //fprintf(stderr, "Error! Cannot open input file '%s'\n", filename);
-    return ok;
-  }
 
   if (pic->width == 0 || pic->height == 0) {
-    // If no size specified, try to decode it as PNG/JPEG (as appropriate).
+    // If no size specified, try to decode it as PNG/JPEG/TIFF (as appropriate).
     const InputFileFormat format = GetImageType(in_file);
     if (format == iPNG_) {
-      ok = UtilReadPNG(in_file, pic, keep_alpha);
+      ok = UtilReadPNG(in_file, pic, keep_alpha, metadata);
     } else if (format == iJPEG_) {
-      ok = UtilReadJPEG(in_file, pic);
+      ok = UtilReadJPEG(in_file, pic, metadata);
     } else if (format == iTIFF_) {
-      ok = UtilReadTIFF(filename, pic, keep_alpha);
+      ok = UtilReadTIFF(in_file, pic, keep_alpha, metadata);
     }
   } else {
     // If image size is specified, infer it as YUV format.
     ok = UtilReadYUV(in_file, pic);
   }
-
-  fclose(in_file);
   return ok;
 }
 
+int UtilFileExists(const char* const path) {
+  struct stat info;
+  return stat(path, &info) == 0;
+}
+
 int UtilSaveOutput(const WebPDecBuffer* const buffer,
                        OutputFileFormat format, const char* const out_file) {
-  FILE* fout = NULL;
-  int ok = 1;
-
-  fout = fopen(out_file, "wb");
+  // a failed write removes the file, but only when this call created it
+  const int existed = UtilFileExists(out_file);
+  int ok;
+  FILE* const fout = fopen(out_file, "wb");
   if (!fout) {
-    fprintf(stderr, "Error opening output file %s\n", out_file);
     return 0;
   }
+  ok = UtilWriteOutput(buffer, format, fout);
+  // fclose flushes buffered data, so it can also fail (for example, disk full)
+  if (fclose(fout) != 0) {
+    ok = 0;
+  }
+  if (!ok && !existed) remove(out_file);
+  return ok;
+}
+
+int UtilWriteOutput(const WebPDecBuffer* const buffer,
+                    OutputFileFormat format, FILE* const fout) {
+  int ok = 1;
 
   if (format == oPNG) {
     ok &= UtilWritePNG(fout, buffer);
@@ -114,14 +155,14 @@ int UtilSaveOutput(const WebPDecBuffer* const buffer,
     ok &= UtilWriteBMP(fout, buffer);
   } else if (format == oTIFF_) {
     ok &= UtilWriteTIFF(fout, buffer);
-  } else if (format == oPGM || format == oYUV) {
+  } else if (format == oPGM) {
     ok &= UtilWritePGM(fout, buffer);
+  } else if (format == oYUV) {
+    ok &= UtilWriteYUV(fout, buffer);
   } else if (format == ALPHA_PLANE_ONLY) {
     ok &= UtilWriteAlphaPlane(fout, buffer);
-  }
-
-  if (fout) {
-    fclose(fout);
+  } else {
+    ok = 0;
   }
   return ok;
 }
@@ -133,7 +174,8 @@ int UtilReadFile(const char* const file_name,
                    const uint8_t** data, size_t* data_size) {
   int ok;
   void* file_data;
-  size_t file_size;
+  long file_size;
+  struct stat info;
   FILE* in;
 
   if (file_name == NULL || data == NULL || data_size == NULL) return 0;
@@ -142,25 +184,30 @@ int UtilReadFile(const char* const file_name,
 
   in = fopen(file_name, "rb");
   if (in == NULL) {
-    fprintf(stderr, "cannot open input file '%s'\n", file_name);
     return 0;
   }
-  fseek(in, 0, SEEK_END);
-  file_size = ftell(in);
-  fseek(in, 0, SEEK_SET);
-  file_data = malloc(file_size);
-  if (file_data == NULL) return 0;
-  ok = (fread(file_data, file_size, 1, in) == 1);
+  // only regular files: on Linux a folder opens and reports a huge size
+  if (fstat(fileno(in), &info) != 0 || !S_ISREG(info.st_mode) ||
+      fseek(in, 0, SEEK_END) != 0 ||
+      (file_size = ftell(in)) <= 0 ||
+      fseek(in, 0, SEEK_SET) != 0) {
+    fclose(in);
+    return 0;
+  }
+  file_data = malloc((size_t)file_size);
+  if (file_data == NULL) {
+    fclose(in);
+    return 0;
+  }
+  ok = (fread(file_data, (size_t)file_size, 1, in) == 1);
   fclose(in);
 
   if (!ok) {
-    fprintf(stderr, "Could not read %zu bytes of data from file %s\n",
-            file_size, file_name);
     free(file_data);
     return 0;
   }
   *data = (uint8_t*)file_data;
-  *data_size = file_size;
+  *data_size = (size_t)file_size;
   return 1;
 }
 

data/ext/webp_ffi/util.h

@@ -1,5 +1,13 @@
+#ifndef _WEBP_FFI_UTIL_H_
+#define _WEBP_FFI_UTIL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
 #include "webp/decode.h"
 #include "webp/encode.h"
+#include "./metadata.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -23,16 +31,33 @@ typedef enum {
   UNSUPPORTED
 } InputFileFormat;
 
+// Writes 'buffer' to 'out_file'. When writing fails, a file this call created
+// is removed again. Returns 1 on success.
 int UtilSaveOutput(const WebPDecBuffer* const buffer, OutputFileFormat format, const char* const out_file);
+int UtilFileExists(const char* const path);
+// Writes 'buffer' in 'format' to an open file. Returns 1 on success.
+int UtilWriteOutput(const WebPDecBuffer* const buffer, OutputFileFormat format, FILE* const fout);
 // Allocates storage for entire file 'file_name' and returns contents and size
 // in 'data' and 'data_size'. Returns 1 on success, 0 otherwise. '*data' should
 // be deleted using free().
 int UtilReadFile(const char* const file_name,
                    const uint8_t** data, size_t* data_size);
 
-int UtilReadPicture(const char* const filename, WebPPicture* const pic,
-                      int keep_alpha);
+// Reads a PNG, JPEG or TIFF picture from an open file (or raw YUV when the
+// picture already has a size). When 'metadata' is not NULL, the picture's
+// metadata is copied into it. Returns 1 on success.
+int UtilReadPictureFile(FILE* const in_file, WebPPicture* const pic,
+                        int keep_alpha, Metadata* const metadata);
+
+// Checks that a 'width' x 'height' image with 'bytes_per_px' bytes per pixel
+// fits in memory, using 64-bit math so the size can't wrap around.
+// Returns 1 on success and stores the row size in 'stride' and the buffer size
+// in 'size' (either pointer may be NULL). Returns 0 for empty or oversized images.
+int UtilCheckImageSize(uint64_t width, uint64_t height, uint64_t bytes_per_px,
+                       int* const stride, size_t* const size);
 
 #if defined(__cplusplus) || defined(c_plusplus)
 }    // extern "C"
-#endif
+#endif
+
+#endif  /* _WEBP_FFI_UTIL_H_ */