gd2-ffij 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6aa4ff4f4aa7e5c580dd3c9d464c8c1df57a98a5
-  data.tar.gz: 211bf9eef3b61bffe85ec4a2e5a2a97affe26bad
+SHA256:
+  metadata.gz: 052cd08377d7f0f72c6c17f29430aacc3abef04cd6e9544ed6303b6dd9f4ed0d
+  data.tar.gz: a00523e57b7df91beb60ed248c6b9f8a33447fef6c0eeb41bbbbcb9b5aca5d18
 SHA512:
-  metadata.gz: b7ed5a027a534a36f2b144392aa8e1f1f56e2a3c2e230d31f4d31409353ab8d7a6d7a9846d12d024ccc9d9b892219e8a4e27a48d2a4b7cc641cdfcc3e7efde88
-  data.tar.gz: 3b5973311c1080fe04273a0dd4923589f9192b1265fe3e5b2fe607acb648af87001fd7fc54cd72a35a02664a26c23c5db60595182d404f1aabbc9e254092a411
+  metadata.gz: 4354f71430291fd6c4b3a986108561d37be95f409dcaa8062f1b0f5b46b19d24ff9d22654210e7b6758a9b7c5db7d22f1ed9b93d06d15863b73b626842a5005f
+  data.tar.gz: f741e53c0661bb400b21197a7b08ab04cd94b595cca2b83d5bb7d010f4deb1c2891b8193d5f2b199ba37f6377c5a81ec16e3ff362c52a429da5b64be0a98369c

data/.travis.yml

@@ -3,9 +3,9 @@ cache: bundler
 sudo: false
 language: ruby
 rvm:
+  - 2.5.1
   - 2.4.2
   - 2.3.5
-  - 2.2.8
   - rbx-3
   - jruby-head
 matrix:

data/COPYRIGHT

@@ -16,7 +16,7 @@ See https://github.com/dark-panda/gd2-ffij/issues/10 ("Consider moving back to
 BSD now that FFI is back to BSD?") for details.
 
 
-Subsequent code added and modified to create gd2-ffij copyright (C) 2010-2017
+Subsequent code added and modified to create gd2-ffij copyright (C) 2010-2019
 J Smith <dark.panda@gmail.com> and published under the MIT license as follows:
 
 Permission is hereby granted, free of charge, to any person

data/lib/gd2-ffij.rb

@@ -59,6 +59,7 @@ module GD2
       :gdImageCreateFromGd2Part           => [ :pointer,  :pointer, :int, :int, :int, :int ],
       :gdImageCreateFromXbm               => [ :pointer,  :pointer ],
       :gdImageCreateFromXpm               => [ :pointer,  :pointer ],
+      :gdImagePaletteCopy                 => [ :void,     :pointer, :pointer ],
       :gdImageCompare                     => [ :int,      :pointer, :pointer ],
       :gdImageJpeg                        => [ :void,     :pointer, :pointer, :int ],
       :gdImageJpegPtr                     => [ :pointer,  :pointer, :pointer, :int ],
@@ -105,6 +106,7 @@ module GD2
       :gdImageColorExactAlpha             => [ :int,      :pointer, :int, :int, :int, :int ],
       :gdImageColorClosestAlpha           => [ :int,      :pointer, :int, :int, :int, :int ],
       :gdImageColorClosestHWB             => [ :int,      :pointer, :int, :int, :int ],
+      :gdImageColorAllocate               => [ :int,      :pointer, :int, :int, :int ],
       :gdImageColorAllocateAlpha          => [ :int,      :pointer, :int, :int, :int, :int ],
       :gdImageColorDeallocate             => [ :void,     :pointer, :int ],
       :gdAlphaBlend                       => [ :int,      :int, :int ],
@@ -122,6 +124,12 @@ module GD2
       :gdImageStringUp                    => [ :void,     :pointer, :pointer, :int, :int, :pointer, :int ],
       :gdImageStringFTEx                  => [ :pointer,  :pointer, :pointer, :int, :pointer, :double, :double, :int, :int, :pointer, :pointer ],
       :gdImageStringFTCircle              => [ :pointer,  :pointer, :int, :int, :double, :double, :double, :pointer, :double, :pointer, :pointer, :int ],
