wiretap 0.1

data/ext/nodemetadata.cpp

@@ -0,0 +1,90 @@
+#include "wiretap.h"
+
+
+
+/*
+ * Get count of node metadata entries
+ */
+static VALUE wiretap_node_metadata_count(VALUE self) {
+	WireTapNodeHandle* node;
+	int num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->getNumAvailableMetaDataStreams(num));
+	return INT2FIX(num);
+}
+
+/*
+ * Get metadata by index
+ */
+static VALUE wiretap_node_metadata_get_at(int argc, VALUE *argv, VALUE self) {
+	WireTapNodeHandle* node;
+	VALUE stream_name, filter, depth;
+    
+	rb_scan_args(argc, argv, "12", &stream_name, &filter, &depth);
+	Check_Type(stream_name, T_STRING);
+	if(filter != Qnil) {
+		Check_Type(filter, T_STRING);
+	}
+	if(depth != Qnil) {
+		Check_Type(depth, T_FIXNUM);
+	}
+	
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	WireTapStr data;
+	NODERUN_E(node, node->getMetaData(CSTR(stream_name), filter == Qnil ? "all" : CSAFESTR(filter), depth == Qnil ? 0 : FIX2INT(depth), data));
+	
+	return wiretap_to_str(data);
+}
+
+/*
+ * Set metadata at index
+ */
+static VALUE wiretap_node_metadata_set_at(VALUE self, VALUE index, VALUE value) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	Check_Type(index, T_STRING);
+	Check_Type(value, T_STRING);
+
+	NODERUN_E(node, node->setMetaData(CSTR(index), WireTapStr(CSTR(value))));
+	return self;
+}
+
+/*
+ * eval block on each metadata entry
+ */
+static VALUE wiretap_node_metadata_each(VALUE self) {
+	WireTapNodeHandle* node;
+	int i, num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->getNumAvailableMetaDataStreams(num));
+
+	for(i = 0; i < num; i++) {
+		WireTapStr stream;
+		NODERUN_E(node, node->getAvailableMetaDataStream(i, stream));
+		
+		WireTapStr data;
+		NODERUN_E(node, node->getMetaData(stream.c_str(), "all", -1, data));
+		rb_yield(rb_ary_new3(2, wiretap_to_str(stream), wiretap_to_str(data)));
+	}
+	return self;
+}
+
+/*
+ * Access to metadata directly.
+ */
+static VALUE wiretap_node_metadata_body(VALUE self) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	return Qnil;
+}
+
+void Init_metadata() {
+	
+	cNodeMetaData = rb_define_class_under(mWiretap, "NodeMetaData", rb_cObject);
+	rb_define_method(cNodeMetaData, "count", VALUEFUNC(wiretap_node_metadata_count), 0);
+	rb_define_method(cNodeMetaData, "[]", VALUEFUNC(wiretap_node_metadata_get_at), -1);
+	rb_define_method(cNodeMetaData, "[]=", VALUEFUNC(wiretap_node_metadata_set_at), 2);
+	rb_define_method(cNodeMetaData, "each", VALUEFUNC(wiretap_node_metadata_each), 0);
+}
+

data/ext/ppm.cpp

