wiretap 0.1 → 0.1.2

data/lib/wiretap.rb

@@ -24,20 +24,31 @@ module Wiretap
       begin
         Timeout.timeout(1) {TCPSocket.new(hostname,'7549')}
         real_alive?
-      rescue
+      rescue Timeout::Error, SocketError, Errno::ECONNREFUSED
         false
       end
     end
+    
+    def children
+      root.children
+    end
   end
   
+  # Returned from ServerList and contains information about a specific server. Call ServerInfo#server to retrieve the actual server
+  # object
   class ServerInfo
     def uri
       server.uri
     end
+    
+    def to_s #:nodoc:
+      super.gsub />$/, " hostname:'#{hostname}'>"
+    end
   end
   
   class ServerList
     include Enumerable
+    def length; count; end
   end
   
   class Reel
@@ -55,17 +66,29 @@ module Wiretap
       return children[path] if path.is_a?(Numeric)
     end
     
+    def ==(other) #:nodoc:
+      return false if other.nil?
+      (other.id == self.id) && (other.server == self.server)
+    end
+    
     def find(path)
       return self if path.empty?
+      
       return (find_child(path.shift).find(path) rescue nil) if path.respond_to?(:shift)
       find_child(path)
     end
     
+    def destroyed?
+      @destroyed ? true : false
+    end
+    
     # Returns a URL for the node that you can later pass to Wiretap::open
-    # Be alert though that it doesn't use the frame IDs - that is, if you have 7 reels of the same name and you ask
+    # Be alert though that it doesn't use the frame IDs - that is, if you have 7 reels of the same name 
+    # (which is a disaster and you should really think about your behavior) and you ask
     # for the uri of the second one, the first one is going to be reopened when you pass the uri to Wiretap::open
     # This is done so that you can maintain "soft links" to specific objects on libraries instead of the frame IDs.
     # When the clip gets edited you can still access it by name, although the frame IDs have changed.
+    # Same is valid for the reel IDs.
     def uri
       self.server.hostname + '/' + self.id
     end
@@ -126,8 +149,10 @@ module Wiretap
 
     # Destroys all the children of the node and node itself
     def destroy
-      children.each {|child| child.destroy} rescue nil
-      destroy!
+      return true if self.destroyed?
+      
+      children.each {|child| child.destroy unless child.destroyed? } rescue nil
+      destroy_self
     end
   end
 
@@ -192,7 +217,11 @@ module Wiretap
       
       outfile
     end
-
+    
+    # Returns the slate clip
+    def slate
+      children.find{|c| c.kind_of?(SlateClip)}
+    end
   protected
     def dump!(path)
       return nil unless clip?
@@ -204,6 +233,10 @@ module Wiretap
     end
   end
 
+  class SlateClip
+    def slate; self; end # :nodoc:
+  end
+  
   class Audio
     def to_s
       "#<#{self.class.to_s} '#{self.name}'>"
@@ -223,6 +256,10 @@ module Wiretap
     include Enumerable
     alias_method :size, :count
     alias_method :length, :count 
+    
+    def inspect #:nodoc:
+      super.gsub />$/, " length:#{length}>"
+    end
   end
 
   class AudioFrames
@@ -245,6 +282,13 @@ module Wiretap
       end
     end
     
