free-image 0.5.0

data/lib/free-image/sources/file.rb

@@ -0,0 +1,115 @@
+module FreeImage
+  # DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size FI_DEFAULT(0));
+  attach_function('FreeImage_GetFileType', [:string, :int], :format)
+
+  # DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFIFFromFilename(const char *filename);
+  attach_function('FreeImage_GetFIFFromFilename', [:string], :format)
+
+  # DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Load(FREE_IMAGE_FORMAT fif, const char *filename, int flags FI_DEFAULT(0));
+  attach_function('FreeImage_Load', [:format, :string, :int], :pointer)
+
+  # DLL_API BOOL DLL_CALLCONV FreeImage_FIFSupportsReading(FREE_IMAGE_FORMAT fif);
+  attach_function('FreeImage_FIFSupportsReading', [:format], FreeImage::Boolean)
+
+  # DLL_API BOOL DLL_CALLCONV FreeImage_Save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, const char *filename, int flags FI_DEFAULT(0));
+  attach_function('FreeImage_Save', [:format, :pointer, :string, :int], FreeImage::Boolean)
+
+  # == Summary
+  #
+  # Supports loading and saving images to a file.
+  #
+  # == Usage
+  #
+  #   # Open a file
+  #   src = FreeImage::File.new('test/fixtures/lena.png')
+  #   image = src.open
+  #   
+  #   # Save a file
+  #   dest = FreeImage::File.new('test/fixtures/lena_new.jpeg')
+  #   image.save(dest, :jpeg)
+  #
+  class File < AbstractSource
+    ##
+    # :call-seq:
+    #   file.open(format = nil, flags = 0) -> FreeImage::Bitmap
+    #
+    # Opens an image from a file.
+    #
+    # == Parameters
+    # format:: By default FreeImage will automatically determine an image's format.  However,
+    #           you may override this value by using this parameter to specify a
+    #           particular {format}[rdoc-ref:FreeImage.formats].
+    # flags:: Format specific flags that control how a bitmap is loaded.  These flags are defined
+    #          as constants on the AbstractSource::Decoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   source = File.new('<path_to_file>')
+    #   source.open(:jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #
+
+    # Create a new FreeImage::File instance that can read and write image data
+    # from a file.
+    #
+    # == Parameters
+    # image_path:: The full path to a image file.
+    #
+    def initialize(image_path)
+      @image_path = image_path
+    end
+
+    # :call-seq:
+    #    file.format -> :format
+    #
+    # Returns the image {format}[rdoc-ref:FreeImage.formats] for a file. If the image format cannot
+    # be determined then will return :unknown.
+    #
+    def format
+      result = FreeImage.FreeImage_GetFileType(@image_path, 0)
+      FreeImage.check_last_error
+
+      if result == :unknown
+        # Try to guess the file format from the file extension
+        result = FreeImage.FreeImage_GetFIFFromFilename(@image_path)
+        FreeImage.check_last_error
+      end
+      result
+    end
+
+    ##
+    # :call-seq:
+    #   file.save(format = nil, flags = 0) -> boolean
+    #
+    # Saves an image to a file.
+    #
+    # == Parameters
+    # format:: The format[rdoc-ref:FreeImage.formats] to save the image to.
+    # flags:: Format specific flags that control how a bitmap is saved.  These flags are defined
+    #          as constants on the AbstractSource::Encoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   image = Bimap.open('<path_to_file>')
+    #   dst = File.new('<path_to_new_file>')
+    #   dst.save(image, :jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #
+    def save(bitmap, format, flags = 0)
+      result = FreeImage.FreeImage_Save(format, bitmap, @image_path, flags)
+      FreeImage.check_last_error
+      result
+    end
+
+    private
+
+    def load(format, flags)
+      if format == :unknown
+       # raise(Error, "Cannot load unknown file format")
+      end
+      ptr = FreeImage.FreeImage_Load(format, @image_path, flags)
+      FreeImage.check_last_error
+      ptr
+    end
+  end
+end

data/lib/free-image/sources/io.rb

