depix 1.0.0

data/DPX_HEADER_STRUCTURE.txt

@@ -0,0 +1,100 @@
+= DPX header structure description
+
+DPX metadata gets returned as a hash containing other nested hashes. You can address hash keys by symbol, string
+and method name
+
+  meta.file.magic # same as meta[:file][:magic]
+
+== Metadata structure
+
+* <tt>file</tt> hash of
+  * <tt>magic</tt> String
+  * <tt>image_offset</tt> Integer
+  * <tt>version</tt> String
+  * <tt>file_size</tt> Integer
+  * <tt>ditto_key</tt> Integer
+  * <tt>generic_size</tt> Integer
+  * <tt>industry_size</tt> Integer
+  * <tt>user_size</tt> Integer
+  * <tt>filename</tt> String
+  * <tt>timestamp</tt> String
+  * <tt>creator</tt> String
+  * <tt>project</tt> String
+  * <tt>copyright</tt> String
+  * <tt>encrypt_key</tt> Integer
+  * <tt>reserve</tt> String
+* <tt>image</tt> hash of
+  * <tt>orientation</tt> Integer
+  * <tt>number_elements</tt> Integer
+  * <tt>pixels_per_line</tt> Integer
+  * <tt>lines_per_element</tt> Integer
+  * <tt>image_elements</tt>  (array , 8 members):
+    * <tt>data_sign</tt> Integer
+    * <tt>low_data</tt> Integer
+    * <tt>low_quantity</tt> Float
+    * <tt>high_data</tt> Integer
+    * <tt>high_quantity</tt> Float
+    * <tt>descriptor</tt> String
+    * <tt>transfer</tt> String
+    * <tt>colorimetric</tt> String
+    * <tt>bit_size</tt> String
+    * <tt>packing</tt> Integer
+    * <tt>encoding</tt> Integer
+    * <tt>data_offset</tt> Integer
+    * <tt>end_of_line_padding</tt> Integer
+    * <tt>end_of_image_padding</tt> Integer
+    * <tt>description</tt> String
+  * <tt>reserve</tt> String
+* <tt>orientation</tt> hash of
+  * <tt>x_offset</tt> Integer
+  * <tt>y_offset</tt> Integer
+  * <tt>x_center</tt> Float
+  * <tt>y_center</tt> Float
+  * <tt>x_size</tt> Integer
+  * <tt>y_size</tt> Integer
+  * <tt>filename</tt> String
+  * <tt>timestamp</tt> String
+  * <tt>device</tt> String
+  * <tt>serial</tt> String
+  * <tt>border</tt>  (array , 4 members):
+  * <tt></tt> Integer
+  * <tt>aspect_ratio</tt>  (array , 2 members):
+  * <tt></tt> Integer
+  * <tt>reserve</tt> String
+* <tt>film</tt> hash of
+  * <tt>id</tt> String
+  * <tt>type</tt> String
+  * <tt>offset</tt> String
+  * <tt>prefix</tt> String
+  * <tt>count</tt> String
+  * <tt>format</tt> String
+  * <tt>frame_position</tt> Integer
+  * <tt>sequence_extent</tt> Integer
+  * <tt>held_count</tt> Integer
+  * <tt>frame_rate</tt> Float
+  * <tt>shutter_angle</tt> Float
+  * <tt>frame_id</tt> String
+  * <tt>slate</tt> String
+  * <tt>reserve</tt> String
+* <tt>television</tt> hash of
+  * <tt>time_code</tt> Integer
+  * <tt>user_bits</tt> Integer
+  * <tt>interlace</tt> String
+  * <tt>field_number</tt> String
+  * <tt>video_signal</tt> String
+  * <tt>padding</tt> String
+  * <tt>horizontal_sample_rate</tt> Float
+  * <tt>vertical_sample_rate</tt> Float
+  * <tt>frame_rate</tt> Float
+  * <tt>time_offset</tt> Float
+  * <tt>gamma</tt> Float
+  * <tt>black_level</tt> Float
+  * <tt>black_gain</tt> Float
+  * <tt>break_point</tt> Float
+  * <tt>white_level</tt> Float
+  * <tt>integration_times</tt> Float
+  * <tt>reserve</tt> String
+* <tt>user</tt> hash of
+  * <tt>id</tt> String
+  * <tt>user_data</tt> Integer
+

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2008-12-18
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,14 @@
+History.txt
+Manifest.txt
+README.txt
+DPX_HEADER_STRUCTURE.txt
+Rakefile
+bin/depix-describe
+lib/depix.rb
+lib/depix/struct_explainer.rb
+lib/depix/structs.rb
+test/test_depix.rb
+test/samples/E012_P001_L000002_lin.0001.dpx
+test/samples/E012_P001_L000002_lin.0002.dpx
+test/samples/E012_P001_L000002_log.0001.dpx
+test/samples/E012_P001_L000002_log.0002.dpx

