iptc 0.0.2

data/LICENSE

@@ -0,0 +1,5 @@
+GPL V2, (c) 2006 Pierre Baillet, (c) 2010 Jens Kraemer
+
+Original code from http://raa.ruby-lang.org/project/jpeg-jfif-iptc/
+
+Gemified, reorganized and modified in 2010 by Jens Kraemer.

data/README.md

@@ -0,0 +1,11 @@
+Ruby IPTC metadata parser
+
+This library can be used to read the metadata of a jpeg file.
+ 
+It reads the IPTC informations embedded and allows to access this information
+Read IPTC::JPEG::Image for more information.
+
+The IPTC library parses the APP13 JPEG Tag and generates a hash of properties for a given file.
+
+Original code from http://raa.ruby-lang.org/project/jpeg-jfif-iptc/
+Gemified, reorganized and modified in 2010 by Jens Kraemer.

data/lib/iptc.rb

@@ -0,0 +1,3 @@
+require 'iptc/jpeg/image'
+require 'iptc/jpeg/markers'
+

data/lib/iptc/jpeg/image.rb

@@ -0,0 +1,100 @@
+require 'logger'
+
+require 'iptc/multiple_hash'
+require 'iptc/jpeg/marker_headers'
+
+module IPTC
+  module JPEG
+    class Image
+      attr_reader :values
+      # creates a JPEG image from a file and does a "quick" load (Only the metadata
+      # are loaded, not the whole file).
+      def initialize filename, quick=true
+        @logger = Logger.new(STDOUT)
+        @logger.datetime_format = "%H:%M:%S"
+        @logger.level = $DEBUG?(Logger::DEBUG):(Logger::INFO)
+      
+        @filename = filename
+        @position = 0
+        @content = File.open(@filename).binmode.read
+      
+      
+        if MARKERS[read(2)]!="SOI"
+          raise  NotJPEGFileException.new("Not a JPEG file: #{@filename}")
+        end
+      
+        @markers = Array.new()
+      
+        begin
+      
+          catch(:end_of_metadata) do
+            while true
+              @markers << read_marker
+            end
+          end
+        
+        rescue Exception=>e
+          @logger.info "Exception in file #{@filename}:\n"+e.to_s
+          raise e
+        end
+        # Markers all read
+        # move back
+        seek(-2)
+      
+        # in full mode, read the rest
+        if !quick
+          @data = read_rest
+        end
+      
+        @values = MultipleHash.new
+      
+        @markers.each do |marker|
+          # puts "processing marker: #{marker.inspect}"
+          marker.parse
+          # puts marker.valid?
+          @values.add(marker, marker.values)
+        end
+      end
+    
+      def read(count)
+        @position += count
+        return @content[@position-count...@position]
+      end
+      def seek(count)
+        @position += count
+      end
+    
+      def l message
+        @logger.debug message
+      end
+    
+      # write the image to the disk
+      def write filename
+        f = File.open(filename,"wb+")
+        f.print "\xFF\xD8"
+      
+        @markers.each do |marker|
+          f.print marker.to_binary
+        end
+        f.print @data.to_binary
+        f.close
+      
+      end
+    
+      def read_marker
+        type = read(2)
+        # finished reading all the metadata
+        throw :end_of_metadata if MARKERS[type]=='SOS'
+        size = read(2)
+        data = read(size.unpack('n')[0]-2)
+      
+        return Marker.NewMarker(MARKERS[type], type+size+data, @logger)
+      end
+      def read_rest
+        rest = @content[@position..-1]
+        return Marker.new("BIN",rest)
+      end
+    
+    end
+  end
+end

data/lib/iptc/jpeg/marker.rb

