exifparser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7616a451f2f84dd5f7e220b0199f67ca9a193fd3
+  data.tar.gz: 9ee05e177cec4badc1c71b6bad7f0e4708688f10
+SHA512:
+  metadata.gz: d07432c7dde901cfc613824b40ce74c669d0f378f9c9dbf26848dc0264085d9e84c615d56f6c4279511bf73b6a1635b959711288ba2055f57338ca2e8d891366
+  data.tar.gz: d2c2e23601eb550b2d0adfffc9c35c5da88676d023a717ab3667a0bc3777f604125b02ddfb880b365bd195d969c063272d765d20392772127a0bb6ecdb1eccab

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in exifparser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 kp
+
+MIT License
+
+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,33 @@
+# Exifparser
+
+Exif tag parser written in pure Ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'exifparser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install exifparser
+
+## Usage
+
+see also lib/exifparser.rb
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Original Author
+Ryuichi Tamura <r-tam@fsinet.or.jp>
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/exifparser.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'exifparser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "exifparser"
+  spec.version       = ExifParser::VERSION
+  spec.authors       = ["kp"]
+  spec.email         = ["knomura.1394@gmail.com"]
+  spec.description   = %q{Exif tag parser written in pure Ruby}
+  spec.summary       = %q{Exif tag parser written in pure Ruby}
+  spec.homepage      = ""
+  spec.license       = "Ruby"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/exifparser.rb

