gif-info 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+  gem "struct-fx", ">= 0.1.1"
+  gem "abstract", ">= 1.0.0"
+  gem "frozen-objects", ">= 0.2.0"
+  
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "riot", ">= 0.12.1"
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    bit-packer (0.1.0)
+      lookup-hash (>= 0.2.0)
+    frozen-objects (0.2.0)
+    git (1.2.5)
+    hash-utils (0.11.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    lookup-hash (0.2.0)
+      hash-utils (>= 0.11.0)
+    rake (0.8.7)
+    riot (0.12.2)
+      rr
+    rr (1.0.2)
+    struct-fx (0.1.1)
+      bit-packer (>= 0.1.0)
+      frozen-objects (>= 0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  abstract (>= 1.0.0)
+  bundler (~> 1.0.0)
+  frozen-objects (>= 0.2.0)
+  jeweler (~> 1.5.2)
+  riot (>= 0.12.1)
+  struct-fx (>= 0.1.1)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Martin Kozák
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+Gif Info
+========
+
+**gif-info** is analyzer of the [GIF image format][1]. It performs complete 
+analysis of internal GIF block structure and streams it as an "object 
+stream" with metainformations of each block. Also can *interpret* internal 
+structure by providing the simple object-like interface to base image 
+file informations. Works above all seekable IO streams, so allows 
+processing of the big files too. Doesn't perform [LZW][2] decompressing, 
+returns raw data for both color tables and images.
+
+Two different approaches are available: **sequential** and **static**. 
+First one yields "stream" of objects which are equivalent to functional 
+blocks in the GIF file and which contain low-level GIF data. It's 
+equivalent of for example [SAX][3] parser although, of sure, less 
+complex. The other one provides classical single object-like access to 
+interpreted file informations. 
+
+Examples of both are available in the `bin` directory. `git-info` 
+command writes out content of the static information object, `git-dump`
+dumps content of low level blocks stream.
+
+Modifiing the file and writing changes back is possible (see [StructFx][5]
+library documentation). It isn't implemented directly by this library,
+but should be easy to implement it if you will need it -- with exception
+of data blocks as comments or image data -- it's necessary split them 
+to blocks manually in your writing routine. Other structures provided
+by the library contains binary serialization routines implicitly.
+
+Contributing
+------------
+
+1. Fork it.
+2. Create a branch (`git checkout -b 20101220-my-change`).
+3. Commit your changes (`git commit -am "Added something"`).
+4. Push to the branch (`git push origin 20101220-my-change`).
+5. Create an [Issue][6] with a link to your branch.
+6. Enjoy a refreshing Diet Coke and wait.
+
+Copyright
+---------
+
+Copyright © 2011 [Martin Kozák][7]. See `LICENSE.txt` for
+further details.
+
+[1]: http://www.matthewflickinger.com/lab/whatsinagif/
+[2]: http://en.wikipedia.org/wiki/LZW
+[3]: http://en.wikipedia.org/wiki/Simple_API_for_XML
+[4]: http://en.wikipedia.org/wiki/Document_Object_Model
+[5]: https://github.com/martinkozak/struct-fx
+[6]: http://github.com/martinkozak/gif-info/issues
+[7]: http://www.martinkozak.net/

data/Rakefile

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "gif-info"
+  gem.homepage = "http://github.com/martinkozak/gif-info"
+  gem.license = "MIT"
+  gem.summary = 'Pure Ruby analyzer of the GIF image format. Performs complete analysis of internal GIF block structure and streams it as an objects stream with metainformations of each block. Also can interpret internal structure by providing the simple object-like interface to base image file informations. Works above seekable IO streams, so allows processing of the big files too. Doesn\'t perform LZW decompressing, returns raw data for both color tables and images.'
+  gem.email = "martinkozak@martinkozak.net"
+  gem.authors = ["Martin Kozák"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hash-utils #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/gif-dump

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)f
+
+if ARGV[0].nil? or (ARGV[0] == "--help")
+    puts "Usage: gif-dump [--help|--version|FILE]"
+    puts "\t--help     display this help and exit"
+    puts "\t--version  output version information and exit"
+
+    exit
+elsif ARGV[0] == "--version"
+    puts "gif-info 0.1.0"
+    puts "Copyright (C) 2011 Martin Kozák (martinkozak@martinkozak.net)"
+    puts "Dumps all structure informations from given GIF file."
+    exit
+end
+
+###
+
+require "gif-info"
+
+def __render(struct, level)
+    struct.members.each do |item|
+        if item == :packed
+            puts (" " * level) << "packed"
+            __render(struct[item].data, level + 1)
+        else
+            puts (" " * level) << item.to_s << " " << struct[item].to_s
+        end
+    end
+end
+
+# Analyzes
+File::open(ARGV[0], "rb") do |io|
+    GifInfo::parse(io) do |block|
+        if block.kind_of? GifInfo::FixedBlock
+            puts "\n" << block.class.name
+            __render(block.header.data, 1)
+        end
+    end
+end

data/bin/gif-info

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)f
+
+if ARGV[0].nil? or (ARGV[0] == "--help")
+    puts "Usage: gif-info [--help|--version|FILE]"
+    puts "\t--help     display this help and exit"
+    puts "\t--version  output version information and exit"
+
+    exit
+elsif ARGV[0] == "--version"
+    puts "gif-info 0.1.0"
+    puts "Copyright (C) 2011 Martin Kozák (martinkozak@martinkozak.net)"
+    puts "Writes out informations about given GIF file."
+    exit
+end
+
+###
+
+require "gif-info"
+
+# Analyzes
+f = GifInfo::analyze_file(ARGV[0])
+
+# Writes out
+puts "type " << f.type.to_s
+puts "version " << f.version.to_s
+puts "images_count " << f.images_count.to_s
+puts "width " << f.width.to_s
+puts "height " << f.height.to_s
+puts "color_resolution " << f.color_resolution.to_s
+
+if not f.pixel_aspect_ratio.nil?
+    puts "pixel_aspect_ratio " << f.pixel_aspect_ratio.to_s
+end
+
+puts "transparent " << f.transparent?.to_s
+puts "interlaced " << f.interlaced?.to_s
+puts "animated " << f.animated?.to_s
+puts "cyclic " << f.cyclic?.to_s
+
+if f.comments.length > 0
+    puts "comment " << f.comments.first
+end

data/gif-info.gemspec

@@ -0,0 +1,86 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gif-info}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Kozák"]
+  s.date = %q{2011-03-10}
+  s.email = %q{martinkozak@martinkozak.net}
+  s.executables = ["gif-dump", "gif-info"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "ajax-loader-0.gif",
+    "ajax-loader.gif",
+    "bin/gif-dump",
+    "bin/gif-info",
+    "gif-info.gemspec",
+    "lib/gif-info.rb",
+    "lib/gif-info/block.rb",
+    "lib/gif-info/blocks/application-extension.rb",
+    "lib/gif-info/blocks/comment-extension.rb",
+    "lib/gif-info/blocks/global-color-table.rb",
+    "lib/gif-info/blocks/graphics-control-extension.rb",
+    "lib/gif-info/blocks/header-block.rb",
+    "lib/gif-info/blocks/image-data.rb",
+    "lib/gif-info/blocks/image-descriptor.rb",
+    "lib/gif-info/blocks/local-color-table.rb",
+    "lib/gif-info/blocks/logical-screen-descriptor.rb",
+    "lib/gif-info/blocks/plain-text-extension.rb",
+    "lib/gif-info/blocks/trailer.rb",
+    "lib/gif-info/body.rb",
+    "lib/gif-info/color-table.rb",
+    "lib/gif-info/data-block.rb",
+    "lib/gif-info/dynamic-block.rb",
+    "lib/gif-info/fixed-block.rb",
+    "lib/gif-info/raw-block.rb",
+    "test"
+  ]
+  s.homepage = %q{http://github.com/martinkozak/gif-info}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Pure Ruby analyzer of the GIF image format. Performs complete analysis of internal GIF block structure and streams it as an objects stream with metainformations of each block. Also can interpret internal structure by providing the simple object-like interface to base image file informations. Works above seekable IO streams, so allows processing of the big files too. Doesn't perform LZW decompressing, returns raw data for both color tables and images.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<struct-fx>, [">= 0.1.1"])
+      s.add_runtime_dependency(%q<abstract>, [">= 1.0.0"])
+      s.add_runtime_dependency(%q<frozen-objects>, [">= 0.2.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<riot>, [">= 0.12.1"])
+    else
+      s.add_dependency(%q<struct-fx>, [">= 0.1.1"])
+      s.add_dependency(%q<abstract>, [">= 1.0.0"])
+      s.add_dependency(%q<frozen-objects>, [">= 0.2.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<riot>, [">= 0.12.1"])
+    end
+  else
+    s.add_dependency(%q<struct-fx>, [">= 0.1.1"])
+    s.add_dependency(%q<abstract>, [">= 1.0.0"])
+    s.add_dependency(%q<frozen-objects>, [">= 0.2.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<riot>, [">= 0.12.1"])
+  end
+end
+

data/lib/gif-info.rb

@@ -0,0 +1,407 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "stringio"
+require "struct-fx"
+
+require "gif-info/blocks/header-block"
+require "gif-info/blocks/logical-screen-descriptor"
+require "gif-info/blocks/global-color-table"
+require "gif-info/blocks/local-color-table"
+require "gif-info/blocks/plain-text-extension"
+require "gif-info/blocks/comment-extension"
+require "gif-info/blocks/application-extension"
+require "gif-info/blocks/graphics-control-extension"
+require "gif-info/blocks/image-descriptor"
+require "gif-info/blocks/image-data"
+require "gif-info/blocks/trailer"
+
+##
+# Primary GifInfo module.
+#
+
+class GifInfo
+
+    ############################################################
+    ## STATIC PART
+    ############################################################
+
+    ##
+    # Defines structure of the block head.
+    #
+    
+    BLOCK_HEAD = StructFx::new do
+        uint8 :block_introducer
+        uint8 :extension_label
+    end
+    
+    ##
+    # Parses the GIF file.
+    #
+    # @param [IO] io IO object where offset 0 is start of the GIF file
+    # @yield [Blocks::ApplicationExtension]
+    # @yield [Blocks::CommentExtension]
+    # @yield [Blocks::GlobalColorTable]
+    # @yield [Blocks::GraphicsControlExtension]
+    # @yield [Blocks::HeaderBlock]
+    # @yield [Blocks::ImageData]
+    # @yield [Blocks::ImageDescriptor]
+    # @yield [Blocks::LocalColorTable]
+    # @yield [Blocks::LogicalScreenDescriptor]
+    # @yield [Blocks::PlainTextExtension]
+    # @yield [Blocks::Trailer]
+    # @see http://www.matthewflickinger.com/lab/whatsinagif/
+    #
+    
+    def self.parse(io)
+        __parse(io) do |block|
+        
+            # Saves position of beginning of the next block set by
+            # inner parser
+            position = io.pos               
+            
+            # Yields block and allows application seek trough the file 
+            # according to its needs
+            yield block
+            
+            # Seeks to position at beginning of the next block
+            io.seek(position)
+            
+        end
+    end
+    
+    
+    private
+    
+    ##
+    # Just performs parsing of the GIF file.
+    #
+    
+    def self.__parse(io)
+        if io.kind_of? String
+            io = StringIO::new(io)
+        end
+        
+        # Header Block
+        yield Blocks::HeaderBlock::new(io)
+        
+        # Logical Screen Descriptor
+        yield lsd = Blocks::LogicalScreenDescriptor::new(io)
+
+        # Global Color Table
+        packed = lsd.header.data.packed.data
+        if packed.global_color_table
+            size = packed.global_color_table_size
+            yield Blocks::GlobalColorTable::new(io, size)
+        end
+
+        # Extensions
+        reader = self::BLOCK_HEAD
+        length = reader.length
+
+        loop do
+            reader << (io.read(length) << "\0")     # adds zero character for cases, trailer is last byte of the file
+            header = self::BLOCK_HEAD.data
+            io.seek(-length, IO::SEEK_CUR)
+
+            case header.block_introducer
+                when 0x21   # extension
+                    case header.extension_label
+                        when 0xF9   # graphics control
+                            yield Blocks::GraphicsControlExtension::new(io)
+                        when 0xFF   # application
+                            yield Blocks::ApplicationExtension::new(io)
+                        when 0xFE   # comment
+                            yield Blocks::CommentExtension::new(io)
+                        when 0x01   # plain text
+                            yield Blocks::PlainTextExtension::new(io)
+                        else
+                            raise Exception::new("Invalid format: 0x01, 0xF9, 0xFE or 0xFF expected, but 0x" << header.block_introducer.to_s(16).upcase << " found at position " << (io.pos + 1).to_s << ".")
+                    end
+                    
+                when 0x2C   # image descriptor
+                
+                    # Image Descriptor
+                    yield desc = Blocks::ImageDescriptor::new(io)
+                    
+                    # Local Color Table
+                    if desc.header.data.packed.data.local_color_table
+                        size = lsd.header.data.packed.data.local_color_table_size
+                        yield Blocks::LocalColorTable::new(io, size)
+                    end
+                    
+                    # Image Data
+                    yield Blocks::ImageData::new(io)
+
+                when 0x3B   # trailer
+                    yield Blocks::Trailer::new(io)
+                    break
+                    
+                else
+                    raise Exception::new("Invalid format: 0x21, 0x2C or 0x3B expected, but 0x" << header.block_introducer.to_s(16).upcase << " found at position " << io.pos.to_s << ".")
+            end
+        end
+    end
+    
+    
+    public
+    
+    ##
+    # Considers stream, performs analyzing and returns info object
+    # as result.
+    #
+    # @param [IO] io IO object with GIF data
+    # @return [GifInfo] info object
+    #
+    
+    def self.analyze_io(io)
+        self::new(io)
+    end
+
+    ##
+    # Analyzes string with GIF data and returns info object.
+    #
+    
+    def self.analyze_string(string)
+        self::analyze_io(StringIO::new(string))
+    end
+
+    ##
+    # Analyzes file and returns info object back.
+    # 
+    # @param [String] filename file path
+    # @return [GifInfo] info object
+    #
+    
+    def self.analyze_file(filename)
+        File::open(filename, "rb") do |io|
+            self.analyze_io(io)
+        end
+    end
+
+
+    ############################################################
+    ## INSTANCE PART
+    ############################################################
+    
+    ##
+    # Type of the file. If it isn't +:GIF+, it means, file isn't
+    # valid GIF gile.
+    #
+    # @return [Symbol] always +:GIF+
+    #
+    
+    attr_reader :type
+    @type
+    
+    ##
+    # Version of the GIF standard. Can be +:87a+ or +?89a+.
+    # @return [Symbol] GIF standard version
+    #
+    
+    attr_reader :version
+    @version
+    
+    ##
+    # Width of the image. (Width of the canvas.)
+    # @return [Integer] width
+    #
+    
+    attr_reader :width
+    @width
+    
+    ##
+    # Height of the image. (Height of the canvas.)
+    # @return [Integer] height
+    #
+    
+    attr_reader :height
+    @height
+    
+    ##
+    # Pixel aspect ratio. See standard what it is.
+    # @return [Integer] pixel aspect ration
+    #
+    
+    attr_reader :pixel_aspect_ratio
+    @pixel_aspect_ratio
+    
+    ##
+    # Color resolution in number of colors which can be encoded 
+    # according to global table. If local tables found, it's +nil+.
+    #
+    # @return [Integer] color count
+    #
+    
+    attr_reader :color_resolution
+    @color_resolution
+    
+    ##
+    # Comments inside the file. GIF file can theorethically contain
+    # unlimtited number of the comment blocks, so it returns array.
+    #
+    # @return [Array] array with comments
+    #
+    
+    attr_reader :comments
+    @comments
+    
+    ##
+    # Contains images count. More images in one file are characteristics
+    # for the animated GIF files.
+    #
+    # @return [Integer] images count
+    #
+    
+    attr_reader :images_count
+    @images_count
+    
+    ##
+    # Indicates animation is cyclic.
+    #
+    
+    @cyclic
+
+    ##
+    # Indicates, file is animated.
+    #
+    
+    @animated
+    
+    ##
+    # Indicates, at least one image in file has some color transparent.
+    #
+    
+    @transparent
+
+    ##
+    # Indicates, at least one image in file is rendered interlaced.
+    #
+    
+    @interlaced
+    
+    ##
+    # Constructor.
+    # @param [IO] io IO object with GIF data
+    #
+    
+    def initialize(io)
+        @comments = [ ]
+        @images_count = 0
+        @cyclic = false
+        @animated = false
+        @transparent = false
+        @interlaced = false
+        
+        self.consider! io
+    end
+    
+    ##
+    # Considers IO object, analyzes it and sets result ot the object.
+    # @param [IO] io IO object with GIF data
+    #
+    
+    def consider!(io)
+        self.class::parse(io) do |block|
+        
+            # Header Block
+            if block.kind_of? GifInfo::Blocks::HeaderBlock
+                header = block.header.data
+                @type = header.signature.to_sym         # type
+                @version = header.version.to_sym        # version
+
+            # Logical Screen Descriptor
+            elsif block.kind_of? GifInfo::Blocks::LogicalScreenDescriptor
+                header = block.header.data
+                packed = header.packed.data
+                
+                @width = header.canvas_width            # width
+                @height = header.canvas_height          # height
+                
+                value = header.pixel_aspect_ratio       # pixel aspect ratio
+                value = nil if value <= 0               #
+                @pixel_aspect_ratio = value             #
+                
+                if packed.global_color_table            # color resolution
+                    @color_resolution = 2 ** (packed.global_color_table_size + 1)
+                end
+                
+            # Comments
+            elsif block.kind_of? GifInfo::Blocks::CommentExtension
+                @comments << block.body.data            # comments
+                
+            # Image Descriptor
+            elsif block.kind_of? GifInfo::Blocks::ImageDescriptor
+                packed = block.header.data.packed.data 
+                
+                @images_count += 1                                 # images count
+                @animated = true if @images_count == 2             # animated
+                @interlaced |= packed.interlace                    # interlaced
+                
+                if packed.local_color_table and (not @color_resolution.nil?) and (packed.local_color_table_size != @color_resolution)
+                    @color_resolution = nil                         # resets color resolution if local color table found
+                end                                                 # and global and local aren't equivalent
+                
+            # Application Extension
+            elsif block.kind_of? GifInfo::Blocks::ApplicationExtension
+                header = block.header.data
+                if (header.application_identifier == "NETSCAPE") and (header.application_authentication_code == "2.0")
+                    @cyclic = true                                  # cyclic
+                end
+                
+            # Graphics Control Extension
+            elsif block.kind_of? GifInfo::Blocks::GraphicsControlExtension
+                packed = block.header.data.packed.data
+                @transparent |= packed.transparent_color            # transparent
+                
+            end
+            
+        end
+
+        ##
+        # Indicates animation is cyclic. In strange GIF files can be set
+        # although file isn't animated and contains single image only.
+        #
+        # @return [Boolean] +true+ if yes, +false+ in otherwise
+        # 
+        
+        def cyclic?
+            @cyclic
+        end
+         
+        ##
+        # Indicates file is animated. It can be set to +true+ although
+        # animation isn't run because it's set if file contains 
+        # more images.
+        #
+        # @return [Boolean] +true+ if yes, +false+ in otherwise
+        # 
+        
+        def animated?
+            @animated
+        end
+        
+        ##
+        # Indicates, at least one image in file has some color 
+        # transparent. It of sure doesn't mean, image is transparent.
+        # It only means, transparency is turned on.
+        #
+        # @return [Boolean] +true+ if yes, +false+ in otherwise
+        # 
+        
+        def transparent?
+            @transparent
+        end
+
+        ##
+        # Indicates, at least one image in file is rendered interlaced.
+        # @return [Boolean] +true+ if yes, +false+ in otherwise
+        # 
+        
+        def interlaced?
+            @interlaced
+        end
+        
+    end
+    
+end