vips 8.6.3

data/lib/vips/access.rb

@@ -0,0 +1,11 @@
+module Vips
+    # The type of access an operation has to supply. 
+    # 
+    # *   `:random` means requests can come in any order. 
+    # 
+    # *   `:sequential` means requests will be top-to-bottom, but with some
+    #     amount of buffering behind the read point for small non-local
+    #     accesses. 
+    class Access < Symbol
+    end
+end

data/lib/vips/align.rb

@@ -0,0 +1,11 @@
+module Vips
+
+    # Various types of alignment. See {Image#join}, for example.
+    #
+    # * `:low` Align on the low coordinate edge
+    # * `:centre` Align on the centre
+    # * `:high` Align on the high coordinate edge
+
+    class Align < Symbol
+    end
+end

data/lib/vips/angle.rb

@@ -0,0 +1,12 @@
+module Vips
+
+    # Various fixed 90 degree rotation angles. See {Image#rot}.
+    #
+    # * `:d0` no rotate
+    # * `:d90` 90 degrees clockwise
+    # * `:d180` 180 degrees 
+    # * `:d270` 90 degrees anti-clockwise
+
+    class Angle < Symbol
+    end
+end

data/lib/vips/angle45.rb

@@ -0,0 +1,16 @@
+module Vips
+
+    # Various fixed 45 degree rotation angles. See {Image#rot45}.
+    #
+    # * `:d0` no rotate
+    # * `:d45` 45 degrees clockwise 
+    # * `:d90` 90 degrees clockwise
+    # * `:d135` 135 degrees clockwise
+    # * `:d180` 180 degrees 
+    # * `:d225` 135 degrees anti-clockwise
+    # * `:d270` 90 degrees anti-clockwise
+    # * `:d315` 45 degrees anti-clockwise
+
+    class Angle45 < Symbol
+    end
+end

data/lib/vips/bandformat.rb

@@ -0,0 +1,20 @@
+module Vips
+
+    # The format used for each band element. Each corresponds to a native C type
+    # for the current machine.
+    #
+    # * `:notset` invalid setting
+    # * `:uchar` unsigned char format
+    # * `:char` char format
+    # * `:ushort` unsigned short format
+    # * `:short` short format
+    # * `:uint` unsigned int format
+    # * `:int` int format
+    # * `:float` float format
+    # * `:complex` complex (two floats) format
+    # * `:double` double float format
+    # * `:dpcomplex` double complex (two double) format
+    class BandFormat < Symbol
+    end
+
+end

data/lib/vips/coding.rb

@@ -0,0 +1,14 @@
+module Vips
+
+    # How pixels are coded. 
+    #
+    # Normally, pixels are uncoded and can be manipulated as you would expect.
+    # However some file formats code pixels for compression, and sometimes it's
+    # useful to be able to manipulate images in the coded format.
+    #
+    # * `:none` pixels are not coded
+    # * `:labq` pixels encode 3 float CIELAB values as 4 uchar
+    # * `:rad` pixels encode 3 float RGB as 4 uchar (Radiance coding)
+    class Coding < Symbol
+    end
+end

data/lib/vips/compass_direction.rb

@@ -0,0 +1,17 @@
+module Vips
+
+    # A direction on a compass used for placing images. See {Image#gravity}.
+    #
+    # * `:centre`
+    # * `:north`
+    # * `:east`
+    # * `:south`
+    # * `:west`
+    # * `:north-east`
+    # * `"south-east`
+    # * `:south-west`
+    # * `:north-west`
+
+    class CompassDirection < Symbol
+    end
+end

data/lib/vips/direction.rb

@@ -0,0 +1,11 @@
+module Vips
+
+    # Operations like {Image#flip} need to be told whether to flip 
+    # left-right or top-bottom. 
+    #
+    # *   `:horizontal` left-right 
+    # *   `:vertical` top-bottom
+
+    class Direction < Symbol
+    end
+end

data/lib/vips/extend.rb

@@ -0,0 +1,17 @@
+module Vips
+
+    # When the edges of an image are extended, you can specify
+    # how you want the extension done. 
+    # See {Image#embed}, {Image#conv}, {Image#affine} and 
+    # so on.
+    #
+    # * `:black` new pixels are black, ie. all bits are zero. 
+    # * `:copy` each new pixel takes the value of the nearest edge pixel
+    # * `:repeat` the image is tiled to fill the new area
+    # * `:mirror` the image is reflected and tiled to reduce hash edges
+    # * `:white` new pixels are white, ie. all bits are set
+    # * `:background` colour set from the @background property
+
+    class Extend < Symbol
+    end
+end

