webp-ffi 0.4.0 → 1.0.0

data/ext/webp_ffi/metadata.c

@@ -0,0 +1,138 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "./metadata.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+// Based on WriteWebPWithMetadata in libwebp's examples/cwebp.c.
+
+#define TAG_SIZE 4
+#define CHUNK_HEADER_SIZE 8
+#define RIFF_HEADER_SIZE 12
+#define VP8X_CHUNK_SIZE 18  // chunk header and 10 bytes of payload
+#define MAX_RIFF_SIZE 0xfffffff6ULL  // the RIFF size is a 32-bit even number
+
+// VP8X flags
+#define FLAG_ICCP  0x20
+#define FLAG_ALPHA 0x10
+#define FLAG_EXIF  0x08
+#define FLAG_XMP   0x04
+
+void MetadataInit(Metadata* const metadata) {
+  memset(metadata, 0, sizeof(*metadata));
+}
+
+static void PayloadFree(MetadataPayload* const payload) {
+  free(payload->bytes);
+  payload->bytes = NULL;
+  payload->size = 0;
+}
+
+void MetadataFree(Metadata* const metadata) {
+  PayloadFree(&metadata->exif);
+  PayloadFree(&metadata->iccp);
+  PayloadFree(&metadata->xmp);
+}
+
+int MetadataCopy(const void* const data, size_t size,
+                 MetadataPayload* const payload) {
+  if (payload->bytes != NULL || data == NULL || size == 0) return 1;
+  payload->bytes = (uint8_t*)malloc(size);
+  if (payload->bytes == NULL) return 0;
+  memcpy(payload->bytes, data, size);
+  payload->size = size;
+  return 1;
+}
+
+static int WriteLE(FILE* const out, uint32_t value, int bytes) {
+  uint8_t buffer[4];
+  int i;
+  for (i = 0; i < bytes; ++i) {
+    buffer[i] = (uint8_t)((value >> (8 * i)) & 0xff);
+  }
+  return fwrite(buffer, (size_t)bytes, 1, out) == 1;
+}
+
+// Chunk payloads have an even size; odd ones get one zero byte of padding.
+static uint64_t ChunkSize(const MetadataPayload* const payload) {
+  return CHUNK_HEADER_SIZE + (uint64_t)payload->size + (payload->size & 1);
+}
+
+static int WriteChunk(FILE* const out, const char* const tag,
+                      const MetadataPayload* const payload) {
+  const uint8_t zero = 0;
+  int ok = (fwrite(tag, TAG_SIZE, 1, out) == 1);
+  ok = ok && WriteLE(out, (uint32_t)payload->size, 4);
+  ok = ok && (fwrite(payload->bytes, payload->size, 1, out) == 1);
+  if (payload->size & 1) ok = ok && (fwrite(&zero, 1, 1, out) == 1);
+  return ok;
+}
+
+int MetadataWriteWebP(FILE* const out, const uint8_t* webp, size_t webp_size,
+                      int width, int height, const Metadata* const metadata,
+                      int keep) {
+  const int write_exif = (keep & METADATA_EXIF) && metadata->exif.size > 0;
+  const int write_iccp = (keep & METADATA_ICC) && metadata->iccp.size > 0;
+  const int write_xmp = (keep & METADATA_XMP) && metadata->xmp.size > 0;
+  uint32_t flags = 0;
+  uint64_t metadata_size = 0;
+  uint64_t riff_size;
+  int has_vp8x;
+  int ok;
+
+  if (webp_size < RIFF_HEADER_SIZE + CHUNK_HEADER_SIZE) return 0;
+  if (!write_exif && !write_iccp && !write_xmp) {
+    return fwrite(webp, webp_size, 1, out) == 1;
+  }
+
+  if (write_exif) { flags |= FLAG_EXIF; metadata_size += ChunkSize(&metadata->exif); }
+  if (write_iccp) { flags |= FLAG_ICCP; metadata_size += ChunkSize(&metadata->iccp); }
+  if (write_xmp)  { flags |= FLAG_XMP;  metadata_size += ChunkSize(&metadata->xmp); }
+
+  has_vp8x = !memcmp(webp + RIFF_HEADER_SIZE, "VP8X", TAG_SIZE);
+  riff_size = (uint64_t)webp_size - CHUNK_HEADER_SIZE +
+              (has_vp8x ? 0 : VP8X_CHUNK_SIZE) + metadata_size;
+  if (riff_size > MAX_RIFF_SIZE) return 0;
+
+  // "RIFF", the new size, then "WEBP"
+  ok = (fwrite(webp, TAG_SIZE, 1, out) == 1);
+  ok = ok && WriteLE(out, (uint32_t)riff_size, 4);
+  ok = ok && (fwrite(webp + CHUNK_HEADER_SIZE, TAG_SIZE, 1, out) == 1);
+  webp += RIFF_HEADER_SIZE;
+  webp_size -= RIFF_HEADER_SIZE;
+
+  if (has_vp8x) {
+    // lossy with alpha: the encoder already wrote a VP8X chunk, add our flags
+    uint8_t vp8x[VP8X_CHUNK_SIZE];
+    memcpy(vp8x, webp, VP8X_CHUNK_SIZE);
+    vp8x[CHUNK_HEADER_SIZE] |= (uint8_t)(flags & 0xff);
+    ok = ok && (fwrite(vp8x, VP8X_CHUNK_SIZE, 1, out) == 1);
+    webp += VP8X_CHUNK_SIZE;
+    webp_size -= VP8X_CHUNK_SIZE;
+  } else {
+    // lossless images keep their alpha bit in the VP8L header
+    if (!memcmp(webp, "VP8L", TAG_SIZE) && webp_size > CHUNK_HEADER_SIZE + 4 &&
+        (webp[CHUNK_HEADER_SIZE + 4] & (1 << 4))) {
+      flags |= FLAG_ALPHA;
+    }
+    ok = ok && (fwrite("VP8X", TAG_SIZE, 1, out) == 1);
+    ok = ok && WriteLE(out, VP8X_CHUNK_SIZE - CHUNK_HEADER_SIZE, 4);
+    ok = ok && WriteLE(out, flags, 4);
+    ok = ok && WriteLE(out, (uint32_t)(width - 1), 3);
+    ok = ok && WriteLE(out, (uint32_t)(height - 1), 3);
+  }
+
+  // the chunk order is fixed: ICCP, image data, EXIF, XMP
+  if (write_iccp) ok = ok && WriteChunk(out, "ICCP", &metadata->iccp);
+  ok = ok && (fwrite(webp, webp_size, 1, out) == 1);
+  if (write_exif) ok = ok && WriteChunk(out, "EXIF", &metadata->exif);
+  if (write_xmp) ok = ok && WriteChunk(out, "XMP ", &metadata->xmp);
+  return ok;
+}
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    // extern "C"
+#endif

