timecode 0.1.0 → 0.1.2

data/History.txt

@@ -1,4 +1,13 @@
-=== 1.0.0 / 2008-12-15
+=== 0.1.2 / 2008-12-25
+
+* Fix to_uint
+* Always use float frame rates and rely on a small delta for comparison
+
+=== 0.1.1 / 2008-12-15
+
+* Allow passing framerate to from_uint
+
+=== 0.1.0 / 2008-12-15
 
 * 1 major enhancement
 

data/README.txt

@@ -1,6 +1,6 @@
 = timecode
 
-* http://projects.juli.nl/timecode
+* http://wiretap.rubyforge.org/timecode
 
 == DESCRIPTION:
 

data/Rakefile

@@ -1,9 +1,15 @@
 require 'rubygems'
-require 'hoe'
 require './lib/timecode.rb'
+require 'hoe'
 
-Hoe.new('timecode', Timecode::VERSION) do |p|
+Class.new(Hoe) do
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end.new('timecode', Timecode::VERSION) do |p|
   p.developer('Julik', 'me@julik.nl')
   p.extra_deps.reject! {|e| e[0] == 'hoe' }
   p.rubyforge_name = 'wiretap'
+  p.remote_rdoc_dir = 'timecode'
 end

data/lib/timecode.rb

@@ -1,6 +1,4 @@
-# Timecode is a convenience object for calculating SMPTE timecode natively. It is used in
-# various StoryTool models and templates, offers string output and is immutable.
-#
+# Timecode is a convenience object for calculating SMPTE timecode natively. 
 # The promise is that you only have to store two values to know the timecode - the amount
 # of frames and the framerate. An additional perk might be to save the dropframeness,
 # but we avoid that at this point.
@@ -14,10 +12,12 @@
 #     :mapping => [%w(source_tc_frames total), %w(tape_fps fps)]
 
 class Timecode
-  VERSION = '0.1.0'
+  VERSION = '0.1.2'
 
   include Comparable
-  DEFAULT_FPS = 25
+  
+  DEFAULT_FPS = 25.0
+  ALLOWED_FPS_DELTA = 0.001
   COMPLETE_TC_RE = /^(\d{1,2}):(\d{1,2}):(\d{1,2}):(\d{1,2})$/
   
   # All Timecode lib errors inherit from this
@@ -32,9 +32,6 @@ class Timecode
   # Self-explanatory
   class NonPositiveFps < RangeError; end
 
-  # Gets raised when float frame count is passed
-  class FrameIsWhole < RangeError; end
-
   # Gets raised when you divide by zero
   class TcIsZero < ZeroDivisionError; end
 
@@ -60,19 +57,17 @@ class Timecode
   end
   
   def initialize(total = 0, fps = DEFAULT_FPS) # :nodoc:
-    if total.is_a?(Float)
-      raise FrameIsWhole, "the number of frames cannot be partial (Integer value needed)"
-    end
-    
     raise RangeError, "Timecode cannot be negative" if total.to_f < 0
     raise WrongFramerate, "FPS cannot be zero" if fps.zero?
-    @total, @fps = total, fps 
+
+    # Always cast framerate to float, and num of rames to integer
+    @total, @fps = total.to_i, fps.to_f
     @value = validate!
     freeze
   end
   
   def inspect # :nodoc:
-    super.gsub(/@fps/, self.to_s + ' @fps').gsub(/ @value=\[(.+)\],/, '')
+    "#<Timecode:%s (%dF@%.2f)>" % [to_s, total, fps]
   end
   
   TIME_FIELDS = 7 # :nodoc:
@@ -167,13 +162,14 @@ class Timecode
   
     
     # Some systems (like SGIs) and DPX format store timecode as unsigned integer, bit-packed
-    def from_uint(uint)
+    def from_uint(uint, fps = DEFAULT_FPS)
       shift = 4 * TIME_FIELDS
       tc_elements = (0..TIME_FIELDS).map do 
         part = ((uint >> shift) & 0x0F)
         shift -= 4
         part
       end.join.scan(/(\d{2})/).flatten.map{|e| e.to_i}