data/README.txt

@@ -0,0 +1,57 @@
+= depix
+
+* http://rubyforge.org/julik/depix
+
+== DESCRIPTION:
+
+Read DPX file metadata
+
+== SYNOPSIS:
+
+  meta = Depix::Reader.new.from_file(dpx_file_path)
+  puts meta.television.time_code #=> 10:00:00:02
+  
+The data returned is described in the DPX_HEADER_STRUCTURE[link:files/DPX_HEADER_STRUCTURE_txt.html]. The structs
+used for actual parsing are in the Depix::Structs module (but in a much less readable form, obviously)
+
+The gem also contains an executable called depix-desribe which can be used from the command line
+  
+  $book depix-describe 001_PTAPE_001.001.dpx
+
+== NOTES:
+
+The reader tries to be efficient - fast Ruby unpacking is used, some shortcuts are taken. Also don't worry - we do not need to read
+the whole DPX file (which usually is around 8mb per frame) to know the details
+
+== REQUIREMENTS:
+
+* timecode gem (sudo gem install timecode)
+
+== INSTALL:
+
+* sudo gem install depix
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Julik Tarkhanov
+
+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/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'hoe'
+require './lib/depix.rb'
+
+Hoe.new('depix', Depix::VERSION) do |p|
+  p.developer('Julik Tarkhanov', 'me@julik.nl')
+  p.rubyforge_name = 'wiretap'
+  p.extra_deps.reject! {|e| e[0] == 'hoe' }
+end
+
+task :describe_structs do
+  require File.dirname(__FILE__) + '/lib/depix/struct_explainer'
+  File.open('DPX_HEADER_STRUCTURE.txt', 'w') {|f| f << RdocExplainer.new.get_rdoc_for(Depix::Structs::DPX_INFO) }
+end

data/bin/depix-describe

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/depix'
+ARGV.flatten.each do | file |
+  data = Depix::Reader.describe_file(file)
+  puts "Describing DPX #{file}. Empty elements are omitted."
+  puts data
+end

data/lib/depix.rb

