webp-ffi 1.0.0-x86_64-linux-gnu

data/ext/webp_ffi/jpegdec.c

@@ -0,0 +1,174 @@
+#include "./jpegdec.h"
+#include "./util.h"
+
+#include <stdio.h>
+#include <jpeglib.h>
+#include <setjmp.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct my_error_mgr {
+  struct jpeg_error_mgr pub;
+  jmp_buf setjmp_buffer;
+};
+
+static void my_error_exit(j_common_ptr dinfo) {
+  struct my_error_mgr* myerr = (struct my_error_mgr*) dinfo->err;
+  longjmp(myerr->setjmp_buffer, 1);
+}
+
+// libjpeg prints errors and warnings to stderr by default. A library should
+// stay quiet.
+static void my_output_message(j_common_ptr dinfo) {
+  (void)dinfo;
+}
+
+// Based on the metadata code in libwebp's imageio/jpegdec.c.
+
+// An ICC profile can be split over several APP2 segments:
+// "ICC_PROFILE\0", the 1-based sequence number, the segment count, then data.
+static int StoreICCP(j_decompress_ptr dinfo, MetadataPayload* const iccp) {
+  static const char kSignature[] = "ICC_PROFILE";  // 12 bytes with the '\0'
+  const size_t signature_length = sizeof(kSignature);
+  const size_t header_length = signature_length + 2;
+  const JOCTET* segments[256];
+  size_t lengths[256];
+  int expected_count = 0;
+  int found = 0;
+  size_t total_size = 0;
+  size_t offset = 0;
+  jpeg_saved_marker_ptr marker;
+  int i;
+
+  memset(lengths, 0, sizeof(lengths));
+  for (marker = dinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker->marker == JPEG_APP0 + 2 && marker->data_length > header_length &&
+        !memcmp(marker->data, kSignature, signature_length)) {
+      const int seq = marker->data[signature_length];
+      const int count = marker->data[signature_length + 1];
+      if (seq == 0 || count == 0 || seq > count) return 0;
+      if (expected_count == 0) expected_count = count;
+      if (count != expected_count || lengths[seq] != 0) return 0;
+      segments[seq] = marker->data + header_length;
+      lengths[seq] = marker->data_length - header_length;
+      total_size += lengths[seq];
+      ++found;
+    }
+  }
+  if (found == 0) return 1;  // no profile
+  if (found != expected_count) return 0;  // missing segments
+
+  iccp->bytes = (uint8_t*)malloc(total_size);
+  if (iccp->bytes == NULL) return 0;
+  for (i = 1; i <= expected_count; ++i) {  // in sequence order
+    memcpy(iccp->bytes + offset, segments[i], lengths[i]);
+    offset += lengths[i];
+  }
+  iccp->size = total_size;
+  return 1;
+}
+
+// EXIF and XMP live in APP1 segments, after a signature that is not copied.
+static int ExtractMetadataFromJPEG(j_decompress_ptr dinfo,
+                                   Metadata* const metadata) {
+  static const char kExifSignature[] = "Exif\0";  // "Exif\0\0", 6 bytes
+  static const char kXMPSignature[] = "http://ns.adobe.com/xap/1.0/";  // 29 bytes
+  jpeg_saved_marker_ptr marker;
+
+  if (!StoreICCP(dinfo, &metadata->iccp)) return 0;
+  for (marker = dinfo->marker_list; marker != NULL; marker = marker->next) {
+    if (marker->marker != JPEG_APP0 + 1) continue;
+    if (marker->data_length > sizeof(kExifSignature) &&
+        !memcmp(marker->data, kExifSignature, sizeof(kExifSignature))) {
+      if (!MetadataCopy(marker->data + sizeof(kExifSignature),
+                        marker->data_length - sizeof(kExifSignature),
+                        &metadata->exif)) {
+        return 0;
+      }
+    } else if (marker->data_length > sizeof(kXMPSignature) &&
+               !memcmp(marker->data, kXMPSignature, sizeof(kXMPSignature))) {
+      if (!MetadataCopy(marker->data + sizeof(kXMPSignature),
+                        marker->data_length - sizeof(kXMPSignature),
+                        &metadata->xmp)) {
+        return 0;
+      }
+    }
+  }
+  return 1;
+}
+
+int UtilReadJPEG(FILE* in_file, WebPPicture* const pic,
+                 Metadata* const metadata) {
+  int ok = 0;
+  int stride, width, height;
+  size_t rgb_size;
+  // 'rgb' changes after setjmp(), so it must be volatile to keep its value
+  // when libjpeg jumps back to the error handler.
+  uint8_t* volatile rgb = NULL;
+  struct jpeg_decompress_struct dinfo;
+  struct my_error_mgr jerr;
+  JSAMPROW buffer[1];
+
+  dinfo.err = jpeg_std_error(&jerr.pub);
+  jerr.pub.error_exit = my_error_exit;
+  jerr.pub.output_message = my_output_message;
+
+  if (setjmp(jerr.setjmp_buffer)) {
+ Error:
+    jpeg_destroy_decompress(&dinfo);
+    goto End;
+  }
+
+  jpeg_create_decompress(&dinfo);
+  jpeg_stdio_src(&dinfo, in_file);
+  if (metadata != NULL) {
+    jpeg_save_markers(&dinfo, JPEG_APP0 + 1, 0xffff);  // EXIF and XMP
+    jpeg_save_markers(&dinfo, JPEG_APP0 + 2, 0xffff);  // ICC profile
+  }
+  jpeg_read_header(&dinfo, TRUE);
+  if (metadata != NULL && !ExtractMetadataFromJPEG(&dinfo, metadata)) {
+    goto Error;
+  }
+
+  dinfo.out_color_space = JCS_RGB;
+  dinfo.do_fancy_upsampling = TRUE;
+
+  jpeg_start_decompress(&dinfo);
+
+  if (dinfo.output_components != 3) {
+    goto Error;
+  }
+
+  if (!UtilCheckImageSize(dinfo.output_width, dinfo.output_height,
+                          dinfo.output_components, &stride, &rgb_size)) {
+    goto Error;
+  }
+  width = (int)dinfo.output_width;
+  height = (int)dinfo.output_height;
+
+  rgb = (uint8_t*)malloc(rgb_size);
+  if (rgb == NULL) {
+    goto Error;
+  }
+  buffer[0] = (JSAMPLE*)rgb;
+
+  while (dinfo.output_scanline < dinfo.output_height) {
+    if (jpeg_read_scanlines(&dinfo, buffer, 1) != 1) {
+      goto Error;
+    }
+    buffer[0] += stride;
+  }
+
+  jpeg_finish_decompress(&dinfo);
+  jpeg_destroy_decompress(&dinfo);
+
+  // WebP conversion.
+  pic->width = width;
+  pic->height = height;
+  ok = WebPPictureImportRGB(pic, rgb, stride);
+
+ End:
+  free(rgb);
+  return ok;
+}
+

data/ext/webp_ffi/jpegdec.h

@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+#include "webp/encode.h"
+#include "webp/decode.h"
+#include "./metadata.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Reads a JPEG from 'in_file', returning the decoded output in 'pic'.
+// The output is RGB. When 'metadata' is not NULL, the ICC profile, EXIF and
+// XMP data are copied into it.
+// Returns true on success.
+int UtilReadJPEG(FILE* in_file, struct WebPPicture* const pic,
+                 Metadata* const metadata);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif

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_ */