+    BITS_PER_PIXEL_TO_BYTES = {
+      24 => 3.00003858024691,
+      30 => 4,
+      32 => 4,
+      36 => 4.5,
+      48 => 6,
+    }
     
     attr_reader :node
     @@audio_formats = [:dlaudio_mixed, :dlaudio_float, :dlaudio_float_le, :dlaudio_int16, :dlaudio_int16_le,
@@ -256,6 +300,22 @@ module Wiretap
     def to_s
       "#<Wiretap::ClipFormat size: #{self.width}x#{self.height}, bpp: #{self.bpp}, channels: #{self.channels}, rate: #{self.rate}, tag: #{self.tag}>"
     end
+    
+    def self.buffer_size_for(*opts)
+      opts = opts.last || {}
+      bpx = opts[:bpp]
+      
+      f_bpx = bpx.to_f
+      f_width = opts[:width].to_f
+      f_height = opts[:height].to_f
+      
+      puts f_bpx
+      puts f_width
+      puts f_height
+      
+      f_mult = BITS_PER_PIXEL_TO_BYTES[bpx]
+      return (f_mult * f_width * f_height).to_i
+    end
   end
   
   class AudioFormat

data/test_new/common.rb

@@ -0,0 +1,8 @@
+require 'test/unit'                                                     
+require 'benchmark'
+require 'fileutils'
+require File.dirname(__FILE__) + '/../lib/wiretap'
+require 'rubygems'
+require 'active_support'
+TESTS_DIR = File.dirname(__FILE__)
+FIXTURES_DIR = File.dirname(__FILE__) + '/fixtures'

data/test_new/test_audio_conversions.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/common'
+$STAMP = Time.now.to_i
+
+class AudioConversionsTest < Test::Unit::TestCase
+  
+  def setup
+    @samples = 48000
+    @rate = 48000.0
+    @bps = 32
+    @temp_outdir = "/tmp/wiretap_test_outputs_#{$STAMP}"
+    FileUtils.mkdir_p(@temp_outdir)
+  end
+  
+  def test_read_audio
+    output = "#{@temp_outdir}/stonesound.aiff"
+    File.open(FIXTURES_DIR + "/raw-snd/simple.stonesound") do |f|
+      Wiretap.dump_audio_data(@samples, @rate, @bps, :dlaudio_float, f.read(@samples*@bps/8), output)
+      assert_equal "#{output}: AIFF data, AIFF audio\n", `file #{output}`, "Should be recognized as AIFF audio"
+    end
+  end
+  
+  def test_get_format
+    assert @format = Wiretap.audio_format(FIXTURES_DIR + "/snd/simple-wave.wav")
+    assert_equal 16, @format.bps
+    assert_equal 48000.0, @format.rate
+    assert_equal 97280, @format.samples
+  end
+end

data/test_new/test_image_conversions.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/common'
+$STAMP = Time.now.to_i
+
+class TestImageConversions < Test::Unit::TestCase
+  
+  def setup
+    @width = 720
+    @height = 576
+    @temp_outdir = "/tmp/wiretap_test_outputs_#{$STAMP}"
+    FileUtils.mkdir_p @temp_outdir
+  end
+
+  def test_dump_bmp_24
+    output = "#{@temp_outdir}/sgi_24bit.test_run_%s.bmp"
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_8bit_8f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 24, f.read(@width*@height*3), output % i)
+      end
+    end
+  end
+
+  def test_dump_sgi_24
+    output = "#{@temp_outdir}/sgi_24bit.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_8bit_8f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 24, f.read(@width*@height*3), output % i )
+      end
+    end
+  end
+
+  def test_dump_bmp36_unpacked
+    output = "#{@temp_outdir}/bmp_36bit_from_12u.test_run_%s.bmp"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitU_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*6), output % i)
+      end
+    end
+  end
+  
+  def test_dump_bmp36_packed
+    output = "#{@temp_outdir}/bmp_36bit_from_12p.test_run_%s.bmp"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitP_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), output % i )
+      end
+    end
+  end
+
+  def test_dump_sgi36_unpacked
+    output = "#{@temp_outdir}/sgi_36bit_from_12u.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitU_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*6), output % i)
+      end
+    end
+  end
+  
+  def test_dump_sgi36_packed
+    output = "#{@temp_outdir}/sgi_36bit_from_12p.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitP_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), output % i)
+      end
+    end
+  end
+
+  def test_dump_bmp32
+    output = "#{@temp_outdir}/bmp_32bit_from_10bit.test_run_%s.bmp"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_10bit_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 32, f.read(@width*@height*4), output % i)
+      end
+    end
+  end
+
+  def test_dump_sgi32
+    output = "#{@temp_outdir}/sgi_32bit_from_10bit.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_10bit_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 32, f.read(@width*@height*4), output % i )
+      end
+    end
+  end
+
+  def xtest_dump_sgi48_packed
+    output = "#{@temp_outdir}/sgi_48bit_from_12p.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitP_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 48, f.read(@width*@height*9/2), output % i)
+      end
+    end
+  end
+
+  def test_dump_sgi48_unpacked
+    output = "#{@temp_outdir}/sgi_48bit_from_12u.test_run_%s.sgi"
+    FileUtils.rm_f output
+    3.times do | i |
+      File.open(FIXTURES_DIR + "/raw/cube_SD_12bitU_5f/%s.stoneimage" % i) do |f|
+        Wiretap.dump_image_data(@width, @height, 48, f.read(@width*@height*6), output % i)
+      end
+    end
+  end
+
+  def test_ppm_format
+    assert @format = Wiretap::image_format(FIXTURES_DIR + "/img/ppm-8bit/01.ppm"), "Should retrieve format from ppm file"
+    assert_equal 720, @format.width
+    assert_equal 576, @format.height
+    assert_equal 24, @format.bpp
+    assert_equal 3, @format.channels
+    assert_equal 720*576*3, @format.buffer_size
+    assert_equal 25, @format.rate
+    assert_equal :progressive, @format.scan
+  end
+
+  def test_ppm_to_sgi
+    assert Wiretap::convert_image(FIXTURES_DIR + "/img/ppm-8bit/01.ppm","#{@temp_outdir}/ppm1.sgi")
+    assert_equal "#{@temp_outdir}/ppm1.sgi: SGI image data, 3-D, 720 x 576, 3 channels\n", `file #{@temp_outdir}/ppm1.sgi`
+  end
+
+  def teardown
+    `open #{@temp_outdir}`
+  end
+
+end

