wiretap 0.1

data/LICENSE

@@ -0,0 +1,32 @@
+Copyright (c) 2006
+
+Hecticelectric BV, Amsterdam
+Max Lapshin
+Julian "Julik" Tarkhanov
+
+<tools@hecticelectric.nl>
+
+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 and merge the copies of the Software, and to permit 
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+a) The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+b) Portions of the Software produced by Autodesk Media&Entertainment might not be included with the copies
+or portions of the Software
+
+c) The images and sound files provided with the Software (test footage) might not be used for anything but
+testing the Software. Persons and organizations obtaining a copy of the Software do not retain the rights
+to use the provided footage for different purposes.
+
+d) Distribution (including commercial distribution) of the Software is possible only with explicit written permission
+of Hecticelectric BV, Amsterdam and Autodesk Media&Entertainment, outside of distribution methods supplied by the
+aforementioned parties.
+
+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/README

@@ -0,0 +1,93 @@
+=== Ruby bindings for Autodesk Wiretap
+
+These bindings allow you to access Wiretap-enabled Autodesk Media&Entertainment systems such as Flame, Flint and Smoke.
+To use the bindings with your Media system you will need the following:
+
+* Wire license
+* Wiretap daemon (should be installed and started separately on the machine to which the Stone storage devices are connected)
+
+=== Dependencies for clip output
+
+The bindings depend on the Wiretap SDK and ActiveSupport (available as part of Rails).
+
+It is possible to export video frames as .sgi images without any dependencies (clips will be exported as image sequences).
+
+However, if you need to export or import video or export and import audio you will need to have 
+additional libraries and binaries installed. These are used by the bindings to de/encode the graphics and sound.
+
+For video files:
+* mencoder + ffmpeg
+
+For sound files:
+* libsndfile
+
+=== Running the unit tests
+
+Define a RUBY_WIRETAP_TEST_HOST environment variable that will contain the hostname or IP address
+of your IFFS system. Make a PAL 720x576 8-bit project on the system and name it "RubyWiretapTest".
+
+Run rake.
+
+=== Building the bindings
+
+To build the bindings you will need the Wiretap SDK, distributed free of charge by Autodesk. Currently you also
+need to use GCC 3.3 to compile against the supplied libraries (GCC 4.0 will not work with current stable libraries,
+but it is required to build against new beta version).
+
+Please note that it's currently not possible to build the bindings on a Windows system. If You require to build them on
+Windows, contact authors. Supported build systems are Linux, MacOS (PowerPC only with current stable libraries) and 
+IRIX (although this configuration has not been tested yet).
+
+Additionally, Wiretap SDK will only run and link in Rosetta on Intel Macs (therefore your Ruby will also need to be PPC).
+(or You can try to use new beta version on Wiretap SDK)
+
+Build the bindings by issuing the following commands:
+
+  export WIRETAP_INSTALL_DIR=/usr/local/lib/wiretap
+  rake build
+  
+=== Simplistic examples
+
+Test a Wiretap connection:
+
+  require 'lib/wiretap'
+  server = Wiretap::Server.new("flame-01")
+  puts "Flame is running" if server.alive?
+
+Retrieve frame 22 from a clip as an SGI file:
+ 
+ require 'lib/wiretap'
+ clip = Wiretap::open('192.168.2.2/stonefs/SuperCommercial/Default/capture')
+ raise "It has to be a clip" unless clip.clip?
+ clip.frames.dump(22, '/tmp/frame22.sgi')
+
+See the documentation for more info on accessing Wiretap servers and nodes from your Ruby program.
+
+=== Sound and image output
+
+The bindings support decoding and encoding of all clip formats on Discreet framestores, inlcuding 8, 10 and 12bit video and
+standard 48khz audio. Both 12-bit packed (36bit per pixel) and 12-bit unpacked (48bit per pixel) variants are supported.
+Please note that when 10 or 12 bit video is extracted it's going to be upsampled to 16bit per channel
+as supported by .sgi image format. There are no formats that natively support 10bit or 12bit color (except for Cineon and
+DPX which are outside of the scope this extension).
+
+Sound is exported as AIFF files.
+
+=== Test footage
+
+The test footage used for the bindings is courtesy of HecticElectric BV, Amsterdam. The use of these clips for testing the bindings has been explicitly and exclusively allowed for this product only. You are not allowed to distribute or use the footage separately from the bindings or for purposes other than testing the software.
+
+=== Testing procedures
+
+On your Flame, Flint or Inferno system, create a new project on the framestore called "RubyWiretapTest". Make sure that it's 8-bit PAL 720x576 and that it has a "Default" library (it gets created for you automatically).
+
+If you are using Smoke, Fire, Backdraft or Backdraft Conform as Wiretap host and you want to test the bindings on it, you will need to have a top-level library called "RubyWiretapTest" and a project inside it called "Default".
+
+Then define the environment variable referring to your system and run the test suite:
+
+  export RUBY_WIRETAP_TEST_HOST=address_of_your_flame_system
+  rake
+
+During the test run the program will write frames and sound to this library. Authors hold no responsibility if other clips or materials on the framestore get lost or damaged during the operation.
+
+After that the media has been written to the framestore (which tests the write operations) the same media is going to be retrieved. If the dependencies are met, the images are going to be converted and output to the test directory - you will receive a number of graphics files and a sound file. Please analyze the output carefully to make sure clip output is working as advertized.