@@ -0,0 +1,265 @@
+#
+#
+#=  exifparser.rb - Exif tag parser written in pure ruby
+#
+#Author:: Ryuchi Tamura (r-tam@fsinet.or.jp)
+#Copyright:: Copyright (C) 2002 Ryuichi Tamura.
+#
+# $Id: exifparser.rb,v 1.1.1.1 2002/12/16 07:59:00 tam Exp $
+#
+#== INTRODUCTION
+#
+#There are 2 classes you work with. ExifParser class is
+#the Exif tag parser that parses all tags defined EXIF-2.2 standard,
+#and many of extension tags uniquely defined by some digital equipment
+#manufacturers. Currently, part of tags defined by FujiFilm, and
+#Olympus is supported. After initialized with the path to image file
+#of EXIF format, ExifParser will provides which tags are available in
+#the image, and how you work with them.
+#
+#Tags availble from ExifParser is objects defined under Exif::Tag module,
+#with its name being the class name. For example if you get "Make" tag
+#from ExifParser, it is Exif::Tag::DateTime object. Inspecting it looks
+#following:
+#
+# #<Exif::Tag::TIFF::Make ID=0x010f, IFD="IFD0" Name="Make", Format="Ascii" Value="FUJIFILM">
+#
+#here, ID is Tag ID defined in EXIF-2.2 standard, IFD is the name of
+#Image File Directory, Name is String representation of tag ID, Format is
+#string that shows how the data is formatted, and Value is the value of
+#the tag. This is retrieved by Exif::Tag::Make#value.
+#
+#Another example. If you want to know whether flash was fired when the image
+#was generated, ExifParser returns Exif::Tag::Flash object:
+#
+# tag = exif['Flash']
+# p tag
+# => #<Exif::Tag::Exif::Flash ID=0x9209, IFD="Exif" Name="Flash", Format="Unsigned short" Value="1">
+# p tag.value
+# => 1
+#
+#It may happen that diffrent IFDs have the same tag name. In this case,
+#use Exif#tag(tagname, IFD)
+#
+#The value of the tag above, 1, is not clearly understood
+#(supposed to be 'true', though). Exif::Tag::Flash#to_s will provides
+#more human-readable form as String.
+#
+# tag.to_s #=> "Flash fired."
+#
+#many of these sentences are cited from Exif-2.2 standard.
+#
+#== USAGE
+# require 'exifparser'
+#
+# exif = ExifParser.new("fujifilm.jpg")
+#
+# 1. get a tag value by its name('Make') or its ID (0x010f)
+# exif['Make'] #=> 'FUJIFILM'
+# exif[0x010f] #=> 'FUJIFILM'
+#
+# if the specified tag is not found, nil is returned.
+#
+# 2. to see the image has the value of specified tag
+# exif.tag?('DateTime') #=> true
+# exif.tag?('CameraID') #=> false
+#
+# 3. get all the tags contained in the image.
+#
+# exif.tags
+#
+# or, if you want to know all the tags defined in specific IFD,
+#
+# exif.tags(:IFD0) # get all the tags defined in IFD0
+#
+# you can traverse each tag and work on it.
+#
+# exif.each do |tag|
+#   p tag.to_s
+# end
+#
+# # each tag in IFD0
+# exif.each(:IFD0) do |ifd0_tag|
+#  p ifd0_tag.to_s
+# end
+#
+# 4. extract thumbnail
+#
+# File.open("thumb.jpg") do |dest|
+#   exif.thumbnail dest
+# end
+#
+# dest object must respond to '<<'.
+#
+require 'exifparser/scan'
+
+module Exif
+
+  class Parser
+    #
+    # create a new object. fpath is String.
+    #
+    def initialize(fpath)
+      @fpath = fpath
+      @scanner = nil
+      File.open(fpath, "rb") do |f|
+        @scanner = Exif::Scanner.new(f)
+        @scanner.scan
+      end
+      @IFD0 = @scanner.result[:IFD0]
+      @IFD1 = @scanner.result[:IFD1]
+      @Exif = @scanner.result[:Exif]
+      @GPS  = @scanner.result[:GPS]
+      @Interoperability = @scanner.result[:Interoperability]
+      @MakerNote = @scanner.result[:MakerNote]
+      @thumbnail = @scanner.result[:Thumbnail]
+    end
+
+    def inspect
+      sprintf("#<%s filename=\"%s\" entries: IFD0(%d) IFD1(%d) Exif(%d) GPS(%d) Interoperability(%d) MakerNote(%d)>", self.class, @fpath, @IFD0.length, @IFD1.length, @Exif.length, @GPS.length, @Interoperability.length, @MakerNote.length)
+    end
+
+    #
+    # return true if specified tagid is defined or has some value.
+    #
+    def tag?(tagid)
+      search_tag(tagid) ? true : false
+    end
+
+    #
+    # search tag on the specific IFD
+    #
+    def tag(tagname, ifd=nil)
+      search_tag(tagname, ifd)
+    end
+
+    #
+    # search the specified tag values. return value is object of
+    # classes defined under Exif::Tag module.
+    #
+    def [](tagname)
+      self.tag(tagname)
+    end
+
+    #
+    # set the specified tag to the specified value.
+    # XXX NOT IMPLEMETED XXX
+    #
+    def []=(tag, value)
+      # not implemented
+    end
+
+    #
+    # extract the thumbnail image to dest. dest should respond to
+    # '<<' method.
+    #
+    def thumbnail(dest)
+      dest << @thumbnail
+    end
+
+    #
+    # return the size of the thumbnail image
+    #
+    def thumbnail_size
+      @thumbnail.size
+    end
+
+    #
+    # return all the tags in the image.
+    #
+    # if argument ifd is specified, every tags defined in the
+    # specified IFD are passed to block.
+    #
+    # return value is object of classes defined under Exif::Tag module.
+    #
+    # allowable arguments are:
+    # * :IFD0
+    # * :IFD1
+    # * :Exif
+    # * :GPS
+    # * :Interoperability
+    # * :MakerNote (if exist)
+    def tags(ifd=nil)
+      if ifd
+        @scanner.result[ifd]
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten
+      end
+    end
+
+    #
+    # execute given block with block argument being every tags defined
+    # in all the IFDs contained in the image.
+    #
+    # if argument ifd is specified, every tags defined in the
+    # specified IFD are passed to block.
+    #
+    # return value is object of classes defined under Exif::Tag module.
+    #
+    # allowable arguments are:
+    # * :IFD0
+    # * :IFD1
+    # * :Exif
+    # * :GPS
+    # * :Interoperability
+    # * :MakerNote
+    def each(ifd=nil)
+      if ifd
+        @scanner.result[ifd].each{ |tag| yield tag }
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten.each do |tag|
+          yield tag
+        end
+      end
+    end
+
+    private
+
+    def search_tag(tagID, ifd=nil)
+      if ifd
+        @scanner.result(ifd).find do |tag|
+          case tagID
+          when Fixnum
+            tag.tagID.hex == tagID
+          when String
+            tag.name == tagID
+          end
+        end
+      else
+        [
+          @IFD0,
+          @IFD1,
+          @Exif,
+          @GPS,
+          @Interoperability,
+          @MakerNote
+        ].flatten.find do |tag|
+          case tagID
+          when Fixnum
+            tag.tagID.hex == tagID
+          when String
+            tag.name == tagID
+          end
+        end
+      end
+    end
+
+  end # module Parser
+
+end # module Exif
+
+ExifParser = Exif::Parser