@@ -0,0 +1,154 @@
+module FreeImage
+  typedef :pointer, :handle
+  
+  #typedef unsigned (DLL_CALLCONV *FI_ReadProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+  callback :read_proc_callback, [:pointer, :ulong, :ulong, :handle], :ulong
+
+  #typedef unsigned (DLL_CALLCONV *FI_WriteProc) (void *buffer, unsigned size, unsigned count, fi_handle handle);
+  callback :write_proc_callback, [:pointer, :ulong, :ulong, :handle], :ulong
+
+  #typedef int (DLL_CALLCONV *FI_SeekProc) (fi_handle handle, long offset, int origin);
+  callback :seek_proc_callback, [:handle, :long, :int], :ulong
+
+  #typedef long (DLL_CALLCONV *FI_TellProc) (fi_handle handle);
+  callback :tell_proc_callback, [:handle], :long
+
+  class IOStruct < FFI::Struct
+    layout :read_proc,  :read_proc_callback,
+           :write_proc, :write_proc_callback,
+           :seek_proc,  :seek_proc_callback,
+           :tell_proc,  :tell_proc_callback
+  end
+
+  # DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size FI_DEFAULT(0));
+  attach_function('FreeImage_GetFileTypeFromHandle', [FreeImage::IOStruct, :handle, :int], :format)
+
+  # DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+  attach_function('FreeImage_LoadFromHandle', [:format, FreeImage::IOStruct, :handle, :int], :pointer)
+
+  # DLL_API BOOL DLL_CALLCONV FreeImage_SaveToHandle(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FreeImageIO *io, fi_handle handle, int flags FI_DEFAULT(0));
+  attach_function('FreeImage_SaveToHandle', [:format, :pointer, FreeImage::IOStruct, :handle, :int], FreeImage::Boolean)
+
+  # == Summary
+  #
+  # Supports loading and saving images to a Ruby IO stream.
+  #
+  # == Usage
+  #
+  #   # Read an image from an io stream string
+  #   file = ::File.open('test/fixtures/lena.png', :encoding => Encoding::BINARY)
+  #   image = FreeImage::IO.open(file)
+  #
+  #   # Save an image to a byte string
+  #   dest = FreeImage::IO.new(::File.open('test/fixtures/lena_new.png', :encoding => Encoding::BINARY))
+  #   image.save(dest, :jpeg)
+  #   dest.bytes
+  #
+  class IO < AbstractSource
+    ##
+    # :call-seq:
+    #   io.open(format = nil, flags = 0) -> FreeImage::Bitmap
+    #
+    # Opens an image from a Ruby IO stream.
+    #
+    # == Parameters
+    # format:: By default FreeImage will automatically determine an image's format.  However,
+    #           you may override this value by using this parameter to specify a
+    #           particular {format}[rdoc-ref:FreeImage.formats].
+    # flags:: Format specific flags that control how a bitmap is loaded.  These flags are defined
+    #          as constants on the AbstractSource::Decoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   source = FreeImage::IO.new(::File.open('<path_to_file>'))
+    #   source.open(:jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #
+
+    # Create a new FreeImage::IO instance that can read and write image data
+    # from a Ruby IO stream.
+    #
+    # == Parameters
+    # io:: A standard Ruby io stream such as a file.
+    #
+    def initialize(io)
+      @io = io
+
+      @handle = FFI::MemoryPointer.new(:int)
+      @handle.put_int(0, self.object_id)
+
+      @ffi_io = FreeImage::IOStruct.new
+      @ffi_io[:read_proc] = method(:read)
+      @ffi_io[:write_proc] = method(:write)
+      @ffi_io[:seek_proc] = method(:seek)
+      @ffi_io[:tell_proc] = method(:tell)
+    end
+
+
+    # call-seq:
+    #    handle.image_type -> :format
+    #
+    # Returns the image format for a memory stream. If the image format cannot be determined
+    # the :unknown will be returned.
+    def format
+      result = FreeImage.FreeImage_GetFileTypeFromHandle(@ffi_io, @handle, 0)
+      FreeImage.check_last_error
+      result
+    rescue Errno::EINVAL => e
+      :unknown
+    end
+
+    ##
+    # :call-seq:
+    #   file.save(format = nil, flags = 0) -> boolean
+    #
+    # Saves an image to a file.
+    #
+    # == Parameters
+    # format:: The format[rdoc-ref:FreeImage.formats] to save the image to.
+    # flags:: Format specific flags that control how a bitmap is saved.  These flags are defined
+    #          as constants on the AbstractSource::Encoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   image = Bimap.open('<path_to_file>')
+    #   source = FreeImage::File.new('<path_to_new_file>')
+    #   source.save(image, :jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #
+    def save(bitmap, format, flags = 0)
+      result = FreeImage.FreeImage_SaveToHandle(format, bitmap, @ffi_io, @handle, flags)
+      FreeImage.check_last_error
+      result
+    end
+
+    private
+
+    def load(format, flags)
+      ptr = FreeImage.FreeImage_LoadFromHandle(format, @ffi_io, @handle, flags)
+      FreeImage.check_last_error
+      ptr
+    end
+
+    def read(buffer, size, count, handle)
+      bytes = @io.read(size * count)
+      return 0 unless bytes
+      buffer.put_bytes(0, bytes)
+      bytes.bytesize
+    end
+
+    def write(buffer, size, count, handle)
+      bytes = buffer.get_bytes(0, size * count)
+      @io.write(bytes)
+      bytes.bytesize
+    end
+
+    def seek(handle, offset, origin)
+      @io.seek(offset, origin)
+    end
+
+    def tell(handle)
+      @io.tell
+    end
+  end
+end