data/lib/vips/gobject.rb

@@ -0,0 +1,122 @@
+# This module provides an interface to the top level bits of GObject
+# via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require 'ffi'
+require 'forwardable'
+
+module GObject
+
+    # we have a number of things we need to inherit in different ways:
+    #
+    # - we want to be able to subclass GObject in Ruby in a simple way
+    # - the layouts of the nested structs need to inherit
+    # - we need to be able to cast between structs which share a base struct
+    #   without creating new wrappers or messing up refcounting
+    # - we need automatic gobject refcounting
+    #
+    # the solution is to split the class into four areas which we treat
+    # differently:
+    #
+    # - we have a "wrapper" Ruby class to allow easy subclassing ... this has a
+    #   @struct member which holds the actual pointer
+    # - we use "forwardable" to forward the various ffi methods on to the
+    #   @struct member ... we arrange things so that subclasses do not need to
+    #   do the forwarding themselves
+    # - we have two versions of the struct: a plain one which we can use for
+    #   casting that will not change the refcounts
+    # - and a managed one with an unref which we just use for .new
+    # - we separate the struct layout into a separate module to avoid repeating
+    #   ourselves
+
+    class GObject
+        extend Forwardable
+        extend SingleForwardable
+
+        def_instance_delegators :@struct, :[], :to_ptr
+        def_single_delegators :ffi_struct, :ptr
+
+        # the layout of the GObject struct
+        module GObjectLayout
+            def self.included base
+                base.class_eval do
+                    layout :g_type_instance, :pointer,
+                           :ref_count, :uint,
+                           :qdata, :pointer
+                end
+            end
+        end
+
+        # the struct with unref ... manage object lifetime with this
+        class ManagedStruct < FFI::ManagedStruct
+            include GObjectLayout
+
+            def self.release ptr
+                # GLib::logger.debug("GObject::GObject::ManagedStruct.release") {
+                #     "unreffing #{ptr}"
+                # }
+                ::GObject::g_object_unref ptr
+            end
+        end
+
+        # the plain struct ... cast with this
+        class Struct < FFI::Struct
+            include GObjectLayout
+
+        end
+
+        # don't allow ptr == nil, we never want to allocate a GObject struct
+        # ourselves, we just want to wrap GLib-allocated GObjects
+        #
+        # here we use ManagedStruct, not Struct, since this is the ref that will
+        # need the unref
+        def initialize ptr
+            # GLib::logger.debug("GObject::GObject.initialize") {"ptr = #{ptr}"}
+            @struct = ffi_managed_struct.new ptr
+        end
+
+        # access to the casting struct for this class
+        def ffi_struct
+            self.class.ffi_struct
+        end
+
+        class << self
+            def ffi_struct
+                self.const_get :Struct
+            end
+        end
+
+        # access to the managed struct for this class
+        def ffi_managed_struct
+            self.class.ffi_managed_struct
+        end
+
+        class << self
+            def ffi_managed_struct
+                self.const_get :ManagedStruct
+            end
+        end
+
+    end
+
+    class GParamSpec < FFI::Struct
+        # the first few public fields
+        layout :g_type_instance, :pointer,
+               :name, :string,
+               :flags, :uint,
+               :value_type, :GType,
+               :owner_type, :GType
+    end
+
+    class GParamSpecPtr < FFI::Struct
+        layout :value, GParamSpec.ptr
+    end
+
+    attach_function :g_param_spec_get_blurb, [GParamSpec.ptr], :string
+
+    attach_function :g_object_ref, [:pointer], :void
+    attach_function :g_object_unref, [:pointer], :void
+
+end

data/lib/vips/gvalue.rb