@@ -0,0 +1,97 @@
+require 'logger'
+
+module IPTC
+  module JPEG
+      # == Marker
+      # A Jpeg marker, generic class used by all others markers
+      class Marker
+          attr_reader :prefix
+          attr_reader :values
+        
+          @@missing = []
+        
+          # The NewMarker constructor method.
+          # Inspect the object space in order to find something usable later
+          def Marker.NewMarker(type,data, logger)
+            marker_class = "#{type}Marker"
+              if JPEG::Markers.constants.include?(marker_class.to_sym)
+                  return JPEG::Markers.const_get(marker_class).new(type, data)
+              else
+                if !@@missing.include?(type)
+                  logger.debug "Marker #{type+"Marker"} not found." if logger!=nil
+                  @@missing << type
+                end
+              end
+              return Marker.new(type,data)
+          end
+        
+          def l message
+            @logger.debug message
+          end
+
+          # binary serialization 
+          # transform the marker to its final form
+          def to_binary data=nil
+              if data!=nil
+                  return @type+[data.length+2].pack('n')+data
+              else
+                  return @original_content
+              end
+          end
+
+          def initialize(type,data)
+              @logger = Logger.new(STDOUT)
+              @logger.datetime_format = "%H:%M:%S"
+              @logger.level = $DEBUG?(Logger::DEBUG):(Logger::INFO)
+    
+              @original_content = data
+            
+              @content = StringIO.new(data)
+              @type = @content.read(2)
+              @size = @content.read(2).unpack('n')[0]-2
+            
+              if !valid?
+                  raise InvalidBlockException.new("In block #{self.class}: invalid marker\n#{@content.read(20)}")
+              end
+
+              @prefix = self.class.to_s
+            
+              @prefix = @prefix[@prefix.rindex("::")+2..-7]
+              if @prefix==""
+                  @prefix= 'Marker'
+              end
+
+              @values = Hash.new
+          end
+          def read count
+              return @content.read(count)
+          end
+          def valid?
+              return true
+          end
+
+
+          # parse the data
+          def parse
+              return []
+          end
+
+          # returns the available properties for the given tag
+          def properties
+              return []
+          end
+      end
+    
+      # This is not a JPEG file.
+      class NotJPEGFileException < Exception; end
+    
+      # The end of the metadata has occured too early
+      class EndOfMetaDataException < Exception; end
+
+      # The block is invalide
+      class InvalidBlockException < Exception; end
+  end
+
+
+
+end

data/lib/iptc/jpeg/marker_headers.rb

@@ -0,0 +1,67 @@
+module IPTC
+  module JPEG
+      MARKERS = {
+          "\xFF\xD8" => 'SOI',
+          "\xFF\xc0" => 'SOF0',
+          "\xFF\xc1" => 'SOF1',
+          "\xFF\xc2" => 'SOF2',
+          "\xFF\xc3" => 'SOF3',
+
+          "\xFF\xc5" => 'SOF5',
+          "\xFF\xc6" => 'SOF6',
+          "\xFF\xc7" => 'SOF7',
+
+          "\xFF\xc8" => 'JPG',
+          "\xFF\xc9" => 'SOF9',
+          "\xFF\xca" => 'SOF10',
+          "\xFF\xcb" => 'SOF11',
+
+          "\xFF\xcd" => 'SOF13',
+          "\xFF\xce" => 'SOF14',
+          "\xFF\xcf" => 'SOF15',
+
+          "\xFF\xc4" => 'DHT',
+
+          "\xFF\xcc" => 'DAC',
+
+          "\xFF\xd0" => 'RST0',
+          "\xFF\xd1" => 'RST1',
+          "\xFF\xd2" => 'RST2',
+          "\xFF\xd3" => 'RST3',
+          "\xFF\xd4" => 'RST4',
+          "\xFF\xd5" => 'RST5',
+          "\xFF\xd6" => 'RST6',
+          "\xFF\xd7" => 'RST7',
+
+          "\xFF\xd8" => 'SOI',
+          "\xFF\xd9" => 'EOI',
+          "\xFF\xda" => 'SOS',
+          "\xFF\xdb" => 'DQT',
+          "\xFF\xdc" => 'DNL',
+          "\xFF\xdd" => 'DRI',
+          "\xFF\xde" => 'DHP',
+          "\xFF\xdf" => 'EXP',
+
+          "\xFF\xe0" => 'APP0',
+          "\xFF\xe1" => 'APP1',
+          "\xFF\xe2" => 'APP2',
+          "\xFF\xe3" => 'APP3',
+          "\xFF\xe4" => 'APP4',
+          "\xFF\xe5" => 'APP5',
+          "\xFF\xe6" => 'APP6',
+          "\xFF\xe7" => 'APP7',
+          "\xFF\xe8" => 'APP8',
+          "\xFF\xe9" => 'APP9',
+          "\xFF\xea" => 'APP10',
+          "\xFF\xeb" => 'APP11',
+          "\xFF\xec" => 'APP12',
+          "\xFF\xed" => 'APP13',
+          "\xFF\xee" => 'APP14',
+          "\xFF\xef" => 'APP15',
+          "\xFF\xf0" => 'JPG0',
+          "\xFF\xfd" => 'JPG13',
+          "\xFF\xfe" => 'COM',
+          "\xFF\x01" => 'TEM'
+      }
+  end
+end

data/lib/iptc/jpeg/markers.rb