+      tc_elements << fps
       at(*tc_elements)
     end
   end
@@ -218,12 +214,12 @@ class Timecode
     1.0/@fps
   end
   
-  # get the timecode as bit-packed unsigned int (suitable for DPX and SGI)
+  # get the timecode as bit-packed unsigned 32 bit int (suitable for DPX and SGI)
   def to_uint
     elements = (("%02d" * 4) % [hours,minutes,seconds,frames]).split(//).map{|e| e.to_i }
     uint = 0
-    elements.each do | el | 
-      uint = ((uint >> el))
+    elements.reverse.each_with_index do | p, i |
+      uint |= p << 4 * i 
     end
     uint
   end
@@ -255,7 +251,7 @@ class Timecode
   
   # add number of frames (or another timecode) to this one
   def +(arg)
-    if (arg.is_a?(Timecode) && arg.fps == @fps)
+    if (arg.is_a?(Timecode) && framerate_in_delta(arg.fps, @fps))
       Timecode.new(@total+arg.total, @fps)
     elsif (arg.is_a?(Timecode))
       raise WrongFramerate, "You are calculating timecodes with different framerates"
@@ -266,7 +262,7 @@ class Timecode
   
   # Subtract a number of frames
   def -(arg)
-    if (arg.is_a?(Timecode) &&  arg.fps == @fps)
+    if (arg.is_a?(Timecode) &&  framerate_in_delta(arg.fps, @fps))
       Timecode.new(@total-arg.total, @fps)
     elsif (arg.is_a?(Timecode))
       raise WrongFramerate, "You are calculating timecodes with different framerates"
@@ -283,7 +279,7 @@ class Timecode
   
   # Get the next frame
   def succ
-    self.class.new(@total + 1)
+    self.class.new(@total + 1, @fps)
   end
   
   # Slice the timespan in pieces
@@ -293,13 +289,19 @@ class Timecode
   
   # Timecodes can be compared to each other
   def <=>(other_tc)
-    if other_tc.is_a?(Timecode)
-      self.total <=> other_tc.class.new(other_tc.total, self.fps).total
+    if other_tc.is_a?(Timecode) && framerate_in_delta(fps, other_tc.fps)
+      self.total <=> other_tc.total
     else
       self.total <=> other_tc
     end
   end
-
+  
+  
+  # Validate that framerates are within a small delta deviation considerable for floats
+  def framerate_in_delta(one, two)
+    (one.to_f - two.to_f).abs <= ALLOWED_FPS_DELTA
+  end
+  
   private
   
   # Formats the actual timecode output from the number of frames

data/test/test_timecode.rb

@@ -7,6 +7,37 @@ require 'active_support'
 
 class TimecodeTest < Test::Unit::TestCase
   
+  def test_timecode_with_nil_gives_zero
+    assert_equal Timecode.new(0), Timecode.new(nil)
+  end
+  
+  def test_fps_always_coerced_to_float
+    t = Timecode.new(10, 25)
+    assert_kind_of Float, t.fps
+
+    t = Timecode.new(10, 25.0)
+    assert_kind_of Float, t.fps
+  end
+  
+  def test_framerate_in_delta
+    tc = Timecode.new(1)
+    assert tc.framerate_in_delta(25.0000000000000001, 25.0000000000000003)
+  end
+
+  def test_equality_validated_based_on_deltas
+    t1, t2 = Timecode.new(10, 25.0000000000000000000000000001), Timecode.new(10, 25.0000000000000000000000000002)
+    assert t1 == t2
+  end
+  
+  def test_inspect
+    tc = Timecode.new(10, 25)
+    assert_equal "#<Timecode:00:00:00:10 (10F@25.00)>", tc.inspect
+  end
+  
+  def test_equality_on_succ
+    assert_equal Timecode.parse("05:43:02:01"), Timecode.parse("05:43:02:00").succ 
+  end
+  
   def test_basics
     five_seconds_of_pal = 5.seconds * 25
     tc = Timecode.new(five_seconds_of_pal, 25)
@@ -42,8 +73,26 @@ class TimecodeTest < Test::Unit::TestCase
     end
 
   end
-    
-  def test_parse
+  
+  def test_succ
+    assert_equal Timecode.new(23), Timecode.new(22).succ
+  end
+  
+  def test_zero
+    assert Timecode.new(0).zero?
+    assert !Timecode.new(1).zero?
+    assert !Timecode.new(1000).zero?
+  end
+  
+  def test_plus
+    a, b = Timecode.new(24, 25.000000000000001), Timecode.new(22, 25.000000000000002)
+    assert_equal Timecode.new(24 + 22, 25.000000000000001), (a + b)
+  end
+end
+
+class TestParsing < Test::Unit::TestCase
+
+  def test_parse_simple
     simple_tc = "00:10:34:10"
     
     assert_nothing_raised do
@@ -63,16 +112,6 @@ class TimecodeTest < Test::Unit::TestCase
     end
   end
   
-  def test_succ
-    assert_equal Timecode.new(23), Timecode.new(22).succ
-  end
-  
-  def test_zero
-    assert Timecode.new(0).zero?
-    assert !Timecode.new(1).zero?
-    assert !Timecode.new(1000).zero?
-  end
-  
   def test_parse_from_numbers
     assert_equal Timecode.new(10), Timecode.parse("10")
     assert_equal Timecode.new(60), Timecode.parse("210")
@@ -84,8 +123,9 @@ class TimecodeTest < Test::Unit::TestCase
   end
   
   def test_parse_s
-    assert_equal Timecode.new(50), Timecode.parse("2s")
-    assert_equal Timecode.new(60), Timecode.parse("2s", 30)
+    assert_equal Timecode.new(50, 25), Timecode.parse("2s", 25)
+    assert_equal Timecode.new(60, 30), Timecode.parse("2s", 30)
+    assert_not_equal Timecode.new(60, 25), Timecode.parse("2s", 30)
   end
 
   def test_parse_m
@@ -107,10 +147,6 @@ class TimecodeTest < Test::Unit::TestCase
     assert_equal "00:00:02:00", tc.to_s
   end
   
-  def test_timecode_with_nil_gives_zero
-    assert_equal Timecode.new(0), Timecode.new(nil)
-  end
-  
   def test_parse_fractional_tc
     fraction = "00:00:07.1"
     tc = Timecode.parse_with_fractional_seconds(fraction, 10)
@@ -134,16 +170,6 @@ class TimecodeTest < Test::Unit::TestCase
 #   assert_equal Timecode.new(17), tc
 # end
   
-  def test_from_uint
-    uint, tc = 87310853, Timecode.at(5,34,42,5)
-    assert_equal tc, Timecode.from_uint(uint)
-  end
-  
-  def test_to_uint
-    uint, tc = 87310853, Timecode.at(5,34,42,5)
-    assert_equal uint, tc.to_uint
-  end
-  
   def test_from_seconds
     fraction = 7.1
     tc = Timecode.from_seconds(fraction, 10)
@@ -158,3 +184,15 @@ class TimecodeTest < Test::Unit::TestCase
     assert_equal "00:00:07:02", tc.to_s
   end
 end
+
+class TestUintConversion < Test::Unit::TestCase
+  def test_from_uint
+    uint, tc = 87310853, Timecode.at(5,34,42,5)
+    assert_equal tc, Timecode.from_uint(uint)
+  end
+  
+  def test_to_uint
+    uint, tc = 87310853, Timecode.at(5,34,42,5)
+    assert_equal uint, tc.to_uint
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: timecode
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors: 
 - Julik
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-19 00:00:00 +01:00
+date: 2008-12-25 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,7 +41,7 @@ files:
 - lib/timecode.rb
 - test/test_timecode.rb
 has_rdoc: true
-homepage: http://projects.juli.nl/timecode
+homepage: http://wiretap.rubyforge.org/timecode
 post_install_message: 
 rdoc_options: 
 - --main