@@ -0,0 +1,281 @@
+# This module provides an interface GValue via ruby-ffi.
+#
+# Author::    John Cupitt  (mailto:jcupitt@gmail.com)
+# License::   MIT
+
+require 'ffi'
+
+module GObject
+
+    # Represent a GValue. Example use:
+    #
+    # ```ruby
+    # gvalue = GValue::alloc
+    # gvalue.init GObject::GDOUBLE_TYPE
+    # gvalue.set 3.1415
+    # value = gvalue.get
+    # ```
+    #
+    # Lifetime is managed automatically. It doesn't know about all GType values,
+    # but it does know the ones that libvips uses. 
+
+    class GValue < FFI::ManagedStruct
+        layout :gtype, :GType, 
+               :data, [:ulong_long, 2]
+
+        # convert an enum value (str/symb/int) into an int ready for libvips
+        def self.from_nick(gtype, value)
+            value = value.to_s if value.is_a? Symbol
+
+            if value.is_a? String
+                value = Vips::vips_enum_from_nick "ruby-vips", gtype, value
+                if value == -1
+                    raise Vips::Error
+                end
+            end
+
+            value
+        end
+
+        # convert an int enum back into a symbol
+        def self.to_nick(gtype, enum_value)
+            enum_name = Vips::vips_enum_nick gtype, enum_value
+            if enum_name == nil
+                raise Vips::Error
+            end
+
+            enum_name.to_sym
+        end
+
+        def self.release ptr
+            # GLib::logger.debug("GObject::GValue::release") {"ptr = #{ptr}"}
+            ::GObject::g_value_unset ptr 
+        end
+
+        # Allocate memory for a GValue and return a class wrapper. Memory will
+        # be freed automatically when it goes out of scope. The GValue is inited
+        # to 0, use {GValue.init} to set a type.
+        #
+        # @return [GValue] a new gvalue set to 0
+        def self.alloc
+            # allocate memory
+            memory = FFI::MemoryPointer.new GValue
+
+            # make this alloc autorelease ... we mustn't release in 
+            # GValue::release, since we are used to wrap GValue pointers 
+            # made by other people
+            pointer = FFI::Pointer.new GValue, memory
+
+            # ... and wrap in a GValue
+            return GValue.new pointer
+        end
+
+        # Set the type of thing a gvalue can hold.
+        #
+        # @param gtype [GType] the type of thing this GValue can hold.
+        def init gtype
+            ::GObject::g_value_init self, gtype
+        end
+
+        # Set the value of a GValue. The value is converted to the type of the
+        # GValue, if possible.
+        #
+        # @param value [Any] The value to set
+        def set value
+            # GLib::logger.debug("GObject::GValue.set") {
+            #     "value = #{value.inspect[0..50]}"
+            # }
+
+            gtype = self[:gtype]
+            fundamental = ::GObject::g_type_fundamental gtype
+
+            case gtype
+            when GBOOL_TYPE
+                ::GObject::g_value_set_boolean self, (value ? 1 : 0)
+
+            when GINT_TYPE
+                ::GObject::g_value_set_int self, value
+
+            when GUINT64_TYPE
+                ::GObject::g_value_set_uint64 self, value
+
+            when GDOUBLE_TYPE
+                ::GObject::g_value_set_double self, value
+
+            when GSTR_TYPE
+                ::GObject::g_value_set_string self, value
+
+            when Vips::REFSTR_TYPE
+                ::Vips::vips_value_set_ref_string self, value
+
+            when Vips::ARRAY_INT_TYPE
+                value = [value] unless value.is_a? Array
+
+                Vips::vips_value_set_array_int self, nil, value.length
+                ptr = Vips::vips_value_get_array_int self, nil
+                ptr.write_array_of_int32 value
+
+            when Vips::ARRAY_DOUBLE_TYPE
+                value = [value] unless value.is_a? Array
+
+                # this will allocate an array in the gvalue
+                Vips::vips_value_set_array_double self, nil, value.length
+
+                # pull the array out and fill it
+                ptr = Vips::vips_value_get_array_double self, nil
+
+                ptr.write_array_of_double value
+
+            when Vips::ARRAY_IMAGE_TYPE
+                value = [value] unless value.is_a? Array
+
+                Vips::vips_value_set_array_image self, value.length
+                ptr = Vips::vips_value_get_array_image self, nil
+                ptr.write_array_of_pointer value
+
+                # the gvalue needs a ref on each of the images
+                value.each {|image| ::GObject::g_object_ref image}
+
+            when Vips::BLOB_TYPE
+                len = value.bytesize
+                ptr = GLib::g_malloc len
+                Vips::vips_value_set_blob self, GLib::G_FREE, ptr, len
+                ptr.write_bytes value
+
+            else
+                case fundamental
+                when GFLAGS_TYPE
+                    ::GObject::g_value_set_flags self, value
+
+                when GENUM_TYPE
+                    enum_value = GValue.from_nick(self[:gtype], value)
+                    ::GObject::g_value_set_enum self, enum_value
+
+                when GOBJECT_TYPE
+                    ::GObject::g_value_set_object self, value
+
+                else
+                    raise Vips::Error, "unimplemented gtype for set: " +
+                        "#{::GObject::g_type_name gtype} (#{gtype})"
+
+                end
+            end
+        end
+
+        # Get the value of a GValue. The value is converted to a Ruby type in
+        # the obvious way. 
+        #
+        # @return [Any] the value held by the GValue
+        def get
+            gtype = self[:gtype]
+            fundamental = ::GObject::g_type_fundamental gtype
+            result = nil
+
+            case gtype
+            when GBOOL_TYPE
+                result = ::GObject::g_value_get_boolean(self) != 0 ? true : false
+
+            when GINT_TYPE
+                result = ::GObject::g_value_get_int self
+
+            when GUINT64_TYPE
+                result = ::GObject::g_value_get_uint64 self
+
+            when GDOUBLE_TYPE
+                result = ::GObject::g_value_get_double self
+
+            when GSTR_TYPE
+                result = ::GObject::g_value_get_string self
+
+            when Vips::REFSTR_TYPE
+                len = Vips::SizeStruct.new
+                result = ::Vips::vips_value_get_ref_string self, len
+
+            when Vips::ARRAY_INT_TYPE
+                len = Vips::IntStruct.new
+                array = Vips::vips_value_get_array_int self, len
+                result = array.get_array_of_int32 0, len[:value]
+
+            when Vips::ARRAY_DOUBLE_TYPE
+                len = Vips::IntStruct.new
+                array = Vips::vips_value_get_array_double self, len
+                result = array.get_array_of_double 0, len[:value]
+
+            when Vips::ARRAY_IMAGE_TYPE
+                len = Vips::IntStruct.new
+                array = Vips::vips_value_get_array_image self, len
+                result = array.get_array_of_pointer 0, len[:value]
+                result.map! do |pointer| 
+                    ::GObject::g_object_ref pointer
+                    Vips::Image.new pointer
+                end
+
+            when Vips::BLOB_TYPE
+                len = Vips::SizeStruct.new
+                array = Vips::vips_value_get_blob self, len
+                result = array.get_bytes 0, len[:value]
+
+            else
+                case fundamental
+                when GFLAGS_TYPE
+                    result = ::GObject::g_value_get_flags self
+
+                when GENUM_TYPE
+                    enum_value = ::GObject::g_value_get_enum(self)
+                    result = GValue.to_nick self[:gtype], enum_value
+
+                when GOBJECT_TYPE
+                    obj = ::GObject::g_value_get_object self
+                    # g_value_get_object() does not add a ref ... we need to add
+                    # one to match the unref in gobject release
+                    ::GObject::g_object_ref obj
+                    result = Vips::Image.new obj
+
+                else
+                    raise Vips::Error, "unimplemented gtype for get: " +
+                        "#{::GObject::g_type_name gtype} (#{gtype})"
+
+                end
+            end
+
+            # GLib::logger.debug("GObject::GValue.get") {
+            #     "result = #{result.inspect[0..50]}"
+            # }
+
+            return result
+
+        end
+
+    end
+
+    attach_function :g_value_init, [GValue.ptr, :GType], :void
+
+    # we must use a plain :pointer here, since we call this from #release, which
+    # just gives us the unwrapped pointer, not the ruby class
+    attach_function :g_value_unset, [:pointer], :void
+
+    attach_function :g_value_set_boolean, [GValue.ptr, :int], :void
+    attach_function :g_value_set_int, [GValue.ptr, :int], :void
+    attach_function :g_value_set_uint64, [GValue.ptr, :uint64], :void
+    attach_function :g_value_set_double, [GValue.ptr, :double], :void
+    attach_function :g_value_set_enum, [GValue.ptr, :int], :void
+    attach_function :g_value_set_flags, [GValue.ptr, :uint], :void
+    attach_function :g_value_set_string, [GValue.ptr, :string], :void
+    attach_function :g_value_set_object, [GValue.ptr, :pointer], :void
+
+    attach_function :g_value_get_boolean, [GValue.ptr], :int
+    attach_function :g_value_get_int, [GValue.ptr], :int
+    attach_function :g_value_get_uint64, [GValue.ptr], :uint64
+    attach_function :g_value_get_double, [GValue.ptr], :double
+    attach_function :g_value_get_enum, [GValue.ptr], :int
+    attach_function :g_value_get_flags, [GValue.ptr], :int
+    attach_function :g_value_get_string, [GValue.ptr], :string
+    attach_function :g_value_get_object, [GValue.ptr], :pointer
+
+    # use :pointer rather than GObject.ptr to avoid casting later
+    attach_function :g_object_set_property, 
+        [:pointer, :string, GValue.ptr], :void
+    attach_function :g_object_get_property, 
+        [:pointer, :string, GValue.ptr], :void
+
+end