@@ -0,0 +1,190 @@
+require 'stringio'
+
+require 'iptc/marker'
+require 'iptc/marker_nomenclature'
+require 'iptc/jpeg/marker'
+
+module IPTC
+
+  module JPEG
+      # == Markers
+      # All the known JPEG markers
+      module Markers
+          # == SOIMarker
+          # The Start Of Image Marker
+      	class SOIMarker < Marker
+      	    def valid?
+      	        return read(5)=="JFIF\0"
+      	    end
+          end
+          # == APP1Marker
+          # The APP1 Marker, Exif container
+          class APP1Marker < Marker
+              def valid?
+                xap = 'http://ns.adobe.com/xap/1.0/'
+                header = read(xap.size)
+                return header == xap || header.start_with?("Exif\0\0")
+              end
+          end
+          # == COMMarker
+          # The COM Marker, contains comments
+          class COMMarker < Marker
+              attr_reader :content
+              def parse
+                  l "COM Marker Parsed"
+                  @content = read(@size)
+                  @dirty = false
+
+                  @values['COM/COM']=@content
+              end
+  #            def []=(key,value)
+  #                if @content != value
+  #                    @content = value
+  #                    @dirty = true
+  #                end
+  #            end
+              def [](item)
+                  return @content
+              end
+          end
+          # == The APP13Marker
+          # The APP13 marker, know as the IPTC Marker
+          # See also the IPTC::MarkerNomenclature.
+          class APP13Marker < Marker
+              def initialize(type, data)
+                  @header = "Photoshop 3.0\0008BIM"
+
+                  super(type, data)
+                  @prefix = "iptc"
+
+              end
+              def valid?
+                  return read(@header.length)==@header
+              end
+            
+              def parse
+                l "APP13 marker parsed"
+                @markers = Array.new	    
+              
+
+                @bim_type = read(2)
+                @bim_dummy = read(4)
+                size = read(2)
+
+                content = StringIO.new(read(size.unpack('n')[0]))
+
+                while !content.eof?
+                  
+                  header = content.read(2)
+
+                  # http://www.sno.phy.queensu.ca/~phil/exiftool/TagNames/IPTC.html
+                  case header
+                  when "\x1c\x01"
+                    # skip the envelope
+                    while !content.eof?
+                      if content.read(1) == "\x1c"
+                        content.pos = content.pos - 1
+                        break
+                      end
+                    end
+                  when "\x1c\x02"
+                
+                    type = content.read(1).unpack('c')[0]
+                    size = content.read(2)
+                    value = content.read(size.unpack('n')[0])
+
+                    l "Found marker #{type}"
+                    marker = IPTC::Marker.new(type, value)
+                    @values[@prefix+"/"+IPTC::MarkerNomenclature.markers(type.to_i).name] ||= []
+                    @values[@prefix+"/"+IPTC::MarkerNomenclature.markers(type.to_i).name] << value
+                    @markers << marker
+
+                  else
+                    # raise InvalidBlockException.new("Invalid BIM segment #{header.inspect} in marker\n#{@original_content.inspect}")
+                  end
+                end
+                return @values
+              end
+            
+              def [](item)
+                  return @values[item]
+              end
+              def to_binary
+                  marker = ""
+                  @markers.each do |value|
+                      marker += value.to_binary
+                  end
+                
+                  marker =  @header+@bim_type+@bim_dummy+[marker.length].pack('n')+marker
+
+                  # build the complete marker
+                  marker = super(marker)
+                
+                  return marker
+              end
+              def properties
+                  return IPTC::TAGS.values.sort
+              end
+              def set(property, value)
+                  numerical_tag = IPTC::TAGS.index(property)
+                      if numerical_tag!=nil
+                  else
+                      throw InvalidPropertyException.new("Invalid property #{property} for IPTC marker")
+                  end
+                  marker = IPTC::Marker.new(numerical_tag, value)
+                  @markers << marker
+              end
+          end
+          class InvalidPropertyException < Exception
+          end
+          # == The APP0Marker
+          # Contains some useful JFIF informations about the current
+          # image.
+          class APP0Marker < Marker
+              def initialize type, data 
+                  super type, data
+              end
+              def valid?
+                  if read(5)!="JFIF\0"
+                      return false
+                  end
+                  return true
+              end
+              def parse
+
+                  @values = {
+                      'APP1/revision'=>read(2).unpack('n')[0],
+                      'APP1/unit' => read(1),
+                      'APP1/xdensity' => read(2).unpack('n')[0],
+                      'APP1/ydensity' => read(2).unpack('n')[0],
+                      'APP1/xthumbnail' => read(1).unpack('c')[0],
+                      'APP1/ythumbnail' => read(1).unpack('c')[0]
+                  }
+              end
+              def [](item)
+                  return @values[item]
+              end
+          end
+  	end
+  end
+end
+
+if $0 == __FILE__
+    if ARGV[0]==nil
+      puts "No file given. Aborting."
+      exit
+    end
+    
+    require 'iptc/jpeg/image'
+    
+
+    # read the image
+    im = IPTC::JPEG::Image.new(ARGV[0])
+
+    puts "Done reading #{ARGV[0]}"
+
+    im.values.each do |item|
+        puts "#{item.key}\t#{item.value}"
+    end
+  
+end