+      :gdImageGifAnimBeginPtr             => [ :pointer,  :pointer, :pointer, :int, :int ],
+      :gdImageGifAnimBegin                => [ :void,     :pointer, :pointer, :int, :int ],
+      :gdImageGifAnimAddPtr               => [ :pointer,  :pointer, :pointer, :int, :int, :int, :int, :int, :pointer ],
+      :gdImageGifAnimAdd                  => [ :void,     :pointer, :pointer, :int, :int, :int, :int, :int, :pointer ],
+      :gdImageGifAnimEnd                  => [ :void,     :pointer ],
+      :gdImageGifAnimEndPtr               => [ :pointer,  :pointer ],
       :gdFontGetSmall                     => [ :pointer ],
       :gdFontGetLarge                     => [ :pointer ],
       :gdFontGetMediumBold                => [ :pointer ],
@@ -179,14 +187,24 @@ module GD2
   ALPHA_TRANSPARENT = 127
 
   class LibraryError < StandardError; end
-end
 
-require 'gd2/image'
-require 'gd2/color'
-require 'gd2/palette'
-require 'gd2/canvas'
-require 'gd2/font'
-require 'gd2/ffi_struct'
+  GD2_BASE = File.join(File.dirname(__FILE__), 'gd2')
+
+  autoload :Image,
+    File.join(GD2_BASE, 'image')
+  autoload :Color,
+    File.join(GD2_BASE, 'color')
+  autoload :Palette,
+    File.join(GD2_BASE, 'palette')
+  autoload :Canvas,
+    File.join(GD2_BASE, 'canvas')
+  autoload :Font,
+    File.join(GD2_BASE, 'font')
+  autoload :FFIStruct,
+    File.join(GD2_BASE, 'ffi_struct')
+  autoload :AnimatedGif,
+    File.join(GD2_BASE, 'animated_gif')
+end
 
 class Numeric
   if not self.instance_methods.include? 'degrees'

data/lib/gd2/animated_gif.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true; encoding: ASCII-8BIT
+#
+# See COPYRIGHT for license details.
+
+class GD2::AnimatedGif
+  class Frame < Struct.new(:ptr, :size)
+    def read
+      ptr.get_bytes(0, size.get_int(0))
+    end
+  end
+
+  def add(ptr, options = {})
+    size = FFI::MemoryPointer.new(:int)
+
+    frame_ptr = if frames.empty?
+      ::GD2::GD2FFI.send(:gdImageGifAnimBeginPtr, ptr.image_ptr, size, -1, 0)
+    else
+      previous_frame_ptr = if options[:previous_frame]
+        options[:previous_frame].image_ptr
+      else
+        FFI::Pointer::NULL
+      end
+
+      ::GD2::GD2FFI.send(:gdImageGifAnimAddPtr, ptr.image_ptr, size, 0, 0, 0, options[:delay].to_i, 1, previous_frame_ptr)
+    end
+
+    raise LibraryError if frame_ptr.null?
+
+    frames << Frame.new(frame_ptr, size)
+  end
+
+  def end
+    size = FFI::MemoryPointer.new(:int)
+
+    frame_ptr = ::GD2::GD2FFI.send(:gdImageGifAnimEndPtr, size)
+
+    raise LibraryError if frame_ptr.null?
+
+    frames << Frame.new(frame_ptr, size)
+  end
+
+  def export(filename_or_io)
+    output = case filename_or_io
+      when String
+        File.open(filename_or_io, 'wb')
+      else
+        filename_or_io
+    end
+
+    frames.each do |frame|
+      output.write(frame.read)
+    end
+
+    output.flush
+    output.rewind
+
+    output
+  end
+
+  private
+
+    def frames
+      return @frames if defined?(@frames)
+
+      @frames = []
+
+      ObjectSpace.define_finalizer(@frames, frames_finalizer)
+
+      @frames
+    end
+
+    def frames_finalizer
+      proc do
+        each do |frame|
+          ::GD2::GD2FFI.send(:gdFree, frame[:frame_ptr])
+        end
+      end
+    end
+end

data/lib/gd2/image.rb

@@ -126,10 +126,31 @@ module GD2
         :wbmp
       when /^gd2/
         :gd2
+      when /^\xff\xff/
+        :gd
       end
     end
     private_class_method :data_type
 
