webp-ffi 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5dc135cb052630588802ca113f8d11a18ccd0dfe
-  data.tar.gz: 685b69ef56c9d2928ab5a6c2f1631f5675bb5796
+SHA256:
+  metadata.gz: 2cf844bf54ff536c29ad8b940b311add0e2dfc9bdf1279f09da6346d0ef14648
+  data.tar.gz: 4c04e7ebcd080732f008e7a03468d7ac83ff856af311854b04bacd5b370c8b1d
 SHA512:
-  metadata.gz: 4b38a77daf24a59aebe807b2444f2a8c601392f78d1d4bdac3363887268ecd2f647577c66bad6847b9dd4ebc147d53c81b5724da042107b4ec1712a427a39edc
-  data.tar.gz: 56a5f00d3cc2b4719060d5e6b03684754d34451cab57a05ce2f476153631f386fd61ce39877f722e3e1ddf68eaf938eec8102672e307dee823ecd1bbbb9a6532
+  metadata.gz: facd4a1bf45bbca5dc44bb60692975aa0109198c7893652678ace43c525b67050514e731c1e9b029619503507fbea994f9a36f6f62d6955de495cf83512b08d3
+  data.tar.gz: e12b828bb6f031ed4b7e7ecbffabf2afc5af56eb022726e349c59f736d20c69c8c7dd2f67bede2c593cef32443cd47f8bb7a2e3c098b37efa88fba836488792f

data/.ruby-version

@@ -1 +1 @@
-2.1.0
+2.7.1

data/.travis.yml

@@ -1,23 +1,38 @@
 language: ruby
+
 before_install:
   - ./spec/travis_build.sh > /dev/null 2>&1
+  - export LD_FLAGS=-L$HOME/opt/lib
+  - export LD_LIBRARY_PATH=/lib:/usr/lib:/usr/local/lib:$HOME/opt/lib
+  - export CPATH=$CPATH:$HOME/opt/include
+
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.5
+  - 2.6
+  - 2.7
+  - 3.0
   - jruby-19mode
   - rbx-19mode
   - ruby-head
   - jruby-head
+env:
+  - LIBWEBP_VERSION=0.4.4
+  - LIBWEBP_VERSION=1.0.2
+
+cache: bundler
+sudo: false
+dist: xenial
+
 notifications:
   email: false
+
 branches:
   only:
     - master
     - development
+
 matrix:
   allow_failures:
     - rvm: rbx-19mode
     - rvm: ruby-head
-    - rvm: jruby-head
+    - rvm: jruby-head

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## v0.2.7
+
+* Fix build for old libwebp versions
+
+## v0.2.6
+
+* Tested on webp 1.0.2
+* Added near_lossless option
+
+## v0.2.5
+
+* Fix build for Travis CI docker containers
+
+## v0.2.4
+
+* DRY C code and split into files each read/write formats
+
 ## v0.2.3
 
 * Fix jpg read in C code

data/README.md

@@ -1,7 +1,7 @@
 # Webp-ffi
 
-[![Build Status](https://travis-ci.org/le0pard/webp-ffi.png)](https://travis-ci.org/le0pard/webp-ffi)
-[![Code Climate](https://codeclimate.com/github/le0pard/webp-ffi.png)](https://codeclimate.com/github/le0pard/webp-ffi)
+[![Build Status](https://travis-ci.com/le0pard/webp-ffi.svg?branch=master)](https://travis-ci.com/le0pard/webp-ffi)
+[![Code Climate](https://codeclimate.com/github/le0pard/webp-ffi/badges/gpa.svg)](https://codeclimate.com/github/le0pard/webp-ffi)
 
 Ruby wrapper for libwebp. What is WebP?
 
@@ -17,7 +17,11 @@ First of all you should have install libraries: libpng, libjpeg and libtiff.
 
 For Ubuntu, Debian:
 
-    sudo apt-get install libjpeg-dev libpng-dev libtiff-dev
+    sudo apt-get install libjpeg-dev libpng-dev libtiff-dev libwebp-dev
+
+For Fedora, CentOS:
+
+    sudo dnf install libjpeg-devel libpng-devel libtiff-devel libwebp-devel
 
 For Mac OS:
 
@@ -27,7 +31,7 @@ or (for MacPorts):
 
     sudo port install jpeg libpng tiff
 
-Next, you should [install libwebp](https://developers.google.com/speed/webp/docs/compiling) (if you didn't install it by `brew` in Mac OS). This gem is not support Windows systems (sorry).
+Next, you should [install libwebp](https://developers.google.com/speed/webp/docs/compiling) (if you didn't install it by `brew` in Mac OS or by `apt-get` in Ubuntu or Debian). Webp library version should be >= 0.3.0. This gem is not support Windows systems.
 
 ### Final part
 
@@ -85,6 +89,7 @@ Encode png, jpg or tiff image to webp with options:
 Possible encode options:
 
  * **lossless** (int) - Lossless encoding (0=lossy(default), 1=lossless)
+ * **near_lossless** (int) - Use near-lossless image preprocessing (0=maximum preprocessing, 100=no preprocessing(default))
  * **quality** (float) - between 0 (smallest file) and 100 (biggest)
  * **method** (int) - quality/speed trade-off (0=fast, 6=slower-better)
  * **target\_size** (int) - if non-zero, set the desired target size in bytes. Takes precedence over the 'compression' parameter
@@ -142,6 +147,47 @@ Possible decode options:
  * **crop\_x** (int), **crop\_y** (int), **crop\_w** (int), **crop\_h** (int) - crop picture with the given rectangle
  * **resize\_w** (int), **resize\_h** (int) - resize picture (after any cropping)
 
+## Rails assets pipeline integration
+
+For integration with Rails 3+ you can use very simple rake task:
+
+```ruby
+# Place this code in lib/tasks/assets.rake
+require 'webp-ffi'
+
+namespace :assets do
+  desc "Create .webp versions of assets"
+  task :webp => :environment do
+    image_types = /\.(?:png|jpe?g)$/
+
+    public_assets = File.join(
+      Rails.root,
+      "public",
+      Rails.application.config.assets.prefix)
+
+    Dir["#{public_assets}/**/*"].each do |filename|
+      next unless filename =~ image_types
+
+      mtime = File.mtime(filename)
+      webp_file = "#{filename}.webp"
+      next if File.exist?(webp_file) && File.mtime(webp_file) >= mtime
+      begin
+        WebP.encode(filename, webp_file)
+        File.utime(mtime, mtime, webp_file)
+        puts "Webp converted image #{webp_file}"
+      rescue => e
+        puts "Webp convertion error of image #{webp_file}. Error info: #{e.message}"
+      end
+    end
+  end
+
+  # Hook into existing assets:precompile task
+  Rake::Task["assets:precompile"].enhance do
+    Rake::Task["assets:webp"].invoke
+  end
+end
+```
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -20,8 +20,8 @@ namespace "ffi-compiler" do
     c.have_library?('png')
     c.have_library?('jpeg')
     c.have_library?('tiff')
-    c.cflags << "-arch x86_64" if c.platform.mac?
-    c.ldflags << "-arch x86_64" if c.platform.mac?
+    c.ldflags << ENV['LD_FLAGS'] if ENV['LD_FLAGS']
+    c.cflags << ENV['C_FLAGS'] if ENV['C_FLAGS']
   end
 end
 task :compile => ["ffi-compiler:default"]
@@ -35,4 +35,4 @@ task :default => [:clean, :compile, :spec]
 
 CLEAN.include('ext/**/*{.o,.log,.so,.bundle}')
 CLEAN.include('lib/**/*{.o,.log,.so,.bundle}')
-CLEAN.include('ext/**/Makefile')
+CLEAN.include('ext/**/Makefile')

data/ext/webp_ffi/Rakefile

@@ -15,6 +15,10 @@ FFI::Compiler::CompileTask.new('webp_ffi') do |c|
   c.have_library?('jpeg')
   c.have_library?('tiff')
   # compiler flags
-  c.cflags << "-arch x86_64" if c.platform.mac?
-  c.ldflags << "-arch x86_64" if c.platform.mac?
+  if c.platform.mac?
+    c.cflags << "-arch x86_64"
+    c.ldflags << "-arch x86_64"
+  end
+  c.ldflags << ENV['LD_FLAGS'] if ENV['LD_FLAGS']
+  c.cflags << ENV['C_FLAGS'] if ENV['C_FLAGS']
 end

data/ext/webp_ffi/jpegdec.c

@@ -0,0 +1,80 @@
+#include "./jpegdec.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;
+  (*dinfo->err->output_message) (dinfo);
+  longjmp(myerr->setjmp_buffer, 1);
+}
+
+int UtilReadJPEG(FILE* in_file, WebPPicture* const pic) {
+  int ok = 0;
+  int stride, width, height;
+  uint8_t* 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;
+
+  if (setjmp(jerr.setjmp_buffer)) {
+ Error:
+    jpeg_destroy_decompress(&dinfo);
+    goto End;
+  }
+
+  jpeg_create_decompress(&dinfo);
+  jpeg_stdio_src(&dinfo, in_file);
+  jpeg_read_header(&dinfo, TRUE);
+
+  dinfo.out_color_space = JCS_RGB;
+  dinfo.do_fancy_upsampling = TRUE;
+
+  jpeg_start_decompress(&dinfo);
+
+  if (dinfo.output_components != 3) {
+    goto Error;
+  }
+
+  width = dinfo.output_width;
+  height = dinfo.output_height;
+  stride = dinfo.output_width * dinfo.output_components * sizeof(*rgb);
+
+  rgb = (uint8_t*)malloc(stride * height);
+  if (rgb == NULL) {
+    goto End;
+  }
+  buffer[0] = (JSAMPLE*)rgb;
+
+  while (dinfo.output_scanline < dinfo.output_height) {
+    if (jpeg_read_scanlines(&dinfo, buffer, 1) != 1) {
+      goto End;
+    }
+    buffer[0] += stride;
+  }
+
+  jpeg_finish_decompress(&dinfo);
+  jpeg_destroy_decompress(&dinfo);
+
+  // WebP conversion.
+  pic->width = width;
+  pic->height = height;
+  ok = WebPPictureImportRGB(pic, rgb, stride);
+  if (!ok) goto Error;
+
+ End:
+  free(rgb);
+  return ok;
+}
+

data/ext/webp_ffi/jpegdec.h

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+#include "webp/encode.h"
+#include "webp/decode.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Reads a JPEG from 'in_file', returning the decoded output in 'pic'.
+// The output is RGB.
+// Returns true on success.
+int UtilReadJPEG(FILE* in_file, struct WebPPicture* const pic);
+
+#ifdef __cplusplus
+}    // extern "C"
+#endif

data/ext/webp_ffi/pngdec.c

@@ -0,0 +1,212 @@
+#include "./pngdec.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <png.h>
+#include <setjmp.h>   // note: this must be included *after* png.h
+#include <stdlib.h>
+#include <string.h>
+
+static void PNGAPI error_function(png_structp png, png_const_charp dummy) {
+  (void)dummy;  // remove variable-unused warning
+  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;
+  int color_type, bit_depth, interlaced;
+  int has_alpha;
+  int num_passes;
+  int p;
+  int ok = 0;
+  png_uint_32 width, height, y;
+  int stride;
+  uint8_t* rgb = NULL;
+
+  png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0);
+  if (png == NULL) {
+    goto End;
+  }
+
+  png_set_error_fn(png, 0, error_function, NULL);
+  if (setjmp(png_jmpbuf(png))) {
+ Error:
+    png_destroy_read_struct(&png, &info, &end_info);
+    goto End;
+  }
+
+  info = png_create_info_struct(png);
+  if (info == NULL) goto Error;
+  end_info = png_create_info_struct(png);
+  if (end_info == NULL) goto Error;
+
+  png_init_io(png, in_file);
+  png_read_info(png, info);
+  if (!png_get_IHDR(png, info,
+                    &width, &height, &bit_depth, &color_type, &interlaced,
+                    NULL, NULL)) goto Error;
+
+  png_set_strip_16(png);
+  png_set_packing(png);
+  if (color_type == PNG_COLOR_TYPE_PALETTE) png_set_palette_to_rgb(png);
+  if (color_type == PNG_COLOR_TYPE_GRAY ||
+      color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
+    if (bit_depth < 8) {
+      png_set_expand_gray_1_2_4_to_8(png);
+    }
+    png_set_gray_to_rgb(png);
+  }
+  if (png_get_valid(png, info, PNG_INFO_tRNS)) {
+    png_set_tRNS_to_alpha(png);
+    has_alpha = 1;
+  } else {
+    has_alpha = !!(color_type & PNG_COLOR_MASK_ALPHA);
+  }
+
+  if (!keep_alpha) {
+    png_set_strip_alpha(png);
+    has_alpha = 0;
+  }
+
+  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 (rgb == NULL) goto Error;
+  for (p = 0; p < num_passes; ++p) {
+    for (y = 0; y < height; ++y) {
+      png_bytep row = rgb + y * stride;
+      png_read_rows(png, &row, NULL, 1);
+    }
+  }
+  png_read_end(png, end_info);
+  png_destroy_read_struct(&png, &info, &end_info);
+
+  pic->width = width;
+  pic->height = 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;
+}
+
+
+
+
+
+int UtilWritePNG(FILE* out_file, const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  unsigned char* const rgb = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const int has_alpha = (buffer->colorspace == MODE_RGBA);
+  png_structp png;
+  png_infop info;
+  png_uint_32 y;
+
+  png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+                                NULL, error_function, NULL);
+  if (png == NULL) {
+    return 0;
+  }
+  info = png_create_info_struct(png);
+  if (info == NULL) {
+    png_destroy_write_struct(&png, NULL);
+    return 0;
+  }
+  if (setjmp(png_jmpbuf(png))) {
+    png_destroy_write_struct(&png, &info);
+    return 0;
+  }
+  png_init_io(png, out_file);
+  png_set_IHDR(png, info, width, height, 8,
+               has_alpha ? PNG_COLOR_TYPE_RGBA : PNG_COLOR_TYPE_RGB,
+               PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+               PNG_FILTER_TYPE_DEFAULT);
+  png_write_info(png, info);
+  for (y = 0; y < height; ++y) {
+    png_bytep row = rgb + y * stride;
+    png_write_rows(png, &row, 1);
+  }
+  png_write_end(png, info);
+  png_destroy_write_struct(&png, &info);
+  return 1;
+}
+
+
+int UtilWritePPM(FILE* fout, const WebPDecBuffer* const buffer, int alpha) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const unsigned char* const rgb = buffer->u.RGBA.rgba;
+  const int stride = buffer->u.RGBA.stride;
+  const size_t bytes_per_px = alpha ? 4 : 3;
+  uint32_t y;
+
+  if (alpha) {
+    fprintf(fout, "P7\nWIDTH %d\nHEIGHT %d\nDEPTH 4\nMAXVAL 255\n"
+                  "TUPLTYPE RGB_ALPHA\nENDHDR\n", width, height);
+  } else {
+    fprintf(fout, "P6\n%d %d\n255\n", width, height);
+  }
+  for (y = 0; y < height; ++y) {
+    if (fwrite(rgb + y * stride, width, bytes_per_px, fout) != bytes_per_px) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+int UtilWriteAlphaPlane(FILE* fout, const WebPDecBuffer* const buffer) {
+  const uint32_t width = buffer->width;
+  const uint32_t height = buffer->height;
+  const unsigned char* const a = buffer->u.YUVA.a;
+  const int a_stride = buffer->u.YUVA.a_stride;
+  uint32_t y;
+  assert(a != NULL);
+  fprintf(fout, "P5\n%d %d\n255\n", width, height);
+  for (y = 0; y < height; ++y) {
+    if (fwrite(a + y * a_stride, width, 1, fout) != 1) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+int UtilWritePGM(FILE* fout, const WebPDecBuffer* const buffer) {
+  const int width = buffer->width;
+  const int height = buffer->height;
+  const WebPYUVABuffer* const yuv = &buffer->u.YUVA;
+  // Save a grayscale PGM file using the IMC4 layout
+  // (http://www.fourcc.org/yuv.php#IMC4). This is a very
+  // convenient format for viewing the samples, esp. for
+  // odd dimensions.
+  int ok = 1;
+  int y;
+  const int uv_width = (width + 1) / 2;
+  const int uv_height = (height + 1) / 2;
+  const int out_stride = (width + 1) & ~1;
+  const int a_height = yuv->a ? height : 0;
+  fprintf(fout, "P5\n%d %d\n255\n", out_stride, height + uv_height + a_height);
+  for (y = 0; ok && y < height; ++y) {
+    ok &= (fwrite(yuv->y + y * yuv->y_stride, width, 1, fout) == 1);
+    if (width & 1) fputc(0, fout);    // padding byte
+  }
+  for (y = 0; ok && y < uv_height; ++y) {
+    ok &= (fwrite(yuv->u + y * yuv->u_stride, uv_width, 1, fout) == 1);
+    ok &= (fwrite(yuv->v + y * yuv->v_stride, uv_width, 1, fout) == 1);
+  }
+  for (y = 0; ok && y < a_height; ++y) {
+    ok &= (fwrite(yuv->a + y * yuv->a_stride, width, 1, fout) == 1);
+    if (width & 1) fputc(0, fout);    // padding byte
+  }
+  return ok;
+}