data/lib/iptc/marker.rb

@@ -0,0 +1,18 @@
+module IPTC
+  # == Marker
+  # A simple IPTC Marker
+  class Marker
+      attr_accessor :value
+      def initialize(type, value)
+          @type = type
+          @value = value
+      end
+      def to_s
+          self.value
+      end
+      def to_binary
+          "\x1c\x02"+[@type, @value.length].pack('cn')+@value
+      end        
+  end
+end
+  

data/lib/iptc/marker_nomenclature.rb

@@ -0,0 +1,49 @@
+require 'singleton'
+require 'iptc/marker'
+
+module IPTC
+  class MarkerNomenclature
+    include Singleton
+    def MarkerNomenclature.markers(id)
+      return MarkerNomenclature.instance.markers(id)
+    end
+    
+    def markers(id)
+      if @markers.has_key?(id)
+        return @markers[id]
+      else
+        return @markers[-1]
+      end
+    end
+    
+    def populate
+      @markers = {}
+      begin
+        fullpath = nil
+        
+        [File.dirname(__FILE__), $:].flatten.each { |path|
+          break if File.exists?(fullpath = File.join(path, "iptc"))
+        }
+        content = File.open(fullpath).read
+      rescue Exception=>e
+        raise "Load failed for \"iptc\" file\nWith $:=#{$:.inspect}\n\n"+e
+      end
+      marker = Struct.new(:iid, :name, :description)
+      
+      m = marker.new
+      m.name = "Unknow marker"
+      m.iid = -1
+      @markers[-1] = m
+              
+      content.each_line do |line|
+          tags = line.split(/\t/)
+          m = marker.new
+          m[:name] = tags[0]
+          m[:description] = tags[1]
+          m[:iid] = tags[2].to_i
+          @markers[m.iid] = m
+      end
+    end
+  end
+  MarkerNomenclature.instance.populate
+end

data/lib/iptc/multiple_hash.rb

@@ -0,0 +1,54 @@
+module IPTC
+
+
+  # a MultipleHash associate a String key, a Marker Object and a String value
+  # this object 
+  class MultipleHash
+    def initialize()
+      @internal = Hash.new
+    end
+    def add marker, hash
+       hash.each do |key,value|
+        @internal[key] ||= []
+        @internal[key] << MultipleHashItem.new(marker,key,value)
+      end
+    end
+    def has_key?(key)
+      return @internal.has_key?(key)
+    end
+    # Returns one or more values for a given key
+    # if there is only one value, do not send an array back
+    # but send the value instead.
+    def [](key)
+      if has_key?(key)
+        if @internal[key].length == 1
+          return @internal[key][0]
+        else
+          return @internal[key]
+        end
+      end
+    end
+    def each
+      @internal.each do |key, values|
+        values.each do |value|
+          yield value
+        end
+      end
+    end
+  end
+
+  class MultipleHashItem
+    attr_reader :key
+    def initialize marker, key, value
+      @marker = marker
+      @key = key
+    end
+    def value=(value)
+      @marker[@key]=value
+    end
+    def value
+      return @marker[@key]
+    end
+  end
+
+end

data/lib/iptc/version.rb

@@ -0,0 +1,3 @@
+module IPTC
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: iptc
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Pierre Baillet
+- Jens Kraemer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-06 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Original code from http://raa.ruby-lang.org/project/jpeg-jfif-iptc/, gemified and updated by Jens Kraemer
+email: 
+- jk@jkraemer.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/iptc/jpeg/image.rb
+- lib/iptc/jpeg/marker.rb
+- lib/iptc/jpeg/marker_headers.rb
+- lib/iptc/jpeg/markers.rb
+- lib/iptc/marker.rb
+- lib/iptc/marker_nomenclature.rb
+- lib/iptc/multiple_hash.rb
+- lib/iptc/version.rb
+- lib/iptc.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/jkraemer/ruby-iptc
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -1405560905508476106
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: ruby-iptc
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Pure ruby IPTC metadata reader
+test_files: []
+