+    def self.extract_format(filename_or_io, options)
+      format = options[:format]
+
+      if !format
+        case filename_or_io
+        when String
+          md = filename_or_io.match(/\.([^.]+)\z/)
+          format = md ? md[1].downcase : nil
+        else
+          magic = filename_or_io.read(4)
+          filename_or_io.seek(-magic.bytes.length, IO::SEEK_CUR)
+          format = data_type(magic.strip)
+        end
+      end
+
+      format = format.to_sym if format
+      format
+    end
+
     # Import an image from a file with the given +filename+. The :format option
     # or the file extension is used to determine the image type (jpeg, png,
     # gif, wbmp, gd, gd2, xbm, or xpm). The resulting image will be either of
@@ -138,21 +159,17 @@ module GD2
     # If the file format is gd2, it is optionally possible to extract only a
     # part of the image. Use options :x, :y, :width, and :height to specify the
     # part of the image to import.
-    def self.import(filename, options = {})
-      raise Errno::ENOENT.new(filename) unless File.exist?(filename)
-
-      unless format = options.delete(:format)
-        md = filename.match(/\.([^.]+)\z/)
-        format = md ? md[1].downcase : nil
-      end
-      format = format.to_sym if format
+    def self.import(filename_or_io, options = {})
+      format = extract_format(filename_or_io, options)
 
       ptr = # TODO: implement xpm and xbm imports
+
       #if format == :xpm
         #raise ArgumentError, "Unexpected options #{options.inspect}" unless options.empty?
         #::GD2::GD2FFI.send(:gdImageCreateFromXpm, filename)
       #elsif format == :xbm
         #::GD2::GD2FFI.send(:gdImageCreateFromXbm, filename)
+
       if format == :gd2 && !options.empty?
         x, y, width, height =
           options.delete(:x) || 0, options.delete(:y) || 0,
@@ -181,12 +198,18 @@ module GD2
         raise UnrecognizedImageTypeError,
           'Format (or file extension) is not recognized' unless create_sym
 
-        file = File.open(filename, 'rb').read
-        file = file.force_encoding("ASCII-8BIT") if file.respond_to? :force_encoding
-        file_ptr = FFI::MemoryPointer.new(file.size, 1, false)
-        file_ptr.put_bytes(0, file)
+        output = case filename_or_io
+        when String
+          File.open(filename_or_io, 'rb').read
+        else
+          filename_or_io.read
+        end
+
+        output = output.force_encoding("ASCII-8BIT") if output.respond_to? :force_encoding
+        file_ptr = FFI::MemoryPointer.new(output.size, 1, false)
+        file_ptr.put_bytes(0, output)
 
-        ::GD2::GD2FFI.send(create_sym, file.size, file_ptr)
+        ::GD2::GD2FFI.send(create_sym, output.size, file_ptr)
       end
       raise LibraryError if ptr.null?
 
@@ -425,17 +448,13 @@ module GD2
       # implemented by subclass
     end
 
-    # Export this image to a file with the given +filename+. The image format
-    # is determined by the :format option, or by the file extension (jpeg, png,
-    # gif, wbmp, gd, or gd2). Returns the size of the written image data.
-    # Additional +options+ are as arguments for the Image#jpeg, Image#png,
-    # Image#wbmp, or Image#gd2 methods.
-    def export(filename, options = {})
-      unless format = options.delete(:format)
-        md = filename.match(/\.([^.]+)\z/)
-        format = md ? md[1].downcase : nil
-      end
-      format = format.to_sym if format
+    # Export this image to a file or stream with the given +filename+. The
+    # image format is determined by the :format option, or by the file
+    # extension (jpeg, png, gif, wbmp, gd, or gd2). Returns the size of the
+    # written image data. Additional +options+ are as arguments for the
+    # Image#jpeg, Image#png, Image#wbmp, or Image#gd2 methods.
+    def export(filename_or_io, options = {})
+      format = self.class.extract_format(filename_or_io, options)
 
       size = FFI::MemoryPointer.new(:pointer)
 
@@ -465,17 +484,24 @@ module GD2
           'Format (or file extension) is not recognized'
       end
 
-      raise ArgumentError, "Unrecognized options #{options.inspect}" unless
-        options.empty?
+      output = case filename_or_io
+        when String
+          File.open(filename_or_io, 'wb')
+        else
+          filename_or_io
+      end
 
