wiretap 0.1

data/ext/wiretap.cpp

@@ -0,0 +1,68 @@
+#include "wiretap.h"
+
+
+VALUE mWiretap, mPPM, cServer, cNodeChildren, cServerList, cServerInfo;
+VALUE cClipFormat, cAudioFormat, cNodeMetaData, cNodeFrames, cAudioFrames;
+VALUE cNode, cHost, cVolume, cClip, cAudio, cReel, cLibrary, cProject;
+VALUE eError;
+ID to_i;
+
+VALUE wiretap_to_str(WireTapStr& str) {
+	return rb_str_new(str.c_str(), str.length());
+}
+
+
+VALUE wiretap_false(int argc, VALUE* argv, VALUE self) {
+	return Qfalse;
+}
+VALUE wiretap_true(int argc, VALUE* argv, VALUE self) {
+	return Qtrue;
+}
+
+void wiretap_throw(const char *file, long unsigned int line, const char *fmt, ...) {
+	char* message;
+	va_list ap;
+	va_start(ap, fmt);
+	vasprintf(&message, fmt, ap);
+	va_end(ap);
+	
+	char error_message[strlen(message) + 80];
+	snprintf(error_message, sizeof(error_message), "%s. File: %s, line: %lu", message, file, line);
+	free(message);
+	rb_raise(eError, error_message);
+}
+
+
+extern "C"
+
+
+void Init_wiretap_bin() {
+	if ( !WireTapClientInit() ) {
+		rb_raise(rb_eStandardError, "Unable to init WireTap Client infrastructure");
+	}
+	to_i = rb_intern("to_i");
+	
+	mWiretap = rb_define_module("Wiretap");
+	eError = rb_define_class_under(mWiretap, "Error", rb_eStandardError);
+	
+#ifdef HAVE_SNDFILE_H
+	rb_define_singleton_method(mWiretap, "supports_audio?", VALUEFUNC(wiretap_true), -1);
+#else
+	rb_define_singleton_method(mWiretap, "supports_audio?", VALUEFUNC(wiretap_false), -1);
+#endif
+	
+	Init_ppm();
+	
+	Init_server();
+	Init_node();
+	Init_children();
+	Init_metadata();
+	Init_nodeframes();
+	Init_format();
+	Init_image_format();
+	Init_audio_format();
+	Init_serverlist();
+	
+	Init_thread_worker();
+}
+

data/ext/wiretap.h