data/test_new/test_parts/connect_to_test_host.rb

@@ -0,0 +1,27 @@
+module TestConnectToTestHost
+  def test_02_connect_to_test_host
+    faulty_server = Wiretap::Server.new("xyz.zy.google.net")
+    assert_kind_of Wiretap::Server, faulty_server, "This should be a Wiretap server object"
+    assert !faulty_server.alive?, "The faulty server should be registered dead"
+
+    assert_kind_of Wiretap::Server, @server, "This should be a Wiretap server object"
+    assert @server.alive?, "The server should be alive to test it - maybe you have mistakenly entered a faulty IP adderss?"
+
+    assert_equal @test_host, @server.hostname
+    assert_match /(\d+)/, @server.version, "Server version has to be a String and has to contain a number"
+    assert_match /Discreet/, @server.vendor, "The vendor should be Discreet"
+    assert_match /IFFFS/, @server.product, "The product should be IFFS (InfernoFlintFlameSmoke)"
+
+    assert @server.close!, "The connection should be closed succesfully"
+    
+    assert_raise(Wiretap::Error, "Accessing a closed server handle should raise") do
+      root = @server.root
+    end
+  end
+  
+  def test_02a_bailing_when_opening_from_dead_server
+    assert_raise(Wiretap::ServerDead) { nonexistent_lib = Wiretap::open("10.2.2.2/Bla") }
+    dead_server = Wiretap::Server.new("10.2.2.2/Bla")
+    assert !dead_server.alive?, "The dead server should respond dead"
+  end
+end

data/test_new/test_parts/constants.rb

@@ -0,0 +1,7 @@
+module TestConstants
+  def test_0_constants
+    assert defined?(Wiretap), "The main constant should be defined"
+    assert defined?(Wiretap::Node), "The node constant should be defined"
+    assert_equal "2007.0", Wiretap::CLIENT_VERSION
+  end
+end

data/test_new/test_parts/create_test_project.rb

@@ -0,0 +1,37 @@
+module TestCreateTestProject
+   def test_02a_create_test_project
+     begin
+       @project = @volume.create_project("RubyWiretapTest_#{Time.now.to_i}")
+       assert_kind_of Wiretap::Project, @project
+     rescue Wiretap::Error
+       @project = @volume[@test_project_name]
+       unless @project
+         $stderr.puts "This server does not allow creation of Project nodes - #{OLD_SERVER}"
+         $stderr.puts "We also cannot find the test project, create a project #{@test_project_name} \
+  on your server and try again"
+         return
+       end
+     end
+
+     # Overload the project name so that next time we use that project for testing
+     ENV['RUBY_WIRETAP_TEST_PROJECT'] = @project.name
+     assert_kind_of Wiretap::Project, @project, "Should be a project node"
+
+     @lib = @project.children[0]
+     unless @lib
+       begin
+         @lib = @project.create_library("TestRun")
+         assert_kind_of Wiretap::Library, @lib, "We should have created a library"
+       rescue Wiretap::Error
+         $stderr.puts "Your test project has no libraries and we cannot create a library automatically. #{OLD_SERVER}"
+         return
+       end
+     end
+
+     # Overload the library name so that we use that library next time
+     ENV['RUBY_WIRETAP_TEST_LIBRARY'] = @lib.uri
+
+     # Overload the key for stuff we are going to create on the framestore
+     ENV['RUBY_WIRETAP_TEST_RUN'] ||= Time.now.to_i.to_s
+   end
+end

