webp-ffi 0.0.1 → 0.1.0

data/.gitignore

@@ -3,6 +3,7 @@
 .bundle
 .config
 .yardoc
+.DS_Store
 Gemfile.lock
 InstalledFiles
 _yardoc

data/.travis.yml

@@ -18,4 +18,6 @@ branches:
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: jruby-head
+    - rvm: jruby-head
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode

data/README.md

@@ -7,6 +7,27 @@ Ruby wrapper for libwebp.
 
 ## Installation
 
+### Requirements
+
+First of all you should have install libraries: libpng, libjpeg and libwebp (for libwebp need libpng and libjpeg).
+
+For ubuntu, debian:
+
+    sudo apt-get install libjpeg62-dev
+    sudo apt-get install libpng12-dev
+    
+For Mac OS:
+
+    sudo port install jpeg libpng
+    
+or:
+
+    brew install libjpg libpng
+    
+Next, you should [install libwebp](https://developers.google.com/speed/webp/docs/compiling).
+
+### Final part
+
 Add this line to your application's Gemfile:
 
     gem 'webp-ffi'
@@ -21,7 +42,42 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Basic info about libwebp (encoder and decoder versions):
+
+    $ irb
+    2.0.0p0 :001 > require 'webp_ffi'
+     => true 
+    2.0.0p0 :002 > WebpFfi.decoder_version
+     => "0.2.0" 
+    2.0.0p0 :003 > WebpFfi.encoder_version
+     => "0.2.0"
+     
+Get size (width and height) from webp image:
+
+    2.0.0p0 :001 > require 'webp_ffi'
+     => true
+    2.0.0p0 :006 > filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.webp"))
+    2.0.0p0 :007 > WebpFfi.webp_size(data = File.open(filename, "rb").read)
+     => [2000, 2353]
+    
+Decode webp image to png:
+
+    2.0.0p0 :008 > filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.webp"))
+     => "/Users/leo/programs/projects/webp-ffi/spec/factories/4.webp" 
+    2.0.0p0 :009 > out_filename = File.expand_path(File.join(File.dirname(__FILE__), "tmp/4.png"))
+     => "/Users/leo/programs/projects/webp-ffi/tmp/4.png" 
+    2.0.0p0 :010 > WebpFfi.decode(filename, out_filename)
+    Saved file /Users/leo/programs/projects/webp-ffi/tmp/4.png
+     => 0 
+
+Encode png image to webp:
+
+    2.0.0p0 :011 > filename = File.expand_path(File.join(File.dirname(__FILE__), "spec/factories/4.png"))
+     => "/Users/leo/programs/projects/webp-ffi/spec/factories/4.png" 
+    2.0.0p0 :012 > out_filename = File.expand_path(File.join(File.dirname(__FILE__), "tmp/4.webp"))
+     => "/Users/leo/programs/projects/webp-ffi/tmp/4.webp" 
+    2.0.0p0 :013 > WebpFfi.encode(filename, out_filename)
+     => 0
 
 ## Contributing
 

data/Rakefile

@@ -16,6 +16,8 @@ namespace "ffi-compiler" do
     c.have_func?('WebPDecoderConfig')
     c.have_func?('WebPGetInfo')
     c.have_library?('webp')
+    c.have_library?('png')
+    c.have_library?('jpeg')
     c.cflags << "-arch x86_64" if c.platform.mac?
     c.ldflags << "-arch x86_64" if c.platform.mac?
   end

data/ext/webp_ffi/Rakefile

@@ -10,7 +10,10 @@ FFI::Compiler::CompileTask.new('webp_ffi') do |c|
   c.have_func?('WebPDecoderConfig')
   c.have_func?('WebPGetInfo')
   c.have_library?('webp')
+  # libs
+  c.have_library?('png')
+  c.have_library?('jpeg')
   # compiler flags
-  c.cflags << "-arch x86_64 -arch i386" if c.platform.mac?
-  c.ldflags << "-arch x86_64 -arch i386" if c.platform.mac?
+  c.cflags << "-arch x86_64" if c.platform.mac?
+  c.ldflags << "-arch x86_64" if c.platform.mac?
 end

data/ext/webp_ffi/util.c

@@ -1,15 +1,273 @@
 #include "./util.h"
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+
+#include <png.h>
+
+#include <setjmp.h>   // note: this must be included *after* png.h
+#include <jpeglib.h>
+
+#include "webp/decode.h"
+#include "webp/encode.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+static int UtilReadYUV(FILE* in_file, WebPPicture* const pic) {
+  const int use_argb = pic->use_argb;
+  const int uv_width = (pic->width + 1) / 2;
+  const int uv_height = (pic->height + 1) / 2;
+  int y;
+  int ok = 0;
+
+  pic->use_argb = 0;
+  if (!WebPPictureAlloc(pic)) return ok;
+
+  for (y = 0; y < pic->height; ++y) {
+    if (fread(pic->y + y * pic->y_stride, pic->width, 1, in_file) != 1) {
+      goto End;
+    }
+  }
+  for (y = 0; y < uv_height; ++y) {
+    if (fread(pic->u + y * pic->uv_stride, uv_width, 1, in_file) != 1)
+      goto End;
+  }
+  for (y = 0; y < uv_height; ++y) {
+    if (fread(pic->v + y * pic->uv_stride, uv_width, 1, in_file) != 1)
+      goto End;
+  }
+  ok = 1;
+  if (use_argb) ok = WebPPictureYUVAToARGB(pic);
+
+ End:
+  return ok;
+}
+
+static void PNGAPI error_function(png_structp png, png_const_charp dummy) {
+  (void)dummy;  // remove variable-unused warning
+  longjmp(png_jmpbuf(png), 1);
+}
+
+static int UtilReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha) {
+  png_structp png;
+  png_infop info;
+  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, NULL, NULL);
+    free(rgb);
+    goto End;
+  }
+
+  info = png_create_info_struct(png);
+  if (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, info);
+  png_destroy_read_struct(&png, &info, NULL);
+
+  pic->width = width;
+  pic->height = height;
+  ok = has_alpha ? WebPPictureImportRGBA(pic, rgb, stride)
+                 : WebPPictureImportRGB(pic, rgb, stride);
+  free(rgb);
+
+  if (ok && has_alpha && keep_alpha == 2) {
+    WebPCleanupTransparentArea(pic);
+  }
+
+ End:
+  return ok;
+}
+
+static 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;
+}
+
+static InputFileFormat GetImageType(FILE* in_file) {
+  InputFileFormat format = UNSUPPORTED;
+  unsigned int magic;
+  unsigned char buf[4];
+
+  if ((fread(&buf[0], 4, 1, in_file) != 1) ||
+      (fseek(in_file, 0, SEEK_SET) != 0)) {
+    return format;
+  }
+
+  magic = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+  if (magic == 0x89504E47U) {
+    format = PNG_;
+  } else if (magic >= 0xFFD8FF00U && magic <= 0xFFD8FFFFU) {
+    format = JPEG_;
+  } else if (magic == 0x49492A00 || magic == 0x4D4D002A) {
+    format = TIFF_;
+  }
+  return format;
+}
+
+int UtilReadPicture(const char* const filename, WebPPicture* const pic,
+                       int keep_alpha) {
+  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).
+    const InputFileFormat format = GetImageType(in_file);
+    if (format == PNG_) {
+      ok = UtilReadPNG(in_file, pic, keep_alpha);
+    }
+    /*
+    } else if (format == JPEG_) {
+      ok = ReadJPEG(in_file, pic);
+    } else if (format == TIFF_) {
+      ok = ReadTIFF(filename, pic, keep_alpha);
+    }
+    */
+  } else {
+    // If image size is specified, infer it as YUV format.
+    ok = UtilReadYUV(in_file, pic);
+  }
+  if (!ok) {
+    fprintf(stderr, "Error! Could not process file %s\n", filename);
+  }
+
+  fclose(in_file);
+  return ok;
+}
+
+void UtilSaveOutput(const WebPDecBuffer* const buffer,
+                       OutputFileFormat format, const char* const out_file) {
+  FILE* fout = NULL;
+  int ok = 1;
+
+  fout = fopen(out_file, "wb");
+  if (!fout) {
+    fprintf(stderr, "Error opening output file %s\n", out_file);
+    return;
+  }
+
+  if (format == PNG) {
+    ok &= UtilWritePNG(fout, buffer);
+  }
+  /*
+  } else if (format == PAM) {
+    ok &= WritePPM(fout, buffer, 1);
+  } else if (format == PPM) {
+    ok &= WritePPM(fout, buffer, 0);
+  } else if (format == PGM) {
+    ok &= WritePGM(fout, buffer);
+  } else if (format == ALPHA_PLANE_ONLY) {
+    ok &= WriteAlphaPlane(fout, buffer);
+  }
+  */
+  if (fout) {
+    fclose(fout);
+  }
+  if (ok) {
+    printf("Saved file %s\n", out_file);
+  } else {
+    fprintf(stderr, "Error writing file %s !!\n", out_file);
+  }
+}
+
 // -----------------------------------------------------------------------------
 // File I/O
 
-int WebpFfiReadFile(const char* const file_name,
+int UtilReadFile(const char* const file_name,
                    const uint8_t** data, size_t* data_size) {
   int ok;
   void* file_data;

data/ext/webp_ffi/util.h

@@ -1,13 +1,30 @@
-#include "webp/types.h"
+#include "webp/decode.h"
+#include "webp/encode.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
 #endif
 
+typedef enum {
+  PNG = 0,
+  PAM,
+  PPM,
+  PGM,
+  ALPHA_PLANE_ONLY  // this is for experimenting only
+} OutputFileFormat;
+
+typedef enum {
+  PNG_ = 0,
+  JPEG_,
+  TIFF_,  // 'TIFF' clashes with libtiff
+  UNSUPPORTED
+} InputFileFormat;
+
+void UtilSaveOutput(const WebPDecBuffer* const buffer, OutputFileFormat format, const char* const out_file);
 // 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 WebpFfiReadFile(const char* const file_name,
+int UtilReadFile(const char* const file_name,
                    const uint8_t** data, size_t* data_size);
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/ext/webp_ffi/webp_ffi.c

@@ -10,23 +10,24 @@
 #include "./util.h"
 #include "./webp_ffi.h"
 
-#ifdef WEBP_HAVE_PNG
-#include <png.h>
-#endif
 
-#ifdef WEBP_HAVE_JPEG
-#include <setjmp.h>   // note: this must be included *after* png.h
-#include <jpeglib.h>
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
 #endif
 
-#ifdef WEBP_HAVE_TIFF
-#include <tiffio.h>
-#endif
+static int EncodeWriter(const uint8_t* data, size_t data_size,
+                    const WebPPicture* const pic) {
+  FILE* const out = (FILE*)pic->custom_ptr;
+  return data_size ? (fwrite(data, data_size, 1, out) == 1) : 1;
+}
 
+static void AllocExtraInfo(WebPPicture* const pic) {
+  const int mb_w = (pic->width + 15) / 16;
+  const int mb_h = (pic->height + 15) / 16;
+  pic->extra_info = (uint8_t*)malloc(mb_w * mb_h * sizeof(*pic->extra_info));
+}
 
-#if defined(__cplusplus) || defined(c_plusplus)
-extern "C" {
-#endif
+// main functions
 
 void decoder_version(char *version) {
   int v = WebPGetDecoderVersion();
@@ -41,11 +42,132 @@ void encoder_version(char *version) {
 }
 
 int webp_get_info(const uint8_t* data, size_t data_size, int* width, int* height) {
-  return WebPGetInfo(data, data_size, width, height);
+  if (WebPGetInfo(data, data_size, width, height) == 1) {
+    return 0;
+  } else {
+    return 1;
+  }
 }
 
-uint8_t* webp_decode_rgba(const uint8_t* data, size_t data_size, int* width, int* height) {
-  return WebPDecodeRGBA(data, data_size, width, height);
+
+
+int webp_decode(const char *in_file, const char *out_file) {
+  int return_value = -1;
+  WebPDecoderConfig config;
+  WebPDecBuffer* const output_buffer = &config.output;
+  WebPBitstreamFeatures* const bitstream = &config.input;
+  OutputFileFormat format = PNG;
+
+  if (!WebPInitDecoderConfig(&config)) {
+    fprintf(stderr, "Library version mismatch!\n");
+    return 1;
+  }
+  
+  VP8StatusCode status = VP8_STATUS_OK;
+  size_t data_size = 0;
+  const uint8_t* data = NULL;
+  
+  if (!UtilReadFile(in_file, &data, &data_size)) return -1;
+  
+  status = WebPGetFeatures(data, data_size, bitstream);
+  if (status != VP8_STATUS_OK) {
+    fprintf(stderr, "This is invalid webp image!\n");
+    return_value = 2;
+    goto Error;
+  }
+  
+  switch (format) {
+    case PNG:
+      output_buffer->colorspace = bitstream->has_alpha ? MODE_RGBA : MODE_RGB;
+      break;
+    case PAM:
+      output_buffer->colorspace = MODE_RGBA;
+      break;
+    case PPM:
+      output_buffer->colorspace = MODE_RGB;  // drops alpha for PPM
+      break;
+    case PGM:
+      output_buffer->colorspace = bitstream->has_alpha ? MODE_YUVA : MODE_YUV;
+      break;
+    case ALPHA_PLANE_ONLY:
+      output_buffer->colorspace = MODE_YUVA;
+      break;
+    default:
+      free((void*)data);
+      return 3;
+  }
+  status = WebPDecode(data, data_size, &config);
+  
+  if (status != VP8_STATUS_OK) {
+    fprintf(stderr, "Decoding of %s failed.\n", in_file);
+    return_value = 4;
+    goto Error;
+  }
+  UtilSaveOutput(output_buffer, format, out_file);
+  return_value = 0;
+  
+Error:  
+  free((void*)data);
+  WebPFreeDecBuffer(output_buffer);
+  return return_value;
+}
+
+
+
+int webp_encode(const char *in_file, const char *out_file) {
+  int return_value = -1;
+  FILE *out = NULL;
+  int keep_alpha = 1;
+  WebPPicture picture;
+  WebPConfig config;
+  
+  
+  if (!WebPPictureInit(&picture) ||
+      !WebPConfigInit(&config)) {
+    fprintf(stderr, "Error! Version mismatch!\n");
+    return 1;
+  }
+  
+  if (!WebPValidateConfig(&config)) {
+    fprintf(stderr, "Error! Invalid configuration.\n");
+    return_value = 2;
+    goto Error;
+  }
+  
+  if (!UtilReadPicture(in_file, &picture, keep_alpha)) {
+    fprintf(stderr, "Error! Cannot read input picture file '%s'\n", in_file);
+    return_value = 3;
+    goto Error;
+  }
+  
+  out = fopen(out_file, "wb");
+  if (out == NULL) {
+    fprintf(stderr, "Error! Cannot open output file '%s'\n", out_file);
+    return_value = 4;
+    goto Error;
+  }
+  picture.writer = EncodeWriter;
+  picture.custom_ptr = (void*)out;
+  
+  if (picture.extra_info_type > 0) {
+    AllocExtraInfo(&picture);
+  }
+  
+  if (!WebPEncode(&config, &picture)) {
+    fprintf(stderr, "Error! Cannot encode picture as WebP\n");
+    return_value = 5;
+    goto Error;
+  }
+  return_value = 0;
+  
+Error:
+  free(picture.extra_info);
+  WebPPictureFree(&picture);
+  if (out != NULL) {
+    fclose(out);
+  }
+
+  return return_value;
 }
 
 // test

data/ext/webp_ffi/webp_ffi.h

@@ -5,10 +5,17 @@
 extern "C" {
 #endif
 
+  typedef struct {
+    int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+    float quality;          // between 0 (smallest file) and 100 (biggest)
+    int method;             // quality/speed trade-off (0=fast, 6=slower-better)
+  } FfiWebpConfig;
+
   void decoder_version(char *version);
   void encoder_version(char *version);
   int webp_get_info(const uint8_t* data, size_t data_size, int* width, int* height);
-  uint8_t* webp_decode_rgba(const uint8_t* data, size_t data_size, int* width, int* height);
+  int webp_decode(const char *in_file, const char *out_file);
+  int webp_encode(const char *in_file, const char *out_file);
   int test(int n);
 
 #if defined(__cplusplus) || defined(c_plusplus)

data/lib/webp_ffi.rb

@@ -10,5 +10,6 @@ end
 
 require "webp_ffi/c"
 require "webp_ffi/error"
+require "webp_ffi/libc"
 require "webp_ffi/webp_ffi"
 require "webp_ffi/version"

data/lib/webp_ffi/c.rb

@@ -1,26 +1,24 @@
 module WebpFfi
   module C
     # enum
-    vp8_status_code_enum = enum(:vp8_status_ok, 0,
-      :vp8_status_out_of_memory,
-      :vp8_status_invalid_params,
-      :vp8_status_bitstream_error,
-      :vp8_status_unsupported_feature,
-      :vp8_status_suspended,
-      :vp8_status_user_abort,
-      :vp8_status_not_enought_data)
+    WebpImageHint = enum(:webp_hint_default, 0,
+      :webp_hint_picture,
+      :webp_hint_photo,
+      :webp_hint_graph,
+      :webp_hint_last)
     # struct
-    class WebPBitstreamFeatures < FFI::Struct
-      layout  :width, :int,
-        :height, :int,
-        :has_alpha, :int
+    class FfiWebpConfig < FFI::Struct
+      layout  :lossless, :int,
+        :quality, :float,
+        :method, :int
     end
-    
+   
     # webp lib functions
     attach_function :decoder_version, [:pointer], :void
     attach_function :encoder_version, [:pointer], :void
     attach_function :webp_get_info, [:pointer, :size_t, :pointer, :pointer], :int
-    attach_function :webp_decode_rgba, [:pointer, :size_t, :pointer, :pointer], :pointer
+    attach_function :webp_decode, [:string, :string], :int
+    attach_function :webp_encode, [:string, :string], :int
 
     attach_function :test, [:int], :int
   end

data/lib/webp_ffi/libc.rb

@@ -0,0 +1,20 @@
+module WebpFfi
+  module LibC
+    extend FFI::Library
+    # figures out the correct libc for each platform including Windows
+    library = ffi_lib(FFI::Library::LIBC).first
+
+    # Size_t not working properly on Windows
+    find_type(:size_t) rescue typedef(:ulong, :size_t)
+
+    # memory allocators
+    attach_function :malloc, [:size_t], :pointer
+    attach_function :free, [:pointer], :void
+  
+    # get a pointer to the free function
+    Free = library.find_symbol('free')
+
+    # memory movers
+    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+  end # module LibC
+end

data/lib/webp_ffi/version.rb

@@ -1,3 +1,3 @@
 module WebpFfi
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/webp_ffi/webp_ffi.rb

@@ -18,12 +18,12 @@ module WebpFfi
     # get webp image size
     def webp_size(data)
       return nil if data.nil?
+      size = data.respond_to?(:bytesize) ? data.bytesize : data.size
       width_ptr = FFI::MemoryPointer.new(:int, 2)
       height_ptr = FFI::MemoryPointer.new(:int, 2)
-      size = data.respond_to?(:bytesize) ? data.bytesize : data.size
       memBuf = FFI::MemoryPointer.new(:char, size)
       memBuf.put_bytes(0, data)
-      if C.webp_get_info(memBuf, size, width_ptr, height_ptr) == 1
+      if C.webp_get_info(memBuf, size, width_ptr, height_ptr) == 0
         [width_ptr.null? ? nil : width_ptr.read_int, height_ptr.null? ? nil : height_ptr.read_int]
       else
         raise InvalidImageFormatError, "invalid webp image"
@@ -31,15 +31,14 @@ module WebpFfi
       end
     end
     
-    def webp_decode_rgba(data)
-      return nil if data.nil?
-      width_ptr = FFI::MemoryPointer.new(:int, 2)
-      height_ptr = FFI::MemoryPointer.new(:int, 2)
-      size = data.respond_to?(:bytesize) ? data.bytesize : data.size
-      memBuf = FFI::MemoryPointer.new(:char, size)
-      memBuf.put_bytes(0, data)
-      pointer = C.webp_decode_rgba(memBuf, size, width_ptr, height_ptr)
-      pointer.null? ? nil : pointer.read_string()
+    # decode
+    def decode(input_file, output_file, options = {})
+      C.webp_decode(input_file, output_file)
+    end
+    
+    # encode
+    def encode(input_file, output_file, options = {})
+      C.webp_encode(input_file, output_file)
     end
     
   end

data/spec/webp_ffi_spec.rb

@@ -2,29 +2,31 @@ require 'spec_helper'
 
 describe WebpFfi do
   factories = {
-    webp: ["1.webp", "2.webp", "3.webp", "4.webp", "5.webp", "6.webp"],
+    webp: ["1", "2", "3", "4", "5", "6"],
+    png: ["1", "2", "3", "4"],
+    jpg: ["5", "6"],
     info: {
-      "1.webp" => {
+      "1" => {
         size: [400, 301],
         has_alpha: true
       },
-      "2.webp" => {
+      "2" => {
         size: [386, 395],
         has_alpha: true
       },
-      "3.webp" => {
+      "3" => {
         size: [300, 300],
         has_alpha: true
       },
-      "4.webp" => {
+      "4" => {
         size: [2000, 2353],
         has_alpha: true
       },
-      "5.webp" => {
+      "5" => {
         size: [550, 368],
         has_alpha: false
       },
-      "6.webp" => {
+      "6" => {
         size: [1024, 772],
         has_alpha: false
       }
@@ -49,7 +51,7 @@ describe WebpFfi do
   context "webp_size" do
     factories[:webp].each do |image|
       it "#{image} image size == #{factories[:info][image][:size]}" do
-        filename = File.expand_path(File.join(File.dirname(__FILE__), "factories/#{image}"))
+        filename = File.expand_path(File.join(File.dirname(__FILE__), "factories/#{image}.webp"))
         data = File.open(filename, "rb").read
         info = WebpFfi.webp_size(data)
         info.class.should == Array
@@ -64,13 +66,26 @@ describe WebpFfi do
     end
   end
   
-  context "webp_decode_rgba" do
+  context "decode" do
     factories[:webp].each do |image|
-      it "#{image} webp_decode_rgba" do
-        filename = File.expand_path(File.join(File.dirname(__FILE__), "factories/#{image}"))
-        data = File.open(filename, "rb").read
-        output_data = WebpFfi.webp_decode_rgba(data)
-        # TODO: finish
+      it "#{image}.webp image" do
+        out_dir = File.expand_path(File.join(File.dirname(__FILE__), "../tmp/"))
+        Dir.mkdir(out_dir) unless File.exists?(out_dir)
+        in_filename = File.expand_path(File.join(File.dirname(__FILE__), "factories/#{image}.webp"))
+        out_filename = File.expand_path(File.join(out_dir, "#{image}.webp.png"))
+        WebpFfi.decode(in_filename, out_filename)
+      end
+    end
+  end
+  
+  context "encode" do
+    factories[:png].each do |image|
+      it "#{image}.png image" do
+        out_dir = File.expand_path(File.join(File.dirname(__FILE__), "../tmp/"))
+        Dir.mkdir(out_dir) unless File.exists?(out_dir)
+        in_filename = File.expand_path(File.join(File.dirname(__FILE__), "factories/#{image}.png"))
+        out_filename = File.expand_path(File.join(out_dir, "#{image}.png.webp"))
+        WebpFfi.encode(in_filename, out_filename)
       end
     end
   end

data/webp-ffi.gemspec

@@ -25,5 +25,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.2"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "vagrant"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webp-ffi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-08 00:00:00.000000000 Z
+date: 2013-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -75,22 +75,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: vagrant
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Ruby wrapper for libwebp
 email:
 - leopard.not.a@gmail.com
@@ -115,6 +99,7 @@ files:
 - lib/webp_ffi.rb
 - lib/webp_ffi/c.rb
 - lib/webp_ffi/error.rb
+- lib/webp_ffi/libc.rb
 - lib/webp_ffi/version.rb
 - lib/webp_ffi/webp_ffi.rb
 - spec/bindings.md
@@ -149,7 +134,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 488812102417916187
+      hash: -112599722798268677
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -158,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 488812102417916187
+      hash: -112599722798268677
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25