data/ext/Makefile

@@ -0,0 +1,146 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /opt/local/lib/ruby/1.8/i686-darwin8.8.3
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/opt/local
+exec_prefix = $(DESTDIR)/opt/local
+sitedir = $(prefix)/lib/ruby/site_ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+vendordir = $(prefix)/lib/ruby/vendor_ruby
+datadir = $(prefix)/share
+includedir = $(prefix)/include
+infodir = $(prefix)/info
+sysconfdir = $(prefix)/etc
+mandir = $(DESTDIR)/opt/local/share/man
+libdir = $(DESTDIR)/opt/local/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorarchdir = $(vendorlibdir)/$(vendorarch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(prefix)/var
+vendorlibdir = $(vendordir)/$(ruby_version)
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = g++ 
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -O -pipe -I/opt/local/include  -fno-common -pipe -fno-common -I../../wiretap_api//api -Wall 
+INCFLAGS = -I. -I. -I/opt/local/lib/ruby/1.8/i686-darwin8.8.3 -I.
+CPPFLAGS = -DHAVE_WIRETAPCLIENTAPI_H -DHAVE_SNDFILE_H -O -pipe -I/opt/local/include
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS = -L/opt/local/lib -L../../wiretap_api//lib/dbg/MACOSX/fat/Darwin_8_3_0/GCC_4_0_1/  
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i686-darwin8.8.3
+sitearch = i686-darwin8.8.3
+vendorarch = i686-darwin8.8.3
+ruby_version = 1.8
+ruby = /opt/local/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) -lwiretapClientAPI -lsndfile  -lpthread -ldl -lobjc  
+SRCS = audio_format.cpp bmp.cpp format.cpp image_format.cpp node.cpp nodechildren.cpp nodeframes.cpp nodemetadata.cpp ppm.cpp server.cpp serverlist.cpp sgi.cpp thread_worker.cpp wiretap.cpp
+OBJS = audio_format.o bmp.o format.o image_format.o node.o nodechildren.o nodeframes.o nodemetadata.o ppm.o server.o serverlist.o sgi.o thread_worker.o wiretap.o
+TARGET = wiretap_bin
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/audio_format.cpp