data/test_new/test_parts/raw_formats_and_uploads.rb

@@ -0,0 +1,170 @@
+module TestRawFormatsAndUploads
+  BASE_FMT = {
+    :ratio => 1.06666004657745, # Pixel aspect
+    :meta_tag => :IFFFS_XML,
+    :buffer_size => 1244176, # In bytes
+    :bpp => 24, # Bits per pixel
+    :rate =>  25.0, #Framerate
+    :tag => :rgb,
+    :meta => '<IFFFS_XML Version="1.0"><ClipData><DropMode>NDF</DropMode><SrcTimecode>01:03:31:07</SrcTimecode><TapeName>MASTER_O</TapeName></ClipData></IFFFS_XML>',
+    :height => 576,
+    :scan => :progressive,
+    :channels => 3, # Oh I wish it was 4
+    :width => 720,
+  }
+  
+  
+  def test_04_raw_formats_and_uploads
+      @lib = Wiretap::open(@test_library)
+      assert_kind_of Wiretap::Library, @lib, "We should have gotten hold of the test library"
+      
+      clip_params = BASE_FMT
+      pal_sd = Wiretap::ClipFormat.new(clip_params)
+      clip_params.each_pair do | k, v |
+        assert pal_sd.respond_to?(k), "Clip format should respond to the getter for #{k}"
+        assert pal_sd.respond_to?(k.to_s + "="), "Clip format should respond to the setter for #{k}"
+        assert_equal v.to_s, pal_sd.send(k).to_s, "Clip format should retain the value we sent it for #{k}"
+      end
+      
+      # Allocate the clip
+      begin
+        @clip = @lib.create_clip("FirstClip_8bit_#{@test_run}", 'CLIP', pal_sd)
+        assert_equal "FirstClip_8bit_#{@test_run}", @clip.name, "The name should have been properly assigned"
+      rescue Wiretap::LibraryLocked
+        $stderr.puts "\n !! Looks like you still have the library open on your Flame/Smoke. Close it and try to run \
+  the tests again"
+        return
+      end
+
+      @deletables << @clip
+      
+      
+      fmt = @clip.format
+      assert_kind_of Wiretap::ClipFormat, fmt, "Shoud give us the format back"
+
+      clip_params.each_pair do | k, v |
+        assert fmt.respond_to?(k), "Clip format should respond to the getter for #{k}"
+        assert fmt.respond_to?(k.to_s + "="), "Clip format should respond to the setter for #{k}"
+        assert_equal v.to_s, fmt.send(k).to_s, "Clip format should retain the value we sent it for #{k}"
+      end
+
+      raw_cube_dir = TESTS_DIR + '/fixtures/raw/cube_SD_8bit_8f'
+
+      files = Dir.entries(raw_cube_dir).grep(/stoneimage/).map{|f| raw_cube_dir + '/' + f }
+      assert_equal 8, files.length, "We should have 8 paths to 8 frames ready to go"
+
+      assert_nothing_raised("We should be able to set the length on this new clip") do
+        @clip.frames.length = 8
+      end
+
+      assert_raise(Wiretap::Error, "We should NOT be able to allocate the frame length twice") do
+        @clip.frames.length = 25
+      end
+
+      assert_kind_of Wiretap::NodeFrames, @clip.frames, "NodeFrames has to be provided to us"
+
+      assert_nothing_raised("We should easily write the frames one by one") do
+        files.each_with_index do | p, i |
+          @clip.frames[i] = File.read(p)
+        end
+      end
+
+      assert_equal 9, @clip.frames.length, "The frame count should be off by 1 because of a bug in Wiretap"
+
+      dir = "/tmp/wiretap-ruby-export/#{@test_run}"
+      assert_nothing_raised("We should be able to create the test exports directory in your /tmp") do
+        FileUtils.mkdir_p(dir)
+      end
+
+      imgs = []
+      assert_nothing_raised("We should be able to export 8bit SGI images") do
+        8.times do | at |
+          frame_path = "#{dir}/8bit_PAL_#{at}.sgi"
+          @clip.frames.dump(at, frame_path)
+          imgs << frame_path
+        end
+      end
+      
+      open_images_in_viewer(imgs, "The images are 8 bit")
+      
+      assert_kind_of Wiretap::SlateClip, @clip.slate, "We should be able to get hold of the slate"
+      
+      raw_cube_dir = TESTS_DIR + '/fixtures/raw/cube_SD_10bit_5f'
+      files = Dir.entries(raw_cube_dir).grep(/stoneimage/).map{|f| raw_cube_dir + '/' + f }
+      assert_equal 5, files.length, "We should have 5 paths ready to go"
+
+       ten_bit_clip_params = clip_params.merge({
+         :buffer_size => File.stat(files[0]).size, # Life is sweet with a little automation
+         :bpp => 32, # Bits per pixel
+       })
+       
+       pal_sd_10bit = Wiretap::ClipFormat.new(ten_bit_clip_params)
+       ten_bit_clip_params.each_pair do | k, v |
+         assert_equal v.to_s, pal_sd_10bit.send(k).to_s, "Clip format should retain the value we sent it for #{k}"
+       end
+       
+       assert_nothing_raised("We should be able to create the clip with this format") do
+         @clip = @lib.create_clip("TestClip_10bit", "CLIP", pal_sd_10bit)
+         @deletables << @clip
+       end
+
+       assert_nothing_raised("We should be able to allocate 5 frames in the new 10bit clip") do
+         @clip.frames.length = 5
+       end
+       
+       assert_nothing_raised("We should easily write the frames one by one") do
+         files.each_with_index do | p, i |
+           @clip.frames[i] = File.read(p)
+         end
+       end
+       
+       imgs = []
+       assert_nothing_raised("We should be able to export 16bit SGI images") do
+         5.times do | at |
+           frame_path = "#{dir}/16bit_PAL_#{at}.sgi"
+           @clip.frames.dump(at, frame_path)
+           imgs << frame_path
+         end
+       end
+       open_images_in_viewer(imgs, "The images are 16 bit")
+
+       raw_cube_dir = TESTS_DIR + '/fixtures/raw/cube_SD_12bitP_5f'
+       files = Dir.entries(raw_cube_dir).grep(/stoneimage/).map{|f| raw_cube_dir + '/' + f }
+       assert_equal 5, files.length, "We should have 5 paths ready to go"
+
+       tw_bit_p_bit_clip_params = clip_params.merge({
+         :buffer_size => File.stat(files[0]).size, # Life is sweet with a little automation
+         :bpp => 36, # Bits per pixel
+       })
+       
+       pal_sd_12bit_p = Wiretap::ClipFormat.new(tw_bit_p_bit_clip_params)
+       tw_bit_p_bit_clip_params.each_pair do | k, v |
+         assert_equal v.to_s, pal_sd_12bit_p.send(k).to_s, "Clip format should retain the value we sent it for #{k}"
+       end
+       
+       assert_nothing_raised("We should be able to create the clip with this format") do
+         @clip = @lib.create_clip("TestClip_12bitP", "CLIP", pal_sd_12bit_p)
+         @deletables << @clip
+       end
+
+       assert_nothing_raised("We should be able to allocate 5 frames in the new 12bitP clip") do
+         @clip.frames.length = 5
+       end
+       
+       assert_nothing_raised("We should easily write the frames one by one") do
+         files.each_with_index do | p, i |
+           @clip.frames[i] = File.read(p)
+         end
+       end
+       
+       imgs = []
+       assert_nothing_raised("We should be able to export 16bit SGI images") do
+         5.times do | at |
+           frame_path = "#{dir}/16bit_PAL_#{at}.sgi"
+           @clip.frames.dump(at, frame_path)
+           imgs << frame_path
+         end
+       end
+       open_images_in_viewer(imgs, "The images are 16 bit")
+    end
+end

data/test_new/test_parts/server_list.rb

@@ -0,0 +1,20 @@
+module TestServerList
+  def test_01_server_list
+    @list = Wiretap::ServerList.new
+    assert_kind_of Wiretap::ServerList, @list
+    servers = []
+
+    @list.each do | info |
+      assert_kind_of Wiretap::ServerInfo, info, "Should be a Wiretap::ServerInfo object"
+      assert info.respond_to?(:server), "ServerInfo should provide the #server method"
+      assert_kind_of Wiretap::Server, info.server
+      servers << info.server
+    end
+    assert_equal @list.length, @list.count, "ServerList should provide both length and count and they should equal"
+
+#    assert_equal servers.length, @list.length, "The number of servers returned should match the number of loop calls"
+    assert 0 < @list.length, "ServerList should discover at least one host"
+    hostnames = servers.map{|s| s.hostname}
+    assert hostnames.include?(@test_host), "One of the discovered servers should have a hostname that you use for testing"
+  end
+end