@@ -0,0 +1,132 @@
+#include "wiretap.h"
+
+
+
+static int extract_int(FILE* f) {
+	char buffer[256];
+	int pos = 0;
+	char c;
+	while(!feof(f)) {
+		c = fgetc(f);
+		if(!isalnum(c)) {
+			break;
+		}
+		buffer[pos++] = c;
+	}
+	buffer[pos] = '\0';
+	return atoi(buffer);
+}
+
+bool ppm_read_format(FILE* f, WireTapClipFormat* format) {
+	extract_int(f);
+	
+	int width = extract_int(f);
+	if(format) {
+		format->setWidth(width);
+	}
+	
+	int height = extract_int(f);
+	if(format) {
+		format->setHeight(height);
+	}
+	
+	int maxval = extract_int(f);
+	if(maxval > 255) {
+		THROW("Decoding 16bit PPM files is not supported");
+	}
+	
+	if(format) {
+		format->setBitsPerPixel(24);
+		format->setNumChannels(3);
+		format->setFrameBufferSize((format->bitsPerPixel()/8)*width*height);
+		format->setFrameRate(25);
+		WireTapClipFormat::ScanFormat scan_format = format->strToScanFormat("progressive");
+		format->setScanFormat(scan_format);
+		format->setFormatTag("rgb");
+		format->setMetaDataTag("IFFFS_XML");
+		format->setMetaData("<IFFFS_XML Version=\"1.0\"><ClipData></ClipData></IFFFS_XML>");
+	}
+	
+	return true;
+}
+
+
+bool ppm_read_image(FILE* f, unsigned char* frame, int width, int height, int bpp) {
+	size_t row_size = width*3;
+  
+	for(int i = 0; i < height; i++) {
+		size_t read_bytes = fread(frame + (height - 1 - i)*row_size, 1, row_size, f);
+		if(read_bytes != row_size) {
+			rb_warn("Read %d bytes, expected %d. Step: %d", read_bytes, row_size, i);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+/*
+ * Extract Wiretap clip format from PPM file. The format will inherit the bit depths of the image and allocate
+ * the framebuffer size into which the imported image will fit
+ *
+ *      @clipformat = Wiretap::PPM.format("test/wiretap-images/01.ppm")
+ */
+static VALUE wiretap_get_ppm_format(VALUE self, VALUE input) {
+
+	FILE* infile = fopen(CSTR(input), "r");
+	if(!infile) {
+		THROW("Couldn't open file %s for reading", CSTR(input));
+	}
+	WireTapClipFormat format;
+	if(!ppm_read_format(infile, &format)) {
+		fclose(infile);
+		return Qfalse;
+	}
+	fclose(infile);
+	VALUE clip_format = rb_funcall(cClipFormat, rb_intern("new"), 0);
+	DATA_PTR(clip_format) = new WireTapClipFormat(format);
+	return clip_format;
+}
+
+/*
+ * Convert a PPM file to an SGI file
+ *
+ *     Wiretap::PPM.to_sgi("test/wiretap-images/01.ppm", "/tmp/a.sgi")
+ */
+static VALUE wiretap_convert_ppm_to_sgi(VALUE self, VALUE input, VALUE output) {
+	Check_Type(input, T_STRING);
+	Check_Type(output, T_STRING);
+	FILE* infile = fopen(CSTR(input), "r");
+	if(!infile) {
+		THROW("Couldn't open file %s for read", CSTR(input));
+	}
+	WireTapClipFormat format;
+	if(!ppm_read_format(infile, &format)) {
+		fclose(infile);
+		rb_warn("Couldn't read PPM format from file %s", CSTR(input));
+		return Qfalse;
+	}
+	
+	unsigned char frame[format.frameBufferSize()];
+	if(!ppm_read_image(infile, frame, format.width(), format.height(), format.bitsPerPixel())) {
+		fclose(infile);
+		rb_warn("Couldn't read PPM image data from file %s", CSTR(input));
+		return Qfalse;
+	}
+	fclose(infile);
+
+	if(!wiretap_write_image_frame(format.width(), format.height(), format.bitsPerPixel(), frame, CSTR(output))) {
+		rb_warn("Couldn't dump image to file %s", CSTR(output));
+		return Qfalse;
+	}
+	return Qtrue;
+}
+
+
+void Init_ppm() {
+	mPPM = rb_define_module_under(mWiretap, "PPM");
+
+	rb_define_singleton_method(mPPM, "to_sgi", VALUEFUNC(wiretap_convert_ppm_to_sgi), 2);
+	rb_define_singleton_method(mPPM, "format", VALUEFUNC(wiretap_get_ppm_format), 1);
+}

data/ext/server.cpp

@@ -0,0 +1,202 @@
+#include "wiretap.h"
+
+#define Safe_Get_Server(obj, server) do { \
+	Data_Get_Struct(obj, WireTapServerHandle, server); \
+	if(!server) { \
+		rb_warn("Connection to server is already closed on %s: %d", __FILE__, __LINE__); \
+		return Qnil; \
+	} \
+} while(0)
+
+static void wiretap_server_free(WireTapServerHandle* server) {
+	if(server) {
+		if(server->ping()) {
+			server->stop();
+		}
+		delete server;
+	}
+}
+
+/* 
+ * If destruction of server interface is required, call close on it to be sure,
+ * that server has been closed right now.
+ *
+ */
+static VALUE wiretap_server_close(VALUE self) {
+	rb_funcall(self, rb_intern("stop!"), 0);
+
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	delete server;
+	DATA_PTR(self) = 0;
+	return Qtrue;
+}
+
+static VALUE wiretap_server_allocate(VALUE klass) {
+	return Data_Wrap_Struct(klass, 0, wiretap_server_free, 0);
+}
+
+/*
+ * Use Server.new(hostname) to connect to specified server.
+ * This method opens server by it's hostname. Not by id.
+ */
+static VALUE wiretap_server_connect(VALUE self, VALUE hostname) {
+	Check_Type(hostname, T_STRING);
+	Check_Type(self, T_DATA);
+
+	DATA_PTR(self) = new WireTapServerHandle(CSTR(hostname));
+	return self;
+}
+
+/*
+ * Get hostname of server, to which connection is established.
+ */
+static VALUE wiretap_server_hostname(VALUE self) {
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	return rb_str_new2(server->getHostName());
+}
+
+
+/*
+ * Get root node of server
+ */
+static VALUE wiretap_server_root(VALUE self) {
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+
+	WireTapNodeHandle root_node;
+	SERVERRUN_E(server, server->getRootNode(root_node));
+
+	return wiretap_node_create_with(root_node, self, Qnil);
+}
+
+/*
+ * Open node by id
+ */
+static VALUE wiretap_server_open_node(VALUE self, VALUE id) {
+	Check_Type(id, T_STRING);
+
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+
+	WireTapNodeHandle node(*server, CSTR(id));
+	return wiretap_node_create_with(node, self, Qnil);
+}
+
+
+/*
+ * Get vendor of server
+ */
+static VALUE wiretap_server_vendor(VALUE self) {
+	WireTapStr str;
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	RUN_E(server->getVendor(str), server);
+	return wiretap_to_str(str);
+}
+
+/*
+ * Get product name, installed on server
+ */
+static VALUE wiretap_server_product(VALUE self) {
+	WireTapStr str;
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	RUN_E(server->getProduct(str), server);
+	return wiretap_to_str(str);
+}
+
+/*
+ * Get version of server
+ */
+static VALUE wiretap_server_version(VALUE self) {
+	int major, minor;
+	char buf[256];
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	RUN_E(server->getVersion(major, minor), server);
+	snprintf(buf, sizeof(buf), "%d.%d", major, minor);
+	return rb_str_new2(buf);
+}
+
+/*
+ * Get ID of server storage
+ */
+static VALUE wiretap_server_storage(VALUE self) {
+	WireTapStr str;
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	RUN_E(server->getStorageId(str), server);
+	return wiretap_to_str(str);
+}
+
+/*
+ * Get version of server protocol.  major.minor
+ */
+static VALUE wiretap_server_protocol(VALUE self) {
+	int major, minor;
+	char buf[256];
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	RUN_E(server->getProtocolVersion(major, minor), server);
+	snprintf(buf, sizeof(buf), "%d.%d", major, minor);
+	return rb_str_new2(buf);
+}
+
+/*
+ * Check, whether connection to server is still alive
+ */
+static VALUE wiretap_server_is_alive(VALUE self) {
+	WireTapServerHandle* server;
+	Data_Get_Struct(self, WireTapServerHandle, server);
+	if(!server) {
+		return Qfalse;
+	}
+	return server->ping() ? Qtrue : Qfalse;
+}
+
+
+/*
+ * Theoretically, it is possible to stop continious operation on server
+ * from other thread. Practically, it is impossible unless ruby gets threads
+ */
+static VALUE wiretap_server_stop(VALUE self) {
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	if(server->ping()) {
+		server->stop();
+	}
+	return self;
+}
+
+/*
+ * Get message, explaining last error, occured on server
+ */
+static VALUE wiretap_server_last_error(VALUE self) {
+	WireTapServerHandle* server;
+	Safe_Get_Server(self, server);
+	return rb_str_new2(server->lastError());
+}
+
+#define READER(name) rb_define_method(cServer, #name, VALUEFUNC(wiretap_server_ ## name), 0);
+
+void Init_server() {
+	cServer = rb_define_class_under(mWiretap, "Server", rb_cObject);
+	rb_define_alloc_func(cServer, wiretap_server_allocate);
+	rb_define_method(cServer, "initialize", VALUEFUNC(wiretap_server_connect), 1);
+    rb_define_method(cServer, "hostname", VALUEFUNC(wiretap_server_hostname), 0);;
+    rb_define_method(cServer, "root", VALUEFUNC(wiretap_server_root), 0);;
+    rb_define_method(cServer, "vendor", VALUEFUNC(wiretap_server_vendor), 0);;
+    rb_define_method(cServer, "product", VALUEFUNC(wiretap_server_product), 0);;
+    rb_define_method(cServer, "version", VALUEFUNC(wiretap_server_version), 0);;
+    rb_define_method(cServer, "storage", VALUEFUNC(wiretap_server_storage), 0);;
+    rb_define_method(cServer, "protocol", VALUEFUNC(wiretap_server_protocol), 0);;
+    rb_define_method(cServer, "last_error", VALUEFUNC(wiretap_server_last_error), 0);;
+	rb_define_method(cServer, "alive?", VALUEFUNC(wiretap_server_is_alive), 0);
+	rb_define_method(cServer, "stop!", VALUEFUNC(wiretap_server_stop), 0);
+	rb_define_method(cServer, "open", VALUEFUNC(wiretap_server_open_node), 1);
+	rb_define_method(cServer, "close!", VALUEFUNC(wiretap_server_close), 0);
+}
+
+#undef READER

data/ext/serverlist.cpp

@@ -0,0 +1,183 @@
+#include "wiretap.h"
+
+static void wiretap_server_info_free(WireTapServerList::ServerInfo* server_info) {
+	delete server_info;
+}
+
+
+static VALUE wiretap_server_info_create(WireTapServerList::ServerInfo & info) {
+	WireTapServerList::ServerInfo *server_info = new WireTapServerList::ServerInfo(info);
+	return Data_Wrap_Struct(cServerInfo, 0, wiretap_server_info_free, server_info);
+}
+
+/*
+ * Extract hostname from server information
+ */
+static VALUE wiretap_server_info_hostname(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	return rb_str_new2(server_info->getHostname());
+}
+
+/*
+ * Extract version of server from server information
+ */
+static VALUE wiretap_server_info_version(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	int major = server_info->getVersionMajor();
+	int minor = server_info->getVersionMinor();
+	char buf[256];
+	snprintf(buf, sizeof(buf), "%d.%d", major, minor);
+	return rb_str_new2(buf);
+}
+
+/*
+ * Extract product name from server information
+ */
+static VALUE wiretap_server_info_product(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	return rb_str_new2(server_info->getProduct());
+}
+
+/*
+ * Extract vendor name from server information
+ */
+static VALUE wiretap_server_info_vendor(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	return rb_str_new2(server_info->getVendor());
+}
+
+/*
+ * Extract product version from server information
+ */
+static VALUE wiretap_server_info_product_version(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	int major = server_info->getProductVersionMajor();
+	int minor = server_info->getProductVersionMinor();
+	char buf[256];
+	snprintf(buf, sizeof(buf), "%d.%d", major, minor);
+	return rb_str_new2(buf);
+}
+
+/*
+ * Extract storage ID from server information
+ */
+static VALUE wiretap_server_info_storage(VALUE self) {
+	WireTapServerList::ServerInfo* server_info;
+	Data_Get_Struct(self, WireTapServerList::ServerInfo, server_info);
+	const char* storage_id = server_info->getStorageId();
+	if(!storage_id) {
+		rb_raise(eError, "Problem in wiretap. File: %s: %d", __FILE__, __LINE__);
+	}
+	return rb_str_new2(storage_id);
+}
+
+/*
+ * Connect to server, described in this information.
+ */
+static VALUE wiretap_server_info_server(VALUE self) {
+	VALUE hostname = rb_funcall(self, rb_intern("hostname"), 0);
+	return rb_funcall(cServer, rb_intern("new"), 1, hostname);
+}
+
+static void wiretap_server_list_free(WireTapServerList* server_list) {
+	delete server_list;
+}
+
+
+static VALUE wiretap_server_list_s_allocate(VALUE klass) {
+	WireTapServerList *server_list = new WireTapServerList();
+	return Data_Wrap_Struct(klass, 0, wiretap_server_list_free, server_list);
+}
+
+/*
+ * Server list doesn't require any params for initialization
+ */
+static VALUE wiretap_server_list_initialize(VALUE self) {
+	return self;
+}
+
+/*
+ * resolve server by it's storage ID
+ */
+static VALUE wiretap_server_list_resolve(VALUE self, VALUE storage) {
+	WireTapServerList* server_list;
+	Data_Get_Struct(self, WireTapServerList, server_list);
+
+	WireTapServerId host;
+	RUN_E(server_list->resolveStorageId(CSTR(storage), host), server_list);
+	return Qnil;
+	//return wiretap_to_str(host);
+}
+
+/*
+ * Number of available servers
+ */
+static VALUE wiretap_server_list_count(VALUE self) {
+	WireTapServerList* server_list;
+	Data_Get_Struct(self, WireTapServerList, server_list);
+
+	int num = 0;
+	//RUN_E(server_list->getNumNodes(num), server_list);
+	if(!server_list->getNumNodes(num)) {
+		rb_warn("Problem in wiretap: %s. File: %s: %d", server_list->lastError(), __FILE__, __LINE__);
+	}
+	return INT2FIX(num);
+}
+
+/*
+ * Get server by it's index
+ */
+static VALUE wiretap_server_list_get_at(VALUE self, VALUE index) {
+	WireTapServerList* server_list;
+	Data_Get_Struct(self, WireTapServerList, server_list);
+
+	WireTapServerList::ServerInfo node;
+	RUN_E(server_list->getNode(FIX2INT(index), node), server_list);
+  return wiretap_server_info_create(node);; 
+}
+
+/*
+ * Eval block on each server
+ */
+static VALUE wiretap_server_list_each(VALUE self) {
+	WireTapServerList* server_list;
+	Data_Get_Struct(self, WireTapServerList, server_list);
+
+	int num;
+	
+	RUN_E(server_list->getNumNodes(num), server_list);
+
+	for(int i = 0; i < num; i++) {
+		WireTapServerList::ServerInfo node;
+		RUN_E(server_list->getNode(i, node), server_list);
+	  rb_yield(wiretap_server_info_create(node));
+	}
+	return self;
+}
+
+
+void Init_serverlist() {
+	cServerList = rb_define_class_under(mWiretap, "ServerList", rb_cObject);
+	rb_define_alloc_func(cServerList, wiretap_server_list_s_allocate);
+	rb_define_method(cServerList, "initialize", VALUEFUNC(wiretap_server_list_initialize), 0);
+	rb_define_method(cServerList, "resolve", VALUEFUNC(wiretap_server_list_resolve), 1);
+	rb_define_method(cServerList, "length", VALUEFUNC(wiretap_server_list_count), 0);
+	rb_define_method(cServerList, "count", VALUEFUNC(wiretap_server_list_count), 0);
+	rb_define_method(cServerList, "[]", VALUEFUNC(wiretap_server_list_get_at), 1);
+	rb_define_method(cServerList, "each", VALUEFUNC(wiretap_server_list_each), 0);
+
+	cServerInfo = rb_define_class_under(mWiretap, "ServerInfo", rb_cObject);
+	rb_define_method(cServerInfo, "hostname", VALUEFUNC(wiretap_server_info_hostname), 0);
+	rb_define_method(cServerInfo, "version", VALUEFUNC(wiretap_server_info_version), 0);
+	rb_define_method(cServerInfo, "product", VALUEFUNC(wiretap_server_info_product), 0);
+	rb_define_method(cServerInfo, "vendor", VALUEFUNC(wiretap_server_info_vendor), 0);
+	rb_define_method(cServerInfo, "product_version", VALUEFUNC(wiretap_server_info_product_version), 0);
+	rb_define_method(cServerInfo, "storage", VALUEFUNC(wiretap_server_info_storage), 0);
+	rb_define_method(cServerInfo, "server", VALUEFUNC(wiretap_server_info_server), 0);
+}
+

data/ext/sgi.cpp

@@ -0,0 +1,69 @@
+#include "wiretap.h"
+
+
+static void write_channel(int width, int height, int number, unsigned char* frame, FILE* f) {
+	std::auto_ptr<unsigned char> buffer(new unsigned char[width*height]);
+	for(int i = 0; i < width*height; i++) {
+		buffer.get()[i] = frame[3*i + number];
+	}
+	fwrite(buffer.get(), width*height, 1, f);
+}
+
+static void write_int32_be_value(int value, bitstream_writer writer, void *data) {
+	writer(data, value >> 24& 0xFF);  
+	writer(data, value >> 16& 0xFF);  
+	writer(data, value >> 8 & 0xFF);  
+	writer(data, value >> 0 & 0xFF);  
+}
+static void write_int16_be_value(short value, bitstream_writer writer, void *data) {
+	writer(data, value >> 8 & 0xFF);  
+	writer(data, value >> 0 & 0xFF);  
+}
+
+static int wiretap_write_sgi_header(int width, int height, bitstream_writer writer, void *data) {
+	//const int header_size = 512;
+	const int header_padding = 404;
+	const int magic = 474;
+	
+	write_int16_be_value(magic, writer, data);  // Magic 474
+	writer(data, 0); // 0 for uncompressed
+	writer(data, 1); // 1 for 1 byte per channel. 24 bit picture
+	write_int16_be_value(3, writer, data); // 3 dimensions - one plain image with multiple channels
+	write_int16_be_value(width, writer, data); 
+	write_int16_be_value(height, writer, data); 
+	write_int16_be_value(3, writer, data); // 3 for RGB mode: 3 channels
+	write_int32_be_value(0, writer, data); // minimum pixel value
+	write_int32_be_value(0xFF, writer, data); // maximum pixel value
+	write_int32_be_value(0, writer, data); // dummy
+	
+	char image_name[80] = "Ruby wiretap encoded";
+	for(size_t i = 0; i < sizeof(image_name); i++) {
+		writer(data, image_name[i]);
+	}
+	
+	write_int32_be_value(0, writer, data); // colormap is in normal mode (0)
+	for(int i = 0; i < header_padding; i++) {
+		writer(data, 0);
+	}
+	return 0;
+}
+
+
+bool wiretap_write_frame_sgi(int width, int height, int bpp, unsigned char* frame, FILE* f) {
+	filestream stream;
+	memstream mem;
+	std::auto_ptr<unsigned char> buffer(new unsigned char[width*height*3]);
+	memset(&stream, 0, sizeof(stream));
+	memset(&mem, 0, sizeof(mem));
+	mem.ptr = buffer.get();
+	stream.f = f;
+
+	wiretap_write_sgi_header(width, height, write_to_file, (void *)&stream);
+	wiretap_write_image_data(width, height, bpp, frame, write_to_memory, (void *)&mem);	
+
+	write_channel(width, height, 0, buffer.get(), f);
+	write_channel(width, height, 1, buffer.get(), f);
+	write_channel(width, height, 2, buffer.get(), f);
+	return 0;
+}
+

data/ext/testserver/Makefile

@@ -0,0 +1,5 @@
+
+all: server.bundle
+
+server.bundle: server.cpp ../format.cpp
+	g++ ../format.cpp server.cpp -I../../../wiretap_api/api -L../../../wiretap_api/lib/dbg/MACOSX/fat/Darwin_8_3_0/GCC_4_0_1/ -lwiretapServerAPI -o server.bundle -I /opt/local/lib/ruby/1.8/i686-darwin8.8.3/ -lruby -g -dynamic -bundle -undefined suppress -flat_namespace