@@ -0,0 +1,115 @@
+#ifndef _WIRETAP_H_
+#define _WIRETAP_H_
+
+#include <WireTapClientAPI.h>
+#include <ifffsWTTypes.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "ruby.h"
+#include "rubyio.h"
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <stdarg.h>
+#include "image.h"
+#include <memory>
+
+
+#ifdef __cplusplus
+#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
+#    define PROTECTFUNC(f) ((VALUE (*)()) f)
+#    define VALUEFUNC(f) ((VALUE (*)()) f)
+#    define VOIDFUNC(f)  ((void (*)()) f)
+#  else
+#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
+#      define PROTECTFUNC(f) ((VALUE (*)()) f)
+#      define VALUEFUNC(f) ((VALUE (*)()) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    else /* These definitions should work for Ruby 1.7+ */
+#      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
+#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
+#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
+#    endif
+#  endif
+#else
+#  define VALUEFUNC(f) (f)
+#  define VOIDFUNC(f) (f)
+#endif
+
+#define STR(x) (RSTRING(x)->ptr)
+#define SAFESTR(x) (x == Qnil ? NULL : RSTRING(x)->ptr)
+#define CSTR(x) (const char *)(STR(x))
+#define CSAFESTR(x) (const char *)(SAFESTR(x))
+#define LEN(x) (RSTRING(x)->len)
+#define RUN(x) if(!x) { return Qnil; }
+#define NODERUN(node, x) {if(!x) { \
+	rb_warn("Problem in wiretap: %s. File: %s: %d", node->lastError(), __FILE__, __LINE__); \
+	return Qnil; \
+}}
+
+// Run a block with expression wrapping
+#define RUN_E(expr, container) {if(!(expr)) { \
+	rb_raise(eError, "Problem in wiretap: %s. File: %s: %d", container->lastError(), __FILE__, __LINE__); \
+}}
+
+#define NODERUN_E(node, x) RUN_E(x, node)
+#define SERVERRUN_E(server, x) RUN_E(x, server)
+
+#define Check_Node_Alive(node) \
+if(rb_iv_get(self, "@destroyed") == Qtrue) { \
+	rb_warn("Node is already destroyed"); \
+	return Qnil; \
+} \
+
+
+VALUE wiretap_false(int argc, VALUE* argv, VALUE self);
+VALUE wiretap_true(int argc, VALUE* argv, VALUE self);
+VALUE wiretap_to_str(WireTapStr &str);
+
+#define THROW(message, ...) wiretap_throw(__FILE__, __LINE__, message, ##__VA_ARGS__)
+void wiretap_throw(const char* file, long unsigned int line, const char *fmt, ...);
+
+void Init_serverlist();
+void Init_server();
+void Init_node();
+VALUE wiretap_node_create_with(WireTapNodeHandle& node, VALUE server, VALUE parent);
+
+
+void Init_format();
+void wiretap_format_free(WireTapClipFormat* format);
+
+void Init_children();
+void Init_metadata();
+void Init_nodeframes();
+
+void Init_ppm();
+bool ppm_read_format(FILE* f, WireTapClipFormat* format);
+bool ppm_read_image(FILE* f, unsigned char* frame, int width, int height, int bpp);
+
+
+void Init_image_format();
+bool wiretap_write_image_frame(int width, int height, int bpp, unsigned char* frame, const char* filename);
+
+void Init_audio_format();
+int wiretap_write_audio_frame(int samples, int rate, int bps, ID type, unsigned char* frame, const char* filename);
+
+
+void Init_thread_worker();
+
+extern "C" {
+	void Init_wiretap_bin(void);
+	extern VALUE mWiretap, mPPM, cServer, cServerList, cServerInfo;
+	extern VALUE cNode, cHost, cVolume, cClip, cAudio, cReel, cLibrary, cProject;
+	extern VALUE cNodeChildren, cNodeFrames, cAudioFrames, cNodeMetaData, cClipFormat, cAudioFormat;
+	extern VALUE eError;
+	extern ID to_i;
+
+}  /* extern "C" { */
+
+
+
+
+
+#endif
+
+

data/lib/wiretap.rb