-      File.open(filename, 'wb') do |file|
-        begin
-          img = ::GD2::GD2FFI.send(write_sym, image_ptr, *args)
-          file.write(img.get_bytes(0, size.get_int(0)))
-        ensure
-          ::GD2::GD2FFI.gdFree(img)
-        end
+      begin
+        img = ::GD2::GD2FFI.send(write_sym, image_ptr, *args)
+        output.write(img.get_bytes(0, size.get_int(0)))
+      ensure
+        ::GD2::GD2FFI.gdFree(img)
       end
+
+      output.flush
+      output.rewind
+
+      output
     end
 
     # Encode and return data for this image in JPEG format. The +quality+

data/lib/gd2/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true; encoding: ASCII-8BIT
 
 module GD2
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end
 

data/test/animated_gif_tests.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true; encoding: ASCII-8BIT
+
+require './test/test_helper'
+
+class AnimatedGifTest < Minitest::Test
+  include TestHelper
+
+  def test_animation
+    image1 = GD2::Image::IndexedColor.new(256, 256)
+
+    black = image1.palette.allocate(GD2::Color[0, 0, 0])
+    white = image1.palette.allocate(GD2::Color[255, 255, 255])
+    lime = image1.palette.allocate(GD2::Color[0, 255, 0])
+
+    image1.draw do |pen|
+      pen.color = white
+      pen.line(64, 64, 192, 192)
+    end
+
+    image2 = GD2::Image::IndexedColor.new(256, 256)
+    black = image2.palette.allocate(GD2::Color[0, 0, 0])
+    white = image2.palette.allocate(GD2::Color[255, 255, 255])
+    lime = image2.palette.allocate(GD2::Color[0, 255, 0])
+
+    image2.draw do |pen|
+      pen.color = lime
+      pen.rectangle(32, 64, 192, 192)
+    end
+
+    anim = GD2::AnimatedGif.new
+    anim.add(image1)
+    anim.add(image2, delay: 50)
+    anim.add(image1, delay: 50)
+    anim.end
+
+    output = StringIO.new
+
+    anim.export(output)
+
+    assert(output.read == File.read('test/images/test_animated_gif.gif'))
+  end
+end

data/test/image_tests.rb

@@ -77,6 +77,17 @@ class ImageTest < Minitest::Test
         File.unlink(out)
       end
 
+      def test_export_and_import_#{ext}_io
+        img = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.gd2'))
+        out = StringIO.new
+        img.export(out, format: :#{ext})
+
+        imgA = GD2::Image.import(out)
+        imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
+
+        assert(imgA == imgB)
+      end
+
       def test_compare_#{ext}
         imgA = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))
         imgB = GD2::Image.import(File.join(PATH_TO_IMAGES, 'test.#{ext}'))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gd2-ffij
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - J Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-09 00:00:00.000000000 Z
+date: 2019-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -40,6 +40,7 @@ files:
 - Rakefile
 - gd2-ffij.gemspec
 - lib/gd2-ffij.rb
+- lib/gd2/animated_gif.rb
 - lib/gd2/canvas.rb
 - lib/gd2/color.rb
 - lib/gd2/ffi_struct.rb
@@ -47,6 +48,7 @@ files:
 - lib/gd2/image.rb
 - lib/gd2/palette.rb
 - lib/gd2/version.rb
+- test/animated_gif_tests.rb
 - test/canvas_tests.rb
 - test/image_tests.rb
 - test/images/test.bmp
@@ -59,6 +61,7 @@ files:
 - test/images/test.xbm
 - test/images/test.xcf
 - test/images/test.xpm
+- test/images/test_animated_gif.gif
 - test/images/test_arc.gd2
 - test/images/test_canvas_filled_polygon.gd2
 - test/images/test_canvas_filled_rectangle.gd2
@@ -108,12 +111,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: gd2-ffij is a refactoring of the Ruby/GD2 library implemented with FFI
 test_files:
+- test/animated_gif_tests.rb
 - test/canvas_tests.rb
 - test/image_tests.rb
 - test/images/test.bmp
@@ -126,6 +129,7 @@ test_files:
 - test/images/test.xbm
 - test/images/test.xcf
 - test/images/test.xpm
+- test/images/test_animated_gif.gif
 - test/images/test_arc.gd2
 - test/images/test_canvas_filled_polygon.gd2
 - test/images/test_canvas_filled_rectangle.gd2