data/lib/exifparser/makernote/canon.rb

@@ -0,0 +1,502 @@
+#
+#   exifparser/makernote/nikon.rb -
+#
+#   Copyright (C) 2002 Ryuichi Tamura (r-tam@fsinet.or.jp)
+#
+#   $Revision: 1.1.1.1 $
+#   $Date: 2002/12/16 07:59:00 $
+#
+require 'exifparser/tag'
+require 'exifparser/utils'
+
+module Exif
+
+  module Tag
+
+    module MakerNote
+
+      #
+      # 0x0000 - Unknown
+      #
+
+      #
+      # 0x0001 - Tag0x0001
+      #
+      class Tag0x0001 < Base
+
+        def processData
+          @formatted = []
+          partition_data(@count) do |part|
+            @formatted.push _formatData(part)
+          end
+        end
+
+        def value
+          numTags = @formatted[0] / 2
+          ret = {}
+
+          return ret if numTags < 2
+          #
+          # offset 1 : Macro mode
+          #
+          ret["Macro mode"] =
+          case @formatted[1]
+          when 1
+            "Macro"
+          when 2
+            "Normal"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 3
+          #
+          # offset 2 : if nonzero, length of self-timer in 10ths of a second.
+          #
+          selftimer_length = @formatted[2]
+
+          return ret if numTags < 5
+          #
+          # offset 4 : Flash mode
+          #
+          ret["Flash mode"] =
+          case @formatted[4]
+          when 0
+            "flash not fired"
+          when 1
+            "auto"
+          when 2
+            "on"
+          when 3
+            "red-eye reduction"
+          when 4
+            "slow synchro"
+          when 5
+            "auto + redeye reduction"
+          when 6
+            "on + redeye reduction"
+          when 16
+            "external flash"
+          else
+            "unknown"
+          end
+
+          return ret if numTags < 6
+          #
+          # offset 5: Contiuous drive mode
+          #
+          ret["Continuous drive mode"] =
+          case @formatted[5]
+          when 0
+            if selftimer_length != 0
+              "Timer = #{selftimer_length/10.0}sec."
+            else
+              "Single"
+            end
+          when 1
+            "Continuous"
+          end
+
+          return ret if numTags < 8
+          #
+          # offset 7: Focus Mode
+          #
+          ret["Focus Mode"] =
+          case @formatted[7]
+          when 0
+            "One-Shot"
+          when 1
+            "AI Servo"
+          when 2
+            "AI Focus"
+          when 3
+            "MF"
+          when 4
+            "Single"
+          when 5
+            "Continuous"
+          when 6
+            "MF"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 11
+          #
+          # offset 10: Image size
+          #
+          ret["Image Size"] =
+          case @formatted[10]
+          when 0
+            "Large"
+          when 1
+            "Medium"
+          when
+            "Small"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 12
+          #
+          # offset 11: "Easy shooting" mode
+          #
+          ret["Easy shooting mode"] =
+          case @formatted[11]
+          when 0
+            "Full auto"
+          when 1
+            "Manual"
+          when 2
+            "Landscape"
+          when 3
+            "Fast Shutter"
+          when 4
+            "Slow Shutter"
+          when 5
+            "Night"
+          when 6
+            "B&W"
+          when 7
+            "Sepia"
+          when 8
+            "Portrait"
+          when 9
+            "Sports"
+          when 10
+            "Macro / Close-Up"
+          when 11
+            "Pan Focus"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 14
+          #
+          # offset 13: Contrast
+          #
+          ret["Contrast"] =
+          case @formatted[13]
+          when 0xffff
+            "Low"
+          when 0x0000
+            "Normal"
+          when 0x0001
+            "High"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 15
+          #
+          # offset 14: Saturation
+          #
+          ret["Saturation"] =
+          case @formatted[14]
+          when 0xffff
+            "Low"
+          when 0x0000
+            "Normal"
+          when 0x0001
+            "High"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 16
+          #
+          # offset 15: Contrast
+          #
+          ret["Sharpness"] =
+          case @formatted[15]
+          when 0xffff
+            "Low"
+          when 0x0000
+            "Normal"
+          when 0x0001
+            "High"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 17
+          #
+          # offset 16: ISO
+          #
+          ret["ISO"] =
+          case @formatted[16]
+          when 0
+            "ISOSpeedRatings"
+          when 15
+            "Auto"
+          when 16
+            50
+          when 17
+            100
+          when 18
+            200
+          when 19
+            400
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 18
+          #
+          # offset 17: Metering mode
+          #
+          ret['Metering mode'] =
+          case @formatted[17]
+          when 3
+            "Evaluative"
+          when 4
+            "Partial"
+          when 5
+            "Center-weighted"
+          else
+            "Unknown"
+          end
+          ret
+        end
+
+      end
+
+      #
+      # 0x0003 - Tag0x0003
+      #
+      class Tag0x0003 < Base
+      end
+
+      #
+      # 0x0004 - Tag0x0004
+      #
+      class Tag0x0004 < Base
+
+        def processData
+          @formatted = []
+          partition_data(@count) do |part|
+            @formatted.push _formatData(part)
+          end
+        end
+
+        def value
+          numTags = @formatted[0] / 2
+          ret = {}
+
+          return hash if numTags < 8
+          # offset 7 : white balance
+          ret['White balance'] =
+          case @formatted[7]
+          when 0
+            "Auto"
+          when 1
+            "Sunny"
+          when 2
+            "Cloudy"
+          when 3
+            "Tungsten"
+          when 4
+            "Florescent"
+          when 5
+            "Flash"
+          when 6
+            "Custom"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 10
+          # offset 9: Sequence number (if in a continuous burst)
+          ret['Sequence number'] = @formatted[9]
+
+          return ret if numTags < 15
+          # offset 14: Auto Focus point used
+          ret['Auto Focus point used'] = @formatted[14]
+
+          return ret if numTags < 16
+          ret['Flash bias'] =
+          case @formatted[15]
+          when 0xffc0
+            "-2 EV"
+          when 0xffcc
+            "-1.67 EV"
+          when 0xffd0
+            "-1.50 EV"
+          when 0xffd4
+            "-1.33 EV"
+          when 0xffe0
+            "-1 EV"
+          when 0xffec
+            "-0.67 EV"
+          when 0xfff0
+            "-0.50 EV"
+          when 0xfff4
+            "-0.33 EV"
+          when 0x0000
+            "0 EV"
+          when 0x000c
+            "0.33 EV"
+          when 0x0010
+            "0.50 EV"
+          when 0x0014
+            "0.67 EV"
+          when 0x0020
+            "1 EV"
+          when 0x002c
+            "1.33 EV"
+          when 0x0030
+            "1.50 EV"
+          when 0x0034
+            "1.67 EV"
+          when 0x0040
+            "2 EV"
+          else
+            "Unknown"
+          end
+
+          return ret if numTags < 20
+          ret['Subject Distance'] = @formatted[19]
+
+          ret
+        end
+
+      end
+
+      #
+      # 0x0006 - ImageType
+      #
+      class ImageType < Base
+      end
+
+      #
+      # 0x0007 - FirmwareVersion
+      #
+      class FirmwareVersion < Base
+      end
+
+      #
+      # 0x0008 - ImageNumber
+      #
+      class ImageNumber < Base
+      end
+
+      #
+      # 0x0009 - OwnerName
+      #
+      class OwnerName < Base
+      end
+
+      #
+      # 0x000a - Unknown
+      #
+
+      #
+      # 0x000c - CameraSerialNumber
+      #
+      class CameraSerialNumber < Base
+
+        def to_s
+          hi = @formatted / 0x10000
+          low = @formatted % 0x10000
+          "%04X%05d"%[hi, low]
+        end
+
+      end
+
+      #
+      # 0x000d - Unknown
+      #
+
+      #
+      # 0x000f - CustomFunctions
+      #
+      class CustomFunctions < Base
+
+        def processData
+          @formatted = []
+          partition_data(@count) do |part|
+            @formatted.push _formatData(part)
+          end
+        end
+
+      end
+
+    end
+
+    CanonIFDTable = {
+      0x0000 => Unknown,
+      0x0001 => MakerNote::Tag0x0001,
+      0x0003 => MakerNote::Tag0x0003,
+      0x0004 => MakerNote::Tag0x0004,
+      0x0006 => MakerNote::ImageType,
+      0x0007 => MakerNote::FirmwareVersion,
+      0x0008 => MakerNote::ImageNumber,
+      0x0009 => MakerNote::OwnerName,
+      0x000a => Unknown,
+      0x000c => MakerNote::CameraSerialNumber,
+      0x000d => Unknown,
+      0x000f => MakerNote::CustomFunctions
+    }
+
+  end
+
+  class Canon
+
+    def initialize(fin, tiff_origin, dataPos, byteOrder_module)
+      @fin = fin
+      @tiffHeader0 = tiff_origin
+      @dataPos = dataPos
+      @byteOrder_module = byteOrder_module
+      self.extend @byteOrder_module
+    end
+
+    def scan_IFD
+      #
+      # Canon MakerNote starts from 0
+      #
+      @fin.pos = @dataPos + 0
+      #
+      # get the number of tags
+      #
+      numDirs = decode_ushort(fin_read_n(2))
+      #
+      # now scan them
+      #
+      1.upto(numDirs) {
+        curpos_tag = @fin.pos
+        tag = parseTagID(fin_read_n(2))
+        tagclass = Tag.find(tag.hex, Tag::CanonIFDTable)
+        unit, formatter = Tag::Format::Unit[decode_ushort(fin_read_n(2))]
+        count = decode_ulong(fin_read_n(4))
+        tagdata = fin_read_n(4)
+        obj = tagclass.new(tag, "MakerNote", count)
+        obj.extend formatter, @byteOrder_module
+        obj.pos = curpos_tag
+        if unit * count > 4
+          curpos = @fin.pos
+          begin
+            @fin.pos = @tiffHeader0 + decode_ulong(tagdata)
+            obj.dataPos = @fin.pos
+            obj.data = fin_read_n(unit*count)
+          ensure
+            @fin.pos = curpos
+          end
+        else
+          obj.dataPos = @fin.pos - 4
+          obj.data = tagdata
+        end
+        obj.processData
+        yield obj
+      }
+    end
+
+    private
+
+    def fin_read_n(n)
+      @fin.read(n)
+    end
+
+  end
+
+
+end