@@ -0,0 +1,224 @@
+#include "wiretap.h"
+#ifdef HAVE_SNDFILE_H
+#include <sndfile.h>
+
+typedef struct {
+	sf_count_t position;
+	sf_count_t size;
+	unsigned char* frame;
+} virtual_file;
+
+static sf_count_t v_get_filelen(void *user_data) {
+	virtual_file* vf = (virtual_file *)user_data;
+	return vf->size;
+}
+static sf_count_t v_seek(sf_count_t offset, int whence, void *user_data) {
+	virtual_file* vf = (virtual_file *)user_data;
+	switch(whence) {
+		case SEEK_SET:
+			if(offset > vf->size || offset < 0) {
+				return -1;
+			}
+			vf->position = offset;
+			return 0;
+		case SEEK_CUR:
+			if(offset > vf->size - vf->position || vf->position + offset < 0) {
+				return -1;
+			}
+			vf->position += offset;
+			return 0;
+		case SEEK_END:
+			if(offset > 0 || vf->size + offset < 0) {
+				return -1;
+			}
+			vf->position = vf->size + offset;
+			return 0;
+	}
+	return -1;
+}
+static sf_count_t v_read(void *ptr, sf_count_t count, void *user_data) {
+	virtual_file* vf = (virtual_file *)user_data;
+	if(count <= 0) {
+		return 0;
+	}
+	sf_count_t len = count;
+	if(count + vf->position > vf->size) {
+		len = vf->size - vf->position;
+	}
+	memcpy(ptr, vf->frame + vf->position, len);
+	vf->position += len;
+	return len;
+}
+static sf_count_t v_write(const void *ptr, sf_count_t count, void *user_data) {
+	return 0;
+}
+static sf_count_t v_tell(void *user_data) {
+	virtual_file* vf = (virtual_file *)user_data;
+	return vf->position;
+}
+
+static int detect_audio_format(ID type) {
+	ID dlaudio_float = rb_intern("dlaudio_float");
+	ID dlaudio_float_le = rb_intern("dlaudio_float_le");
+	ID dlaudio_int16 = rb_intern("dlaudio_int16");
+	ID dlaudio_int16_le = rb_intern("dlaudio_int16_le");
+	ID dlaudio_int24 = rb_intern("dlaudio_int24");
+	ID dlaudio_int24_le = rb_intern("dlaudio_int24_le");
+	ID dlaudio_wav = rb_intern("dlaudio_wav");
+	ID dlaudio_aiff = rb_intern("dlaudio_aiff");
+	
+	if(type == dlaudio_float) return  SF_FORMAT_RAW | SF_FORMAT_FLOAT;
+	if(type == dlaudio_float_le) return  SF_FORMAT_RAW | SF_FORMAT_FLOAT | SF_ENDIAN_LITTLE;
+	if(type == dlaudio_int16) return  SF_FORMAT_RAW | SF_FORMAT_PCM_16;
+	if(type == dlaudio_int16_le) return  SF_FORMAT_RAW | SF_FORMAT_PCM_16 | SF_ENDIAN_LITTLE;
+	if(type == dlaudio_int24) return  SF_FORMAT_RAW | SF_FORMAT_PCM_24;
+	if(type == dlaudio_int24_le) return  SF_FORMAT_RAW | SF_FORMAT_PCM_24 | SF_ENDIAN_LITTLE;
+	if(type == dlaudio_wav) return  SF_FORMAT_WAV | SF_FORMAT_PCM_24;
+	if(type == dlaudio_aiff) return  SF_FORMAT_AIFF | SF_FORMAT_PCM_24;
+	THROW("Couldn't detect type");
+	return 0;
+}
+
+int wiretap_write_audio_frame(int samples, int rate, int bps, ID type, unsigned char* frame, const char* filename) {
+	const char* error = 0;
+	virtual_file vf = {0, samples*bps/8, frame};
+	SF_VIRTUAL_IO v_io = {v_get_filelen, v_seek, v_read, v_write, v_tell};
+	
+	
+	SF_INFO info;
+	int item_count = samples;
+	info.frames = item_count;
+	info.samplerate = rate;
+	info.channels = 2;
+	info.format = detect_audio_format(type);
+	SNDFILE *input = sf_open_virtual(&v_io, SFM_READ, &info, &vf);
+
+	if(!input) {
+		THROW("Couldn't open frame for reading");
+	}
+
+	std::auto_ptr<float> output_items(new float[item_count]);
+	int size = sf_read_float(input, output_items.get(), item_count);
+	
+	if(size != item_count) { 
+		error = sf_strerror(input);
+	}
+	sf_close(input);
+	if(error) {
+		output_items.release();
+		THROW("Waited to read %d frames, got %d: %s", item_count, size, error);
+	}
+	
+	SF_INFO out_info = info;
+	out_info.format = SF_FORMAT_AIFF | SF_FORMAT_PCM_16;
+	if(!sf_format_check(&out_info)) {
+		output_items.release();
+		THROW("Invalid format provided for output file");
+	 }
+
+	SNDFILE *output = sf_open(filename, SFM_RDWR, &out_info);
+	if(!output) {
+		output_items.release();
+		THROW("Couldn't open file %s for write", filename);
+	}
+	int out_size = sf_write_float(output, output_items.get(), item_count);
+	output_items.release();
+	if(out_size != item_count)  {
+		error = sf_strerror(output);
+	}
+
+	sf_close(output);
+	if(error) {
+		THROW("Waited to write %d frames, got %d: %s", item_count, out_size, error);
+	}
+	
+	return 0;
+}
+
+
+static VALUE wiretap_dump_audio_data(VALUE self, VALUE samples, VALUE rate, VALUE bps, VALUE type, VALUE raw, VALUE filename) {
+	wiretap_write_audio_frame(NUM2INT(samples), NUM2INT(rb_funcall(rate, rb_intern("to_i"), 0)), NUM2INT(bps), SYM2ID(type), 
+	   (unsigned char* )STR(raw), CSTR(filename));
+	return Qtrue;
+}
+
+static VALUE wiretap_get_audio_format(VALUE self, VALUE filename) {
+	Check_Type(filename, T_STRING);
+	
+	SF_INFO sfinfo;
+	SNDFILE* snd = sf_open(CSTR(filename), SFM_READ, &sfinfo);
+	
+	WireTapAudioFormat audio_format;
+	audio_format.setNumSamples(sfinfo.frames);
+	audio_format.setBitsPerSample(16);
+	audio_format.setSampleRate(sfinfo.samplerate);
+	audio_format.setFrameBufferSize(2*sfinfo.frames);
+	audio_format.setFormatTag("dlaudio_int16_le");
+	sf_close(snd);
+	return Data_Wrap_Struct(cAudioFormat, 0, wiretap_format_free, new WireTapAudioFormat(audio_format));
+}
+
+static VALUE wiretap_audio_import_music(VALUE self, VALUE filename) {
+	Check_Type(filename, T_STRING);
+	
+	SF_INFO sfinfo;
+	SNDFILE* snd = sf_open(CSTR(filename), SFM_READ, &sfinfo);
+
+
+	std::auto_ptr<short> frame(new short[sfinfo.frames]);
+	sf_count_t read_frames = sf_read_short(snd, frame.get(), sfinfo.frames);
+	if(read_frames != sfinfo.frames) {
+		rb_warn("Waited to read %lld audio frames, got only %lld", sfinfo.frames, read_frames);
+		sf_close(snd);
+		return Qnil;
+	}
+	sf_close(snd);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->setNumFrames(1));
+	NODERUN_E(node, node->writeFrame(0, frame.get(), sfinfo.frames*2));
+	return self;
+}
+
+/* This is called on node. Not on NodeFrames */
+
+static VALUE wiretap_audio_dump(VALUE self, VALUE file) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	WireTapAudioFormat format;
+	RUN(node->getClipFormat(format));
+
+	int num;
+	NODERUN_E(node, node->getNumFrames(num));
+	if(num <= 0) {
+		rb_warn("No frames in the audio stream");
+		return Qnil;
+	}
+
+	std::auto_ptr<unsigned char> frame(new unsigned char[format.frameBufferSize() * num]);
+	for(int i = 0; i < num; i++) {
+		if(!node->readFrame(i, frame.get() + i*format.frameBufferSize(), format.frameBufferSize())) {
+			frame.release();
+			NODERUN_E(node, false);
+		}
+	}
+
+	wiretap_write_audio_frame(format.numSamples(), int(format.sampleRate()), 
+		format.bitsPerSample(), rb_intern(format.formatTag()), frame.get(), CSTR(file));
+	return self;
+}
+
+#endif /* HAVE_SNDFILE_H */
+
+
+void Init_audio_format() {
+#ifdef HAVE_SNDFILE_H
+	rb_define_singleton_method(mWiretap, "dump_audio_data", VALUEFUNC(wiretap_dump_audio_data), 6);	
+	rb_define_singleton_method(mWiretap, "audio_format", VALUEFUNC(wiretap_get_audio_format), 1);
+	
+	rb_define_method(cAudio, "import_music", VALUEFUNC(wiretap_audio_import_music), 1);
+	rb_define_method(cAudio, "dump", VALUEFUNC(wiretap_audio_dump), 1);
+#endif /* HAVE_SNDFILE_H */
+}