data/ext/webp_ffi/metadata.h

@@ -0,0 +1,49 @@
+#ifndef _WEBP_FFI_METADATA_H_
+#define _WEBP_FFI_METADATA_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+// Which metadata to copy from the input picture into the WebP file.
+#define METADATA_EXIF 1
+#define METADATA_ICC  2
+#define METADATA_XMP  4
+#define METADATA_ALL  (METADATA_EXIF | METADATA_ICC | METADATA_XMP)
+
+typedef struct {
+  uint8_t* bytes;
+  size_t size;
+} MetadataPayload;
+
+typedef struct {
+  MetadataPayload exif;
+  MetadataPayload iccp;
+  MetadataPayload xmp;
+} Metadata;
+
+void MetadataInit(Metadata* const metadata);
+void MetadataFree(Metadata* const metadata);
+
+// Copies 'size' bytes into an empty 'payload'. Returns 1 on success, or when
+// the payload already holds data (the first copy wins). Returns 0 when out of
+// memory.
+int MetadataCopy(const void* const data, size_t size, MetadataPayload* const payload);
+
+// Writes a complete WebP file to 'out': the encoder output 'webp' plus the
+// metadata selected by 'keep' (METADATA_* flags), using the extended format
+// (VP8X) when any metadata is written. 'width' and 'height' are the size of the
+// encoded picture. Returns 1 on success.
+int MetadataWriteWebP(FILE* const out, const uint8_t* webp, size_t webp_size,
+                      int width, int height, const Metadata* const metadata,
+                      int keep);
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    // extern "C"
+#endif
+
+#endif  /* _WEBP_FFI_METADATA_H_ */