@@ -0,0 +1,280 @@
+begin
+  require File.dirname(__FILE__)+'/wiretap_bin'
+rescue LoadError
+  require File.dirname(__FILE__)+'/../ext/wiretap_bin'
+end
+require 'timeout'
+require 'socket'
+
+module Wiretap
+
+  FRAMES_PATTERN = /[A-Z]_-(\d){10}_[A-Z]_(\d){10}_[A-Z]_(\d){6}/
+  class Server
+    def find(path)
+      root.find(path.split("/"))
+    end
+    alias :[] :find
+    
+    def uri
+      hostname
+    end
+
+    alias :real_alive? :alive?
+    def alive?
+      begin
+        Timeout.timeout(1) {TCPSocket.new(hostname,'7549')}
+        real_alive?
+      rescue
+        false
+      end
+    end
+  end
+  
+  class ServerInfo
+    def uri
+      server.uri
+    end
+  end
+  
+  class ServerList
+    include Enumerable
+  end
+  
+  class Reel
+    def uri
+      [parent.uri, name].join('/')
+    end
+  end
+  
+  class Node
+    attr_reader :server
+    attr_reader :parent
+    
+    def [](path)
+      return find(path) if path.is_a?(String)
+      return children[path] if path.is_a?(Numeric)
+    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
+    
+    # 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
+    # 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.
+    def uri
+      self.server.hostname + '/' + self.id
+    end
+
+    def to_s
+      "#<#{self.class.to_s} '#{self.name}', children: #{self.children.count}>"
+    end
+    alias :inspect :to_s
+    
+    # Returns a list of names of all child nodes
+    def ls
+      children.map {|c| c.name}
+    end
+
+    # Creates a project as a child of the Volume node
+    def create_project(name)
+      node = create_node(name, "PROJECT")
+      yield node if block_given?
+      node
+    end
+
+    # Creates a library as a child of the Project node
+    def create_library(name)
+      node = create_node(name, "LIBRARY")
+      yield node if block_given?
+      node
+    end
+
+    # Creates a reel as a child of a Desktop or Library node    
+    def create_reel(name)
+      node = create_node(name, "REEL")
+      yield node if block_given?
+      node
+    end
+    
+    def import_video(name, file)
+=begin
+      1. create directory
+      2. change to it
+      3. run mplayer -vo pnm -ao pcm:file=output.wav on our movie
+      4. format = Wiretap::PPM::format(Dir["."].entries.first)
+      5. create clip with this format
+      6. @clip.import_directory(".")
+      7. Find out format of output.wav
+      8. create audioclip with this format. NOTE: by default, output format from mplayer is dlaudio_int16_le
+      9. @audio.import_music("output.wav")
+=end
+    end
+    
+    # Imports the first frame of an image in PPM format
+    def import_image(name, filename)
+      format = Wiretap::PPM::format(filename)
+      node = create_clip(name, "CLIP", format)
+      node.frames.count = 1
+      node.frames.write_from_file(0, filename)
+      node
+    end
+
+    # Destroys all the children of the node and node itself
+    def destroy
+      children.each {|child| child.destroy} rescue nil
+      destroy!
+    end
+  end
+
+  class Library
+  end
+    
+  class Clip
+    def to_s
+      "#<#{self.class.to_s} '#{self.name}', frames: #{self.frames.count}>"
+    end
+
+    # Returns a name-based path to the clip (as opposed to the frame ID ranges provided by Wiretap ID)
+    def uri
+      ident = (self.server.hostname + '/' + self.id).split(/\//)
+      ident[-1] = name
+      ident[-2] = parent.name if parent.reel?
+
+      return ident.join('/')
+    end
+    
+    def dump(path)
+      return unless frame_names = dump!(path)
+      fmt = format
+      mencoder_cmd = "mencoder mf://#{frame_names.join(",")} -mf w=#{fmt.width}:h=#{fmt.height}:fps=25:type=sgi " +
+         " -ovc lavc -lavcopts vcodec=mpeg4:mbd=2:turbo -oac copy -o output.avi"
+      `(cd #{path} && #{mencoder_cmd} && ffmpeg -i output.avi output.mov) 2>&1 >/dev/null`
+    end
+
+    def to_video(path, options = {})
+      return unless frame_names = dump!(path)
+      fmt = format
+      
+      if options[:resize]
+        target_width = options[:resize].split(/x/)[0]
+        target_height = options[:resize].split(/x/)[1]
+        
+        frame_names.map! do | n |
+          `convert -resize #{options[:resize]}! #{File.join(path,n)} #{File.join(path,n +'.resized.sgi')}`
+          n + '.resized.sgi'
+        end
+      else
+        target_width = fmt.width
+        target_height = fmt.height
+      end
+      
+      
+      mencoder_cmd = "mencoder mf://#{frame_names.join(",")} -mf w=#{target_width}:h=#{target_height}:fps=25:type=sgi " +
+         " -ovc lavc -lavcopts vcodec=mpeg4:mbd=2:turbo -o output.avi"
+         
+      begin
+        # Try to assimilate audio in the clip
+        find("#{self.name} (audio)").find("#{self.name} (stream)").dump "#{path}/audio.aiff"
+        `(cd #{path} && #{mencoder_cmd} && ffmpeg -i output.avi -acodec aac -i audio.aiff output.mov) 2>&1 >/dev/null`
+      rescue NoMethodError, Wiretap::Error
+        # No audio given, proceed with images only
+        `(cd #{path} && #{mencoder_cmd} && ffmpeg -i output.avi -acodec aac output.mov) 2>&1 >/dev/null`
+      end
+      
+      outfile = path + "/output.mov"
+      File.unlink(path + "/0.sgi")
+      File.unlink(path + "/output.avi")
+      
+      outfile
+    end
+
+  protected
+    def dump!(path)
+      return nil unless clip?
+      return nil if path.empty?
+      `rm -rf #{path}/*`
+      `mkdir -p #{path}`
+      self.frames.dump_all("#{path}/%d.sgi")
+      frame_names = (0...self.frames.count).to_a.map {|i| "#{i}.sgi" }
+    end
+  end
+
+  class Audio
+    def to_s
+      "#<#{self.class.to_s} '#{self.name}'>"
+    end
+  end
+  
+  
+  class NodeChildren
+    attr_reader :node
+    include Enumerable
+    alias_method :size, :count
+    alias_method :length, :count
+  end
+  
+  class NodeFrames
+    attr_reader :node
+    include Enumerable
+    alias_method :size, :count
+    alias_method :length, :count 
+  end
+
+  class AudioFrames
+    alias :real_dump :dump
+    def dump(index, filename)
+      FileUtils.rm_r(filename) rescue nil
+      real_dump(index, filename)
+    end
+  end
+  
+  class NodeMetaData
+    attr_reader :node
+    include Enumerable
+  end
+  
+  class ClipFormat
+    def initialize(options = {})
+      options.each do |key, value| 
+        self.send("#{key}=".to_sym, value) if self.respond_to?("#{key}=".to_sym) 
+      end
+    end
+    
+    
+    attr_reader :node
+    @@audio_formats = [:dlaudio_mixed, :dlaudio_float, :dlaudio_float_le, :dlaudio_int16, :dlaudio_int16_le,
+     :dlaudio_int24, :dlaudio_int24_le, :wav, :aiff, :aifc, :dlaudio ]
+    def audio?
+      @@audio_formats.include? self.tag
+    end
+    
+    def to_s
+      "#<Wiretap::ClipFormat size: #{self.width}x#{self.height}, bpp: #{self.bpp}, channels: #{self.channels}, rate: #{self.rate}, tag: #{self.tag}>"
+    end
+  end
+  
+  class AudioFormat
+    def to_s
+      "#<Wiretap::AudioFormat samples: #{self.samples}, bps: #{self.bps}, sample rate: #{self.sample_rate}>"
+    end
+  end
+    
+  
+  def self.open(uri)
+    return unless match_data = uri.match(/([^\/]+)(\/?)(.*)/)
+    server = Server.new(match_data.captures.first)
+    raise Wiretap::ServerDead, "Could not connect to Wiretap host #{match_data.captures.first}" unless server.alive?
+    
+    return server if match_data.captures.last.empty?
+    server.find(match_data.captures.last)
+  end
+
+  class ServerDead < RuntimeError
+  end
+end
+

data/test/audio.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/wiretap'
+
+class AudioTest < Test::Unit::TestCase
+  
+  def setup
+    @samples = 48000
+    @rate = 48000.0
+    @bps = 32
+    @temp_outdir = "/tmp/wiretap_tests"
+    FileUtils.mkdir(@temp_outdir) rescue nil
+  end
+  
+  def test_read_audio
+    File.open(File.dirname(__FILE__) + "/wiretap-images/b1.stonesound") do |f|
+      Wiretap.dump_audio_data(@samples, @rate, @bps, :dlaudio_float, f.read(@samples*@bps/8), "#{@temp_outdir}/b1.aiff")
+      assert_equal "#{@temp_outdir}/b1.aiff: IFF data, AIFF audio\n", `file #{@temp_outdir}/b1.aiff`
+    end
+  end
+  
+  def test_get_format
+    assert @format = Wiretap.audio_format(File.dirname(__FILE__) + "/wiretap-images/output.wav")
+    assert_equal 16, @format.bps
+    assert_equal 48000.0, @format.rate
+    assert_equal 97280, @format.samples
+  end
+end

data/test/convert.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/wiretap'
+require 'benchmark'
+
+
+class ConvertTest < Test::Unit::TestCase
+
+  def setup
+    @temp_outdir = "/tmp/wiretap_tests/thread_convert"
+    `rm -rf #{@temp_outdir}`
+    `mkdir -p #{@temp_outdir} 2>/dev/null`
+  end
+  
+
+  def test_convert
+    num = 1
+    iteration = 0
+    
+    Wiretap::ThreadWorker::run do |i|
+      filename = File.dirname(__FILE__) + "/wiretap-images/importable-seq/#{(num).to_s.rjust(8, '0')}.ppm"
+      unless File.exists?(filename)
+        iteration += 1
+        if iteration == 100
+          break
+        end
+        num = 1
+        filename = File.dirname(__FILE__) + "/wiretap-images/importable-seq/#{(num).to_s.rjust(8, '0')}.ppm"
+      end
+      num += 1
+      "convert #{filename} #{@temp_outdir}/#{i.to_s.rjust(8,'0')}.jpg"
+      #{}"echo #{i} >> /tmp/log"
+    end
+    
+  end
+end

data/test/image.rb

@@ -0,0 +1,101 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/wiretap'
+
+class ImageTest < Test::Unit::TestCase
+  
+  def setup
+    @width = 720
+    @height = 576
+    @temp_outdir = "/tmp/wiretap_tests"
+    `mkdir #{@temp_outdir} 2>/dev/null`
+  end
+  
+  def test_dump_bmp_24
+    Wiretap.dump_image_format = :bmp
+    0.upto(3) do |i|
+      File.open(File.dirname(__FILE__) + "/wiretap-images/a#{i}.stoneimage") do |f|
+        `rm -f #{@temp_outdir}/a#{i}.bmp`
+        Wiretap.dump_image_data(@width, @height, 24, f.read(@width*@height*3), "#{@temp_outdir}/a#{i}.bmp")
+      end
+    end
+  end
+
+  def test_dump_sgi_24
+    Wiretap.dump_image_format = :sgi
+    0.upto(3) do |i|
+      File.open(File.dirname(__FILE__) + "/wiretap-images/a#{i}.stoneimage") do |f|
+        `rm -f #{@temp_outdir}/a#{i}.sgi`
+        Wiretap.dump_image_data(@width, @height, 24, f.read(@width*@height*3), "#{@temp_outdir}/a#{i}.sgi")
+      end
+    end
+  end
+  
+  def test_dump_bmp36
+    Wiretap.dump_image_format = :bmp
+    `rm -f #{@temp_outdir}/a4.bmp`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/a4.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), "#{@temp_outdir}/a4.bmp")
+    end
+    `rm -f #{@temp_outdir}/36bit.bmp`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/36bit.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), "#{@temp_outdir}/36bit.bmp")
+      # `open /tmp/36bit.sgi`
+    end
+  end
+
+  def test_dump_sgi36
+    Wiretap.dump_image_format = :sgi
+    `rm -f #{@temp_outdir}/a4.sgi`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/a4.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), "#{@temp_outdir}/a4.sgi")
+    end
+    `rm -f #{@temp_outdir}/36bit.sgi`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/36bit.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 36, f.read(@width*@height*9/2), "#{@temp_outdir}/36bit.sgi")
+      # `open /tmp/36bit.sgi`
+    end
+  end
+
+  def test_dump_bmp32
+    Wiretap.dump_image_format = :bmp
+    `rm -f #{@temp_outdir}/32bit.bmp`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/32bit.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 32, f.read(@width*@height*9/2), "#{@temp_outdir}/32bit.bmp")
+      # `open /tmp/32bit.sgi`
+    end
+  end
+  def test_dump_sgi32
+    Wiretap.dump_image_format = :sgi
+    `rm -f #{@temp_outdir}/32bit.sgi`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/32bit.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 32, f.read(@width*@height*9/2), "#{@temp_outdir}/32bit.sgi")
+      # `open /tmp/32bit.sgi`
+    end
+  end
+  
+  def test_dump_sgi48
+    Wiretap.dump_image_format = :sgi
+    `rm -f #{@temp_outdir}/48bit.sgi`
+    File.open(File.dirname(__FILE__) + "/wiretap-images/48bit.stoneimage") do |f|
+      Wiretap.dump_image_data(@width, @height, 48, f.read(@width*@height*6), "#{@temp_outdir}/48bit.sgi")
+      # `open #{@temp_outdir}/48bit.sgi`
+    end
+    
+  end
+  
+  def test_ppm_format
+    assert @format = Wiretap::PPM::format(File.dirname(__FILE__) + "/wiretap-images/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::PPM.to_sgi(File.dirname(__FILE__) + "/wiretap-images/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
+end