data/ext/bmp.cpp

@@ -0,0 +1,65 @@
+#include "wiretap.h"
+static void write_int32_le_value(int value, bitstream_writer writer, void *data) {
+	writer(data, value >> 0 & 0xFF);  
+	writer(data, value >> 8 & 0xFF);  
+	writer(data, value >> 16& 0xFF);  
+	writer(data, value >> 24& 0xFF);
+}
+
+static void write_int16_le_value(short value, bitstream_writer writer, void *data) {
+	writer(data, value >> 0 & 0xFF);  
+	writer(data, value >> 8 & 0xFF);  
+}
+
+void write_string_value(char* value, bitstream_writer writer, void *data) {
+	while(value && *value) {
+		writer(data, *value);
+		value++;
+	}
+}
+
+
+static int wiretap_write_bmp_header(int width, int height, bitstream_writer writer, void *data) {
+	const int header_size = 54;
+	int size = header_size + width * height * 3;
+	write_string_value("BM", writer, data); //  0,1 
+	write_int32_le_value(size, writer, data); // 2,3,4,5
+	write_int32_le_value(0, writer, data); // 6,7,8,9: reserved data
+	write_int32_le_value(header_size, writer, data); // 10,11,12,13: Image header ends.
+	write_int32_le_value(40, writer, data); // 14,15,16,17: Image information size
+	write_int32_le_value(width, writer, data); // 18,19,20,21: Width
+	write_int32_le_value(height, writer, data); // 22,23,24,25: Height
+	write_int16_le_value(1, writer, data); // 26,27: Number of color planes
+    write_int16_le_value(24, writer, data); // 28,29: Bits per pixel. We write only 24 bit images
+    write_int32_le_value(0, writer, data); // 30,31,32,33: Compression schema. None
+    write_int32_le_value(width*height*3, writer, data); // 34,35,36,37: raw data size. 3 bytes per pixel.
+	write_int32_le_value(2834, writer, data); // 38,39,40,41: horisontal resolution. Perhaprs 72 dpi. I don't know
+	write_int32_le_value(2834, writer, data); // 42,43,44,45: vertical resolution
+	write_int32_le_value(0, writer, data); // 46,47,48,49: number of colors
+	write_int32_le_value(0, writer, data); // 50,51,52,53: number of important colors
+	return 0;
+}
+
+
+
+bool wiretap_write_frame_bmp(int width, int height, int bpp, unsigned char* frame, FILE* f) {
+	filestream stream;
+	memset(&stream, 0, sizeof(stream));
+	stream.f = f;
+	
+	wiretap_write_bmp_header(width, height, write_to_file, (void *)&stream);
+	wiretap_write_image_data(width, height, bpp, frame, write_to_file_bgr, (void *)&stream);
+
+	return 0;
+}
+
+void write_to_file_bgr(void *stream, unsigned char channel) {
+	filestream* data = (filestream *)stream;
+	data->buffer[2 - data->count] = channel;
+	data->count++;
+	if(data->count == 3) {
+		fwrite(data->buffer, sizeof(data->buffer), 1, data->f);
+		data->count = 0;
+	}
+}
+