@@ -0,0 +1,123 @@
+require 'stringio'
+require 'rubygems'
+require 'timecode'
+
+require File.dirname(__FILE__) + '/depix/structs'
+
+module Depix
+  VERSION = '1.0.0'
+  BLANK_4, BLANK_2 = 0xFFFFFFFF, 0xFFFF
+  
+  # Methodic hash - stolen from Camping
+  class H < Hash
+    # Gets or sets keys in the hash.
+    #
+    #   @cookies.my_favorite = :macadamian
+    #   @cookies.my_favorite
+    #   => :macadamian
+    #
+    def method_missing(m,*a)
+        m.to_s=~/=$/?self[$`]=a[0]:a==[]? (self.key?(m.to_sym) ? self[m.to_sym] : super ) : super
+    end
+    undef id, type
+  end
+  
+  # Reads the metadata
+  class Reader
+    
+    class << self
+      # Read the header from file (no worries, only the needed number of bytes will be read into memory). Returns a H with the metadata.
+      def from_file(path)
+        new.from_file(path)
+      end
+
+      # Read the metadata from an in-memory string. Returns a H with the metadata.
+      def from_string(str)
+        new.from_string(str)
+      end
+      
+      def describe_string(str)
+        reader = new
+        result = reader.deep_parse(str, Structs::DPX_INFO)
+        reader.inform(result)
+      end
+      
+      def describe_file(path)
+        header = File.open(path, 'r') { |f| f.read(Structs::TEMPLATE_LENGTH) }
+        describe_string(header)
+      end
+    end
+    
+    #:stopdoc:
+    def from_file(path)
+      header = File.open(path, 'r') { |f| f.read(Structs::TEMPLATE_LENGTH) }
+      from_string(header)
+    end
+    
+    def from_string(str) #:nodoc:
+      wrap(deep_parse(str, Structs::DPX_INFO))
+    end
+    
+    def deep_parse(data, structure)
+      magic = data[0..3]
+      template = (magic == "SDPX") ? Structs::TEMPLATE_BE : Structs::TEMPLATE_LE
+      
+      result = data.unpack(template).map do |e| 
+        case e
+          when String
+            clean = unpad(e)
+            clean.empty? ? nil : clean
+          when Integer
+            (e == BLANK_2 || e == BLANK_4) ? nil : e
+          when Float
+            e.nan? ? nil : e
+        end
+      end
+      result
+    end
+    
+    def inform(result)
+      Structs::TEMPLATE_KEYS.zip(result).map{|k, v| "#{k}:#{v}" unless v.nil? }.compact.join("\n")
+    end
+    
+    def wrap(result)
+      self.class.nestify(Structs::TEMPLATE_KEYS, result)
+    end
+    
+    def self.nestify(keys, values)
+      auto_hash = H.new do |h,k| 
+        h[k] = H.new(&h.default_proc)
+      end
+      
+      keys.each_with_index do |path, idx |
+        value = values[idx]
+        
+        sub, elems = auto_hash, path.split('.')
+        while elems.any?
+          dir = elems.shift
+          dir = dir.to_i if dir =~ /^(\d+)$/
+          elems.any? ? (sub = sub[dir]) : (sub[dir] = value)
+        end
+      end
+      
+      auto_hash
+    end
+    
+    def unpad(string) # :nodoc:
+      string.gsub(0xFF.chr, '').gsub(0xFF.chr, '')
+    end
+    
+    TIME_FIELDS = 7 # :nodoc:
+
+    def uint_to_tc(timestamp)  # :nodoc:
+      shift = 4 * TIME_FIELDS;
+      tc_elements = (0..TIME_FIELDS).map do 
+        part = ((timestamp >> shift) & 0x0F)
+        shift -= 4
+        part
+      end.join.scan(/(\d{2})/).flatten.map{|e| e.to_i}
+      
+      Timecode.at(*tc_elements)
+    end
+  end
+end

data/lib/depix/struct_explainer.rb

@@ -0,0 +1,62 @@
+# Generates an RDoc description of the DPX structs from the structs.rb file
+class Formatter #:nodoc:
+  attr_accessor :io, :attr_template, :struct_template
+  
+  def initialize
+    @io = STDOUT
+    @attr_template = "%s%s (%s)"
+    @struct_template = "%s%s (which is a hash with the following elements):"
+    @array_template = "%s%s (array , %d members):"
+    @padding =  '  '
+  end
+  
+  def explain_struct(struct, padding = '') #:nodoc:
+    struct.each do | e |
+      key, cast, len = e
+      if cast.is_a?(Depix::Structs::Struct)
+        @io.puts( @struct_template % [padding, key, len])
+        explain_struct(cast, padding + @padding)
+      elsif cast.is_a?(Array) # Repeats
+        @io.puts( @array_template % [padding, key, cast.size])
+        inner_struct = cast[0]
+        ikey, icast, ilen = inner_struct
+        if icast.is_a?(Depix::Structs::Struct)
+          explain_struct(icast, padding + @padding)
+        else
+          @io.puts( @attr_template % [padding, '', icast, ilen])
+        end
+      else
+        @io.puts( @attr_template % [padding, key, cast, len])
+      end
+    end
+  end
+end
+
+class RdocExplainer < Formatter #:nodoc:
+  TPL = <<eof
+= DPX header structure description
+
+DPX metadata gets returned as a hash containing other nested hashes. You can address hash keys by symbol, string
+and method name
+
+  meta.file.magic # same as meta[:file][:magic]
+
+== Metadata structure
+
+%s
+eof
+
+  def initialize
+    super
+    @attr_template = "%s* <tt>%s</tt> %s"
+    @struct_template = "%s* <tt>%s</tt> hash of"
+    @array_template  = "%s* <tt>%s</tt>  (array , %d members):"
+    
+  end
+  
+  def get_rdoc_for(struct)
+    @io = StringIO.new
+    explain_struct(Depix::Structs::DPX_INFO)
+    TPL % @io.string
+  end
+end

data/lib/depix/structs.rb

@@ -0,0 +1,259 @@
+module Depix
+  # Basically a copy of http://trac.imagemagick.org/browser/ImageMagick/trunk/coders/dpx.c
+  #
+  # Which is a reformulation of http://www.cineon.com/ff_draft.php
+  #
+  # Which is a preamble to some SMPTE crap that you have to buy for 14 bucks. Or download from http://www.cinesite.com/static/scanning/techdocs/dpx_spec.pdf
+  #
+  # It's very fragile - in the world of C, everything is fixed length. If Tolstoy wanted to write
+  # "War and Peace" in C he would need to know the number of letters ahead. It has good and bad
+  # qualities - the good ones being computers go faster like that. The rest are bad parts.
+  module Structs
+  
+  COLORIMETRIC = {
+      :UserDefined => 0,
+      :PrintingDensity => 1,
+      :Linear => 2,
+      :Logarithmic => 3,
+      :UnspecifiedVideo => 4,
+      :SMTPE_274M => 5,
+      :ITU_R709 => 6,
+      :ITU_R601_625L => 7,
+      :ITU_R601_525L => 8,
+      :NTSCCompositeVideo => 9,
+      :PALCompositeVideo => 10,
+      :ZDepthLinear => 11,
+      :DepthHomogeneous => 12
+  }
+  
+  COMPONENT_TYPE = {
+    :Undefined => 0,
+    :Red => 1,
+    :Green => 2,
+    :Blue => 3,
+    :Alpha => 4,
+    :Luma => 6,
+    :ColorDifferenceCbCr => 7,
+    :Depth => 8,
+    :CompositeVideo => 9,
+    :RGB => 50,
+    :RGBA => 51,
+    :ABGR => 52,
+    :CbYCrY422 => 100,
+    :CbYACrYA4224 => 101,
+    :CbYCr444 => 102,
+    :CbYCrA4444 => 103,
+    :UserDef2Element => 150,
+    :UserDef3Element => 151,
+    :UserDef4Element => 152,
+    :UserDef5Element => 153,
+    :UserDef6Element => 154,
+    :UserDef7Element => 155,
+    :UserDef8Element => 156,
+  }
+  
+  #:stopdoc: 
+  
+  # To avoid fucking up with sizes afterwards
+  UINT, FLOAT, USHORT, UCHAR = 4, 4, 2, 1
+  
+  def self.struct_size(struct_const) #:nodoc:
+    struct_const.inject(0){| s, e | s + e[2]}
+  end
+  
+  # Used to distinguish structs from repeated values
+  class Struct < Array; end
+  
+  
+  FILE_INFO = Struct[
+    [:magic, String, 4],
+    [:image_offset, Integer, UINT],
+    
+    [:version, String, 8],
+    
+    [:file_size, Integer, UINT],
+    [:ditto_key, Integer, UINT],
+    [:generic_size, Integer, UINT],
+    [:industry_size, Integer, UINT],
+    [:user_size, Integer, UINT],
+    
+    [:filename, String, 100],
+    [:timestamp, String, 24],
+    [:creator, String, 100],
+    [:project, String, 200],
+    [:copyright, String, 200],
+    
+    [:encrypt_key, Integer, UINT],
+    [:reserve, String, 104],
+  ]
+
+  FILM_INFO = Struct[
+      [:id, String, 2],
+      [:type, String, 2],
+      [:offset, String, 2],
+      [:prefix, String, 6],
+      [:count, String, 4],
+      [:format, String, 32],
+      
+      [:frame_position, Integer, UINT],
+      [:sequence_extent, Integer, UINT],
+      [:held_count, Integer, UINT],
+    
+      [:frame_rate, Float, FLOAT],
+      [:shutter_angle, Float, FLOAT],
+      
+      [:frame_id, String, 32],
+      [:slate, String, 100],
+      [:reserve, String, 56],
+  ]
+  
+
+  IMAGE_ELEMENT = Struct[
+     [:data_sign, Integer, UINT],
+     [:low_data, Integer, UINT],
+     [:low_quantity, Float, FLOAT],
+     [:high_data, Integer, UINT],
+     [:high_quantity, Float, FLOAT],
+     
+     # TODO: Autoreplace with enum values. Note: with these we will likely be addressing the enums
+     [:descriptor, String, UCHAR],
+     [:transfer, String, UCHAR],
+     [:colorimetric, String, UCHAR],
+     [:bit_size, String, UCHAR],
+     
+     [:packing, Integer, USHORT],
+     [:encoding, Integer, USHORT],
+     [:data_offset, Integer, UINT],
+     [:end_of_line_padding, Integer, UINT],
+     [:end_of_image_padding, Integer, UINT],
+     [:description, String, 32],
+  ]
+  
+  IMAGE_ELEMENTS = (0..7).map{|e| [e, IMAGE_ELEMENT, struct_size(IMAGE_ELEMENT)] }
+  
+  IMAGE_INFO = Struct[
+    [:orientation, Integer, USHORT],
+    [:number_elements, Integer, USHORT],
+    
+    [:pixels_per_line, Integer, UINT],
+    [:lines_per_element, Integer, UINT],
+    
+    [:image_elements, IMAGE_ELEMENTS, struct_size(IMAGE_ELEMENTS) ],
+
+    [:reserve, String, 52],
+  ]
+  
+  BORDER = (0..3).map{|s| [s, Integer, USHORT] }
+
+  ASPECT_RATIO = [
+    [0, Integer, UINT],
+    [1, Integer, UINT],
+  ]
+  
+  ORIENTATION_INFO = Struct[
+  
+    [:x_offset, Integer, UINT],
+    [:y_offset, Integer, UINT],
+    
+    [:x_center, Float, FLOAT],
+    [:y_center, Float, FLOAT],
+    
+    [:x_size, Integer, UINT],
+    [:y_size, Integer, UINT],
+    
+    [:filename, String, 100],
+    [:timestamp, String, 24],
+    [:device, String, 32],
+    [:serial, String, 32],
+    
+    [:border, BORDER, struct_size(BORDER)],
+    [:aspect_ratio, ASPECT_RATIO, struct_size(ASPECT_RATIO)],
+    
+    [:reserve, String, 28],
+  ]
+  
+  TELEVISION_INFO = Struct[
+    [:time_code, Integer, UINT],
+    [:user_bits, Integer, UINT],
+    
+    [:interlace, String, UCHAR],
+    [:field_number, String, UCHAR],
+    [:video_signal, String, UCHAR],
+    [:padding, String, UCHAR],
+    
+    [:horizontal_sample_rate, Float, FLOAT],
+    [:vertical_sample_rate, Float, FLOAT],
+    [:frame_rate, Float, FLOAT],
+    [:time_offset, Float, FLOAT],
+    [:gamma, Float, FLOAT],
+    [:black_level, Float, FLOAT],
+    [:black_gain, Float, FLOAT],
+    [:break_point, Float, FLOAT],
+    [:white_level, Float, FLOAT],
+    [:integration_times, Float, FLOAT],
+    [:reserve, String, 76],
+  ]
+  
+  USER_INFO = Struct[
+    [:id, String, 32],
+    [:user_data, Integer, UINT],
+  ]
+  
+  DPX_INFO = Struct[
+    [:file, FILE_INFO, struct_size(FILE_INFO)],
+    [:image, IMAGE_INFO, struct_size(IMAGE_INFO)],
+    [:orientation, ORIENTATION_INFO, struct_size(ORIENTATION_INFO)],
+    [:film, FILM_INFO, struct_size(FILM_INFO)],
+    [:television, TELEVISION_INFO, struct_size(TELEVISION_INFO)],
+    [:user, USER_INFO, struct_size(USER_INFO)],
+  ]
+  
+  # Converts the nexted structs to one template that can be fed to Ruby pack/unpack. This yields
+  # some impressive performance improvements (about 1.4 times faster) over reading fields bytewise
+  def self.struct_to_template(struct, big_endian)
+    keys, template = [], ''
+    struct.each do | elem |
+      key, cast, size = elem
+      pattern = case true
+        when cast.is_a?(Struct) # Nested structs
+          inner_keys, inner_template = struct_to_template(cast, big_endian)
+          # Use a dot as a divider. We will detect it later on and merge into nested hashes
+          keys += inner_keys.map{|k| [key, k].join('.') }
+          inner_template
+        when cast.is_a?(Array) # Repeat values
+          inner_keys, inner_template = struct_to_template(cast, big_endian)
+          # Use a dot as a divider. We will detect it later on and merge into nested hashes
+          keys += inner_keys.map{|k| [key, k].join('.') }
+          inner_template
+        when cast == Integer || cast == Timecode
+          keys << key.to_s
+          integer_template(size, big_endian)
+        when cast == String
+          keys << key.to_s
+          "A#{size}"
+        when cast == Float
+          keys << key.to_s
+          big_endian ? "g" : "f"
+      end
+      
+      template << pattern
+    end
+    [keys, template]
+  end
+  
+  def self.integer_template(size, big_endian) #:nodoc:
+    if size == 2
+      big_endian ? "n" : "v"
+    elsif size == 4
+      big_endian ? "N" : "V"
+    end
+  end
+  
+  # Shortcuts used to speed up parsing
+  TEMPLATE_KEYS, TEMPLATE_BE = struct_to_template(DPX_INFO, true)
+  TEMPLATE_LE = struct_to_template(DPX_INFO, false)
+  TEMPLATE_LENGTH = struct_size(DPX_INFO)
+  
+  #:startdoc:
+  end
+end

data/test/test_depix.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../lib/depix'
+require 'test/unit'
+
+class StructsTest < Test::Unit::TestCase
+  def test_struct_size
+    int = [[:some, Integer, 13]]
+    assert_equal 13, Depix::Structs.struct_size(int)
+
+    two_ints = [[:some, String, 13], [:some, String, 13]]
+    assert_equal 26, Depix::Structs.struct_size(two_ints)
+    
+    nested_struct = [[:some, String, 10], [:some, two_ints, Depix::Structs.struct_size(two_ints)]]
+    assert_equal 36, Depix::Structs.struct_size(nested_struct)
+  end
+  
+  def test_integer_template
+    assert_equal "N", Depix::Structs.integer_template(4, true)
+    assert_equal "V", Depix::Structs.integer_template(4, false)
+
+    assert_equal "n", Depix::Structs.integer_template(2, true)
+    assert_equal "v", Depix::Structs.integer_template(2, false)
+  end
+  
+  def test_struct_to_template
+    one_int = [[:some, Integer, 4]]
+    assert_equal [["some"], "N"], Depix::Structs.struct_to_template(one_int, true)
+    assert_equal [["some"], "V"], Depix::Structs.struct_to_template(one_int, false)
+
+    float = [[:afloat, Float, 4]]
+    assert_equal [["afloat"], "g"], Depix::Structs.struct_to_template(float, true)
+    assert_equal [["afloat"], "f"], Depix::Structs.struct_to_template(float, false)
+
+    two_ints = [[:some, Integer, 4], [:another, Integer, 4]]
+    assert_equal [["some", "another"], "NN"], Depix::Structs.struct_to_template(two_ints, true)
+    assert_equal [["some", "another"], "VV"], Depix::Structs.struct_to_template(two_ints, false)
+
+    two_ints = [[:some, Integer, 4], [:another, Integer, 2]]
+    assert_equal [["some", "another"], "Nn"], Depix::Structs.struct_to_template(two_ints, true)
+
+    two_ints = [[:some, Integer, 4], [:another, Integer, 2], [:str, String, 5]]
+    assert_equal [["some", "another", "str"], "NnA5"], Depix::Structs.struct_to_template(two_ints, true)
+    
+    int_and_nest = [
+      [:some, Integer, 4],
+      [:another, [[:inner, String, 3]], 3]
+    ]
+    assert_equal [["some", "another.inner"], "NA3"], Depix::Structs.struct_to_template(int_and_nest, true)
+  end
+  
+  def test_template_length
+    assert_equal 2084, Depix::Structs::TEMPLATE_LENGTH
+  end
+  
+  def test_dpx_info_present
+    assert_nothing_raised { Depix::Structs.const_get(:DPX_INFO) }
+  end
+end
+
+class ReaderTest < Test::Unit::TestCase
+  def test_nestify
+    k, v = ["foo", "bar"], [1, 2]
+    assert_equal( {"foo"=>1, "bar"=> 2}, Depix::Reader.nestify(k,v))
+
+    k, v = ["foo", "bar.baz"], [1, 2]
+    assert_equal( {"foo"=>1, "bar"=> {"baz"=> 2}}, Depix::Reader.nestify(k,v))
+
+    k, v = ["foo", "bar.baz", "bar.bam"], [1, 2, 3]
+    assert_equal( {"foo"=>1, "bar"=> {"baz"=> 2, "bam" => 3}}, Depix::Reader.nestify(k,v))
+
+    k, v = ["foo", "bar.baz.boo", "bar.baz.doo"], [1, 2, 3]
+    assert_equal( {"foo"=>1, "bar"=> {"baz"=> {"boo" => 2, "doo" => 3}}}, Depix::Reader.nestify(k,v))
+
+    k, v = ["foo", "bar.0", "bar.1"], [1, 2, 3]
+    assert_equal( {"foo"=>1, "bar"=>{0=>2, 1=>3}}, Depix::Reader.nestify(k,v))
+
+    k, v = ["foo", "bar.0.baz", "bar.0.dam"], [1, 2, 3]
+    assert_equal( {"foo"=>1, "bar"=>{0=>{"dam"=>3, "baz"=>2}}}, Depix::Reader.nestify(k,v))
+  end
+  
+  def test_parse
+    file = 'samples/E012_P001_L000002_lin.0001.dpx'
+    parsed = Depix::Reader.from_file(file)
+    assert_equal 'SDPX', parsed.file.magic
+    assert_equal 320, image.pixels_per_line
+    assert_equal 240, image.lines_per_element
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: depix
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Julik Tarkhanov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: Read DPX file metadata
+email: 
+- me@julik.nl
+executables: 
+- depix-describe
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- DPX_HEADER_STRUCTURE.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- DPX_HEADER_STRUCTURE.txt
+- Rakefile
+- bin/depix-describe
+- lib/depix.rb
+- lib/depix/struct_explainer.rb
+- lib/depix/structs.rb
+- test/test_depix.rb
+- test/samples/E012_P001_L000002_lin.0001.dpx
+- test/samples/E012_P001_L000002_lin.0002.dpx
+- test/samples/E012_P001_L000002_log.0001.dpx
+- test/samples/E012_P001_L000002_log.0002.dpx
+has_rdoc: true
+homepage: http://rubyforge.org/julik/depix
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: wiretap
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Read DPX file metadata
+test_files: 
+- test/test_depix.rb