data/ext/webp_ffi/pngdec.c

@@ -1,4 +1,5 @@
 #include "./pngdec.h"
+#include "./util.h"
 
 #include <assert.h>
 #include <stdio.h>
@@ -12,10 +13,146 @@ static void PNGAPI error_function(png_structp png, png_const_charp dummy) {
   longjmp(png_jmpbuf(png), 1);
 }
 
-int UtilReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha) {
-  png_structp png;
-  png_infop info = NULL;
-  png_infop end_info = NULL;
+// libpng prints warnings to stderr by default. A library should stay quiet.
+static void PNGAPI warning_function(png_structp png, png_const_charp dummy) {
+  (void)png;
+  (void)dummy;
+}
+
+// The metadata code below is based on libwebp's imageio/pngdec.c.
+
+// Converts pairs of hex digits, possibly split by newlines, to 'length' bytes.
+// Returns NULL for other characters or when there are fewer bytes.
+static uint8_t* HexStringToBytes(const char* hexstring, size_t length) {
+  const char* src = hexstring;
+  size_t actual_length = 0;
+  uint8_t* const raw_data = (uint8_t*)malloc(length > 0 ? length : 1);
+  uint8_t* dst;
+
+  if (raw_data == NULL) return NULL;
+  for (dst = raw_data; actual_length < length && *src != '\0'; ++src) {
+    char* end;
+    char value[3];
+    if (*src == '\n') continue;
+    value[0] = *src++;
+    value[1] = *src;
+    value[2] = '\0';
+    *dst++ = (uint8_t)strtol(value, &end, 16);
+    if (end != value + 2) break;
+    ++actual_length;
+  }
+  if (actual_length != length) {
+    free(raw_data);
+    return NULL;
+  }
+  return raw_data;
+}
+
+// ImageMagick and ExifTool store metadata in text chunks as "raw profiles":
+// "\n<name>\n<length>\n<hex data>\n".
+static int ProcessRawProfile(const char* profile, size_t profile_length,
+                             MetadataPayload* const payload) {
+  const char* src = profile;
+  char* end;
+  long length;
+
+  if (profile == NULL || profile_length == 0 || *src != '\n') return 0;
+  ++src;
+  while (*src != '\0' && *src++ != '\n') {}  // skip the profile name
+  length = strtol(src, &end, 10);
+  if (*end != '\n') return 0;
+  ++end;
+  // two hex digits per byte, so a longer length cannot be right
+  if (length < 0 || (size_t)length > profile_length / 2) return 0;
+  payload->bytes = HexStringToBytes(end, (size_t)length);
+  if (payload->bytes == NULL) return 0;
+  payload->size = (size_t)length;
+  return 1;
+}
+
+static int CopyText(const char* text, size_t length, MetadataPayload* const payload) {
+  return MetadataCopy(text, length, payload);
+}
+
+static const struct {
+  const char* key;
+  int (*process)(const char* text, size_t length, MetadataPayload* const payload);
+  int kind;  // METADATA_* flag
+} kPNGTextMetadata[] = {
+  // https://exiftool.org/TagNames/PNG.html#TextualData
+  { "Raw profile type exif", ProcessRawProfile, METADATA_EXIF },
+  { "Raw profile type xmp",  ProcessRawProfile, METADATA_XMP },
+  // ExifTool puts EXIF data in an APP1 profile too; ImageMagick in "app1".
+  { "Raw profile type APP1", ProcessRawProfile, METADATA_EXIF },
+  { "Raw profile type app1", ProcessRawProfile, METADATA_EXIF },
+  // XMP Specification Part 3, Section 3 #PNG
+  { "XML:com.adobe.xmp",     CopyText,          METADATA_XMP },
+  { NULL, NULL, 0 }
+};
+
+// Looks for metadata before and after the image data, preferring what comes
+// first. Like libwebp, an eXIf chunk wins over EXIF in text chunks.
+static int ExtractMetadataFromPNG(png_structp png, png_infop info,
+                                  png_infop end_info, Metadata* const metadata) {
+  int p;
+  for (p = 0; p < 2; ++p) {
+    png_infop const head = (p == 0) ? info : end_info;
+    png_textp text = NULL;
+    const png_uint_32 count = png_get_text(png, head, &text, NULL);
+    png_uint_32 i;
+
+#ifdef PNG_eXIf_SUPPORTED
+    {
+      png_bytep exif = NULL;
+      png_uint_32 length = 0;
+      if (png_get_eXIf_1(png, head, &length, &exif) == PNG_INFO_eXIf &&
+          !MetadataCopy(exif, length, &metadata->exif)) {
+        return 0;
+      }
+    }
+#endif
+
+    for (i = 0; i < count; ++i, ++text) {
+      int j;
+      for (j = 0; kPNGTextMetadata[j].key != NULL; ++j) {
+        if (text->key != NULL && !strcmp(text->key, kPNGTextMetadata[j].key)) {
+          MetadataPayload* const payload =
+              (kPNGTextMetadata[j].kind == METADATA_EXIF) ? &metadata->exif : &metadata->xmp;
+          // iTXt chunks keep their length in a separate field
+          const size_t length = (text->compression == PNG_ITXT_COMPRESSION_NONE ||
+                                 text->compression == PNG_ITXT_COMPRESSION_zTXt)
+                                    ? text->itxt_length : text->text_length;
+          // the first one wins; like cwebp, a broken one fails the read
+          if (payload->bytes == NULL &&
+              !kPNGTextMetadata[j].process(text->text, length, payload)) {
+            return 0;
+          }
+          break;
+        }
+      }
+    }
+
+    {
+      png_charp name;
+      int compression_type;
+      png_bytep profile;
+      png_uint_32 length;
+      if (png_get_iCCP(png, head, &name, &compression_type, &profile, &length) == PNG_INFO_iCCP &&
+          !MetadataCopy(profile, length, &metadata->iccp)) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+int UtilReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha,
+                Metadata* const metadata) {
+  // Locals that change after setjmp() must be volatile, otherwise their values
+  // are undefined when libpng jumps back to the error handler.
+  volatile png_structp png = NULL;
+  volatile png_infop info = NULL;
+  volatile png_infop end_info = NULL;
   int color_type, bit_depth, interlaced;
   int has_alpha;
   int num_passes;
@@ -23,17 +160,19 @@ int UtilReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha) {
   int ok = 0;
   png_uint_32 width, height, y;
   int stride;
-  uint8_t* rgb = NULL;
+  size_t rgb_size;
+  uint8_t* volatile rgb = NULL;
 
-  png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
+  png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
   if (png == NULL) {
     goto End;
   }
 
-  png_set_error_fn(png, 0, error_function, NULL);
+  png_set_error_fn(png, NULL, error_function, warning_function);
   if (setjmp(png_jmpbuf(png))) {
  Error:
-    png_destroy_read_struct(&png, &info, &end_info);
+    png_destroy_read_struct((png_structpp)&png, (png_infopp)&info,
+                            (png_infopp)&end_info);
     goto End;
   }
 
@@ -72,28 +211,31 @@ int UtilReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha) {
 
   num_passes = png_set_interlace_handling(png);
   png_read_update_info(png, info);
-  stride = (has_alpha ? 4 : 3) * width * sizeof(*rgb);
-  rgb = (uint8_t*)malloc(stride * height);
+  if (!UtilCheckImageSize(width, height, has_alpha ? 4 : 3,
+                          &stride, &rgb_size)) {
+    goto Error;
+  }
+  rgb = (uint8_t*)malloc(rgb_size);
   if (rgb == NULL) goto Error;
   for (p = 0; p < num_passes; ++p) {
     for (y = 0; y < height; ++y) {
-      png_bytep row = rgb + y * stride;
+      png_bytep row = rgb + (size_t)y * stride;
       png_read_rows(png, &row, NULL, 1);
     }
   }
   png_read_end(png, end_info);
-  png_destroy_read_struct(&png, &info, &end_info);
+  if (metadata != NULL && !ExtractMetadataFromPNG(png, info, end_info, metadata)) {
+    goto Error;
+  }
+  png_destroy_read_struct((png_structpp)&png, (png_infopp)&info,
+                          (png_infopp)&end_info);
 
-  pic->width = width;
-  pic->height = height;
+  pic->width = (int)width;
+  pic->height = (int)height;
   pic->use_argb = 1;
   ok = has_alpha ? WebPPictureImportRGBA(pic, rgb, stride)
                  : WebPPictureImportRGB(pic, rgb, stride);
 
-  if (!ok) {
-    goto Error;
-  }
-
  End:
   free(rgb);
   return ok;
@@ -114,7 +256,7 @@ int UtilWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
   png_uint_32 y;
 
   png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
-                                NULL, error_function, NULL);
+                                NULL, error_function, warning_function);
   if (png == NULL) {
     return 0;
   }
@@ -209,4 +351,39 @@ int UtilWritePGM(FILE* fout, const WebPDecBuffer* const buffer) {
     if (width & 1) fputc(0, fout);    // padding byte
   }
   return ok;
-}
+}
+
+// Based on WebPWriteYUV in libwebp's imageio/image_enc.c.
+int UtilWriteYUV(FILE* fout, const WebPDecBuffer* const buffer) {
+  const int width = buffer->width;
+  const int height = buffer->height;
+  const WebPYUVABuffer* const yuv = &buffer->u.YUVA;
+  const uint8_t* src_y = yuv->y;
+  const uint8_t* src_u = yuv->u;
+  const uint8_t* src_v = yuv->v;
+  const uint8_t* src_a = yuv->a;
+  const int uv_width = (width + 1) / 2;
+  const int uv_height = (height + 1) / 2;
+  const int a_height = (src_a != NULL) ? height : 0;
+  int ok = 1;
+  int y;
+
+  if (src_y == NULL || src_u == NULL || src_v == NULL) return 0;
+  for (y = 0; ok && y < height; ++y) {
+    ok &= (fwrite(src_y, width, 1, fout) == 1);
+    src_y += yuv->y_stride;
+  }
+  for (y = 0; ok && y < uv_height; ++y) {
+    ok &= (fwrite(src_u, uv_width, 1, fout) == 1);
+    src_u += yuv->u_stride;
+  }
+  for (y = 0; ok && y < uv_height; ++y) {
+    ok &= (fwrite(src_v, uv_width, 1, fout) == 1);
+    src_v += yuv->v_stride;
+  }
+  for (y = 0; ok && y < a_height; ++y) {
+    ok &= (fwrite(src_a, width, 1, fout) == 1);
+    src_a += yuv->a_stride;
+  }
+  return ok;
+}

data/ext/webp_ffi/pngdec.h

@@ -3,6 +3,7 @@
 
 #include "webp/encode.h"
 #include "webp/decode.h"
+#include "./metadata.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -10,14 +11,18 @@ extern "C" {
 
 // Reads a PNG from 'in_file', returning the decoded output in 'pic'.
 // If 'keep_alpha' is true and the PNG has an alpha channel, the output is RGBA
-// otherwise it will be RGB.
+// otherwise it will be RGB. When 'metadata' is not NULL, the ICC profile, EXIF
+// and XMP data are copied into it.
 // Returns true on success.
-int UtilReadPNG(FILE* in_file, struct WebPPicture* const pic, int keep_alpha);
+int UtilReadPNG(FILE* in_file, struct WebPPicture* const pic, int keep_alpha,
+                Metadata* const metadata);
 
 int UtilWritePNG(FILE* out_file, const WebPDecBuffer* const buffer);
 int UtilWritePPM(FILE* fout, const WebPDecBuffer* const buffer, int alpha);
 int UtilWriteAlphaPlane(FILE* fout, const WebPDecBuffer* const buffer);
 int UtilWritePGM(FILE* fout, const WebPDecBuffer* const buffer);
+// Raw planes: Y, then U and V (half size, rounded up), then alpha if any.
+int UtilWriteYUV(FILE* fout, const WebPDecBuffer* const buffer);
 
 #ifdef __cplusplus
 }    // extern "C"