data/ext/extconf.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require "mkmf"
+require 'optparse'
+CONFIG["CPP"] = "g++ -E "
+CONFIG["CC"] = "g++ "
+CONFIG["LDSHARED"].gsub!(/^cc /,"g++ ")
+
+#@wiretap_placements = [ "../../wiretap_api", "/Code/wiretap-api"]
+@wiretap_placements = []
+
+@includes = []
+@libraries = []
+
+OptionParser.new do |opts|
+  opts.on("-S PATH", "--sndfile-dir=PATH", "Prefix, where libsndfile is installed: /usr/local or /opt/local") do |path|
+    @libraries << path + "/lib"
+    @includes << path + "/include"
+  end
+  opts.on("-W PATH", "--wiretap-dir=PATH", "Specify path to wiretap api placement: /Code/wiretap-api") do |path|
+    @wiretap_placements.unshift(path)
+  end
+  opts.parse!(ARGV.include?("--") ? ARGV[ARGV.index("--")+1..-1] : ARGV.clone)
+end
+
+def locations(suffix)
+  @wiretap_placements.map {|place| place + suffix}
+end
+
+def library_path
+	case PLATFORM
+		when /linux/
+			"LINUX/i686/RHEL4/GCC_3_4_4"
+		when /darwin/
+			"MACOSX/fat/Darwin_8_3_0/GCC_4_0_1/"
+	end
+end
+
+def old_library_path
+	case PLATFORM
+		when /linux/
+			"Linux/i686/RedHat/40/gcc_3.4.4/dbg/"
+		when /darwin/
+			"Mac/OSX/gcc_3.3/dbg"
+	end
+end
+
+def include_locations
+  locations("/api") + @includes
+end
+
+def library_locations
+  locations("/lib/dbg/"+library_path) + locations("/libs/"+old_library_path) + @libraries
+end
+
+def clear_locations(locations)
+  locations.reject {|location| !File.exists?(location)}
+end
+
+def include_flags
+  " "+(clear_locations(include_locations).map { |place| "-I"+place} + ["-Wall"]).join(" ")
+end
+def library_flags
+  " " + (clear_locations(library_locations) || []).map { |place| "-L"+place}.join(" ")
+end
+
+$CFLAGS << include_flags
+$LDFLAGS << library_flags
+
+have_header "WireTapClientAPI.h"
+unless have_header("sndfile.h") && have_library("sndfile")
+  puts "*********************"
+  puts "You don't have libsndfile installed. You can use wiretap ruby binding without it,"
+  puts "but You will not have support of audio."
+  puts "If You install libsndfile, reinstall gem after it."
+end
+have_library "wiretapClientAPI", "WireTapClientInit" do <<-SRC
+#include <WireTapClientAPI.h>
+int main(void) {
+	WireTapClientInit();
+}
+	SRC
+end
+create_makefile "wiretap_bin"
+