data/lib/free-image/sources/memory.rb

@@ -0,0 +1,189 @@
+module FreeImage
+  typedef :pointer, :memory
+
+  #DLL_API void DLL_CALLCONV FreeImage_CloseMemory(FIMEMORY *stream);
+  attach_function('FreeImage_CloseMemory', [:memory], :void)
+
+  #DLL_API FIMEMORY *DLL_CALLCONV FreeImage_OpenMemory(BYTE *data FI_DEFAULT(0), DWORD size_in_bytes FI_DEFAULT(0));
+  attach_function('FreeImage_OpenMemory', [:pointer, :dword], :memory)
+
+  # DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size FI_DEFAULT(0));
+  attach_function('FreeImage_GetFileTypeFromMemory', [:memory, :int], :format)
+
+  # DLL_API FIBITMAP *DLL_CALLCONV FreeImage_LoadFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0))
+  attach_function('FreeImage_LoadFromMemory', [:format, :memory, :int], :pointer)
+
+  # DLL_API BOOL DLL_CALLCONV FreeImage_SaveToMemory(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, FIMEMORY *stream, int flags FI_DEFAULT(0));
+  attach_function('FreeImage_SaveToMemory', [:format, :pointer, :memory, :int], FreeImage::Boolean)
+
+  #DLL_API unsigned DLL_CALLCONV FreeImage_ReadMemory(void *buffer, unsigned size, unsigned count, FIMEMORY *stream);
+  attach_function('FreeImage_ReadMemory', [:pointer, :ulong, :ulong, :memory], :ulong)
+
+  # DLL_API long DLL_CALLCONV FreeImage_TellMemory(FIMEMORY *stream);
+  attach_function('FreeImage_TellMemory', [:memory], :long)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_SeekMemory(FIMEMORY *stream, long offset, int origin);
+  attach_function('FreeImage_SeekMemory', [:memory, :long, :int], FreeImage::Boolean)
+
+  #DLL_API BOOL DLL_CALLCONV FreeImage_AcquireMemory(FIMEMORY *stream, BYTE **data, DWORD *size_in_bytes);
+  #DLL_API unsigned DLL_CALLCONV FreeImage_WriteMemory(const void *buffer, unsigned size, unsigned count, FIMEMORY *stream);
+  #DLL_API FIMULTIBITMAP *DLL_CALLCONV FreeImage_LoadMultiBitmapFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream, int flags FI_DEFAULT(0));
+  #DLL_API BOOL DLL_CALLCONV FreeImage_SaveMultiBitmapToMemory(FREE_IMAGE_FORMAT fif, FIMULTIBITMAP *bitmap, FIMEMORY *stream, int flags);
+
+  # Wrapper for a FreeImage memory stream which allows images to be read and written
+  # to memory.  Memory streams are usefule for storing images as blobs in a database
+  # or writing them to an to a Internet stream.
+  class MemoryStream < FFI::AutoPointer
+    def self.release(ptr)
+      FreeImage.FreeImage_CloseMemory(ptr)
+      FreeImage.check_last_error
+    end
+
+    # Create a new memory stream.
+    #
+    # == Parameters
+    # bytes::  If specified, a binary encoded Ruby string that stores image data.  FreeImage
+    #          will treat the string as read-only.  If not specified, a writable MemoryStream
+    #          is created.
+    def initialize(bytes = nil)
+      ptr = if bytes
+        buf = FFI::MemoryPointer.from_string(bytes)
+        FreeImage.FreeImage_OpenMemory(buf, bytes.bytesize)
+      else
+        FreeImage.FreeImage_OpenMemory(nil, 0)
+      end
+      FreeImage.check_last_error
+
+      super(ptr)
+    end
+
+    # Returns the size of the memory stream.
+    def count
+      # Store current position
+      pos = FreeImage.FreeImage_TellMemory(self)
+      FreeImage.check_last_error
+
+      # Go to end of stream to get length
+      FreeImage.FreeImage_SeekMemory(self, 0, ::IO::SEEK_END)
+      FreeImage.check_last_error
+      count = FreeImage.FreeImage_TellMemory(self)
+
+      # Restore position
+      FreeImage.FreeImage_SeekMemory(self, pos, ::IO::SEEK_SET)
+      FreeImage.check_last_error
+
+      count
+    end
+
+    # Returns the bytes of the memory stream.
+    def bytes
+      size = FFI::Type::CHAR.size
+
+      # Reset memory to start
+      FreeImage.FreeImage_SeekMemory(self, 0, ::IO::SEEK_SET)
+      FreeImage.check_last_error
+
+      buffer = FFI::MemoryPointer.new(FFI::Type::CHAR, size * count)
+      FreeImage.check_last_error
+      size = FreeImage.FreeImage_ReadMemory(buffer, size, count, self)
+      buffer.null? ? nil : buffer.read_string
+    end
+  end
+
+  # == Summary
+  #
+  # Supports loading and saving images to a Ruby string.
+  #
+  # == Usage
+  #
+  #   # Read an image from a byte string
+  #   bytes = ::File.read('test/fixtures/lena.png', :encoding => Encoding::BINARY)
+  #   image = FreeImage::Memory.open(bytes)
+  #
+  #   # Save an image to a byte string
+  #   dest = FreeImage::Memory.new
+  #   image.save(dest, :jpeg)
+  #   dest.bytes
+  #
+  class Memory < AbstractSource
+    ##
+    # MemoryStream used to read and write data
+    attr_reader :memory
+    
+    ##
+    # :call-seq:
+    #   file.open(format = nil, flags = 0) -> FreeImage::Bitmap
+    #
+    # Opens an image from a file.
+    #
+    # == Parameters
+    # format:: By default FreeImage will automatically determine an image's format.  However,
+    #           you may override this value by using this parameter to specify a
+    #           particular {format}[rdoc-ref:FreeImage.formats].
+    # flags:: Format specific flags that control how a bitmap is loaded.  These flags are defined
+    #          as constants on the AbstractSource::Decoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   source = File.new('<path_to_file>')
+    #   source.open(:jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #
+   
+    # Create a new FreeImage::File instance that can read and write image data
+    # from memory.
+    #
+    # == Parameters
+    # bytes:: If specified, FreeImage will read image from the bytes string and treat
+    #         it as readonly.  If not specified, then FreeImage will create a writable
+    #         memory stream.
+    #
+    def initialize(bytes = nil)
+      @memory = MemoryStream.new(bytes)
+    end
+
+    # call-seq:
+    #    memory.format -> :format
+    #
+    # Returns the image format for a memory stream. If the image format cannot be determined
+    # the :unknown will be returned.
+    def format
+      result = FreeImage.FreeImage_GetFileTypeFromMemory(@memory, 0)
+      FreeImage.check_last_error
+      result
+    end
+
+    ##
+    # :call-seq:
+    #   memory.save(format = nil, flags = 0) -> boolean
+    #
+    # Saves an image to memory.
+    #
+    # == Parameters
+    # format:: The format[rdoc-ref:FreeImage.formats] to save the image to.
+    # flags:: Format specific flags that control how a bitmap is saved.  These flags are defined
+    #          as constants on the AbstractSource::Encoder module.  Flags can be combined using
+    #          Ruby's bitwise or operator (|)
+    #
+    # == Usage
+    #
+    #   image = Bimap.open('<path_to_file>')
+    #   dst = FreeImage::Memory.new
+    #   dst.save(image, :jpeg, AbtractSource::JPEG_QUALITYSUPERB | AbtractSource::JPEG_PROGRESSIVE)
+    #   dst.bytes
+    #
+    def save(bitmap, format, flags = 0)
+      result = FreeImage.FreeImage_SaveToMemory(format, bitmap, @memory, flags)
+      FreeImage.check_last_error
+      result
+    end
+
+    private
+
+    def load(format, flags)
+      ptr = FreeImage.FreeImage_LoadFromMemory(format, @memory, flags)
+      FreeImage.check_last_error
+      ptr
+    end
+  end
+end