wiretap 0.1

data/ext/node.cpp

@@ -0,0 +1,401 @@
+#include "wiretap.h"
+
+
+static void node_free(WireTapNodeHandle* node) {
+	delete node;
+}
+
+static void node_leave(WireTapNodeHandle* node) { 
+}
+
+static VALUE node_detect_klass(WireTapNodeHandle* node) {
+	int type;
+	NODERUN_E(node, node->getNodeType(type));
+	switch(type) {
+		case IFFFS_WT_TYPE_NODE: {
+			return cNode;
+		}
+		case IFFFS_WT_TYPE_HOST: {
+			return cHost;
+		}
+		case IFFFS_WT_TYPE_VOLUME: {
+			return cVolume;
+		}
+		case IFFFS_WT_TYPE_PROJECT: {
+			return cProject;
+		}
+		case IFFFS_WT_TYPE_LIBRARY: {
+			return cLibrary;
+		}
+		case IFFFS_WT_TYPE_REEL: {
+			return cReel;
+		}
+		case IFFFS_WT_TYPE_CLIP:
+		case IFFFS_WT_TYPE_CLIP_HIRES:
+		case IFFFS_WT_TYPE_CLIP_LOWRES:
+		case IFFFS_WT_TYPE_CLIP_SLATE: {
+			return cClip;
+		}
+		case IFFFS_WT_TYPE_CLIP_AUDIO:
+		case IFFFS_WT_TYPE_CLIP_AUDIO_STREAM: {
+			return cAudio;
+		}
+		case IFFFS_WT_TYPE_USER:
+		case IFFFS_WT_TYPE_SETUP:
+		case IFFFS_WT_TYPE_USER_PREFERENCE: {
+		}
+	}
+	return cNode;
+}
+
+VALUE wiretap_node_create_with(WireTapNodeHandle& node, VALUE server, VALUE parent) {
+	WireTapNodeHandle* new_node = new WireTapNodeHandle(node);
+	
+	VALUE created_node = Data_Wrap_Struct(node_detect_klass(new_node), 0, node_free, new_node);
+	rb_iv_set(created_node, "@server", server);
+	rb_iv_set(created_node, "@parent", parent);
+	return created_node;
+}
+
+
+static VALUE wiretap_node_allocate(VALUE klass) {
+	WireTapNodeHandle* new_node = new WireTapNodeHandle();
+	return Data_Wrap_Struct(klass, 0, node_free, new_node);
+}
+
+static VALUE wiretap_node_get_id(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	return rb_str_new2(node->getNodeId().id());
+}
+
+static VALUE wiretap_node_set_id(VALUE self, VALUE id) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Check_Type(id, T_STRING);
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+//	node->setNodeId(WireTapNodeId(STR(id)));
+	return self;
+}
+
+static VALUE wiretap_node_reload(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	WireTapNodeId id = node->getNodeId();
+	WireTapServerHandle server = node->getServer();
+	delete node;
+	*((WireTapNodeHandle **)&(RDATA(self)->data)) = new WireTapNodeHandle(server, id.id());
+	return self;
+}
+
+static VALUE wiretap_node_find(VALUE self, VALUE path) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Check_Type(path, T_STRING);
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+
+	if(LEN(path) == 0) {
+		return self;
+	}
+	WireTapNodeHandle child;
+	if(!WireTapFindChild(*node, CSTR(path), child)) {
+		if(!node->lastError() || !*node->lastError()) {
+			return Qnil;
+		}
+		rb_raise(eError, "Problem while looking for child '%s': %s", CSTR(path), node->lastError());
+	}
+
+	return wiretap_node_create_with(child, rb_iv_get(self, "@server"), self);
+}
+
+
+static VALUE wiretap_clip_import_directory(VALUE self, VALUE dir_name) {
+	Check_Node_Alive(self);
+	
+	Check_Type(dir_name, T_STRING);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	int count = 0;
+	struct stat sb;
+	/*
+	 * Mplayer decoding video always start writing frame from 00000001.ppm
+	 */
+	for(int i = 1;; i++) {
+		char filename[PATH_MAX];
+		snprintf(filename, sizeof(filename), "%s/%08d.ppm", STR(dir_name), i);
+		if(stat(filename, &sb) != 0) {
+			break;
+		}
+		count = i;
+	}
+	
+	if(count <= 0) {
+		return Qnil;
+	}
+	
+
+	NODERUN_E(node, node->setNumFrames(count));
+	WireTapClipFormat format;
+	NODERUN_E(node, node->getClipFormat(format));	
+	unsigned char frame[format.frameBufferSize()];
+
+  /** TODO - refactor to use write_frame **/
+
+	for(int i = 0; i < count; i++) {
+		char filename[PATH_MAX];
+		snprintf(filename, sizeof(filename), "%s/%08d.ppm", STR(dir_name), i+1);
+		//rb_warn("Opening file %s", filename);
+
+
+		FILE* infile = fopen(filename, "r");
+		if(!infile) {
+			THROW("Couldn't open file %s for read", filename);
+		}
+		
+		if(!ppm_read_format(infile, NULL)) {
+			fclose(infile);
+			THROW("Couldn't read PPM format from file %s", filename);
+		}
+
+		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", filename);
+			return Qnil;
+		}
+		fclose(infile);
+		
+		NODERUN_E(node, node->writeFrame(i, frame, sizeof(frame)));
+	}
+	return self;
+}
+
+static VALUE wiretap_node_get_type(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	WireTapStr type;
+	NODERUN_E(node, node->getNodeTypeStr(type));
+	return wiretap_to_str(type);
+}
+
+static VALUE wiretap_node_get_name(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	WireTapStr name;
+	NODERUN_E(node, node->getDisplayName(name));
+	return wiretap_to_str(name);
+}
+
+
+static VALUE wiretap_node_create_node(int argc, VALUE* argv, VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE display_name, extended_type;
+
+	rb_scan_args(argc, argv, "11", &display_name, &extended_type);
+	Check_Type(display_name, T_STRING);
+	WireTapNodeHandle node_return;
+	
+	if(extended_type == Qnil) {
+		extended_type = INT2FIX(0);
+	}
+	switch(TYPE(extended_type)) {
+		case T_FIXNUM:
+			NODERUN_E(node, node->createNode(CSTR(display_name), NUM2INT(extended_type), node_return));
+			break;
+		case T_STRING:
+			NODERUN_E(node, node->createNode(CSTR(display_name), CSTR(extended_type), node_return));
+			break;
+		default:
+			rb_raise(rb_eArgError, "extended type must be integer or string");
+	}
+	
+	return wiretap_node_create_with(node_return, rb_iv_get(self, "@server"), self);
+}
+
+
+static VALUE wiretap_node_create_clip(int argc, VALUE* argv, VALUE self) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE display_name, extended_type, format;
+	
+	Check_Node_Alive(self);
+
+	rb_scan_args(argc, argv, "12", &display_name, &extended_type, &format);
+	Check_Type(display_name, T_STRING);
+	WireTapNodeHandle node_return;
+
+	if(extended_type == Qnil) {
+		extended_type = INT2FIX(0);
+	}
+	if(format == Qnil) {
+		format = rb_funcall(self, rb_intern("format"), 0);
+	}
+	
+	WireTapClipFormat *f;
+	Data_Get_Struct(format, WireTapClipFormat, f);
+	
+	switch(TYPE(extended_type)) {
+		case T_FIXNUM:
+			NODERUN_E(node, node->createClipNode(CSTR(display_name), *f, NUM2INT(extended_type), node_return));
+			break;
+		case T_STRING:
+			NODERUN_E(node, node->createClipNode(CSTR(display_name), *f, CSTR(extended_type), node_return));
+			break;
+		default:
+			rb_raise(rb_eArgError, "extended type must be integer or string");
+	}
+
+	return wiretap_node_create_with(node_return, rb_iv_get(self, "@server"), self);
+}
+
+
+static VALUE wiretap_node_destroy(VALUE self) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->destroyNode());
+	rb_iv_set(self, "@destroyed", Qtrue);
+	return Qtrue;
+}
+
+
+
+/*
+ * Extract metadata from node
+ *     @node.metadata
+ */
+static VALUE wiretap_node_metadata(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE metadata = Data_Wrap_Struct(cNodeMetaData, 0, node_leave, node);
+	rb_iv_set(metadata, "@node", self);
+
+  /*
+    WireTapStr metaDataBody; <--- !
+    node->getMetaData(streamName, filter, depth)
+    plainly speaking - somehow this has to happen, all that schtuff
+  */
+
+	return metadata;
+}
+
+
+
+static VALUE wiretap_clip_format(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	WireTapClipFormat format;
+	NODERUN_E(node, node->getClipFormat(format));
+	VALUE clipformat = Data_Wrap_Struct(cClipFormat, 0, wiretap_format_free, new WireTapClipFormat(format));
+	rb_iv_set(clipformat, "@node", self);
+	return clipformat;
+}
+
+
+static VALUE wiretap_audio_format(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	WireTapAudioFormat audio_format;
+	NODERUN_E(node, node->getClipFormat(audio_format));
+	VALUE audioformat = Data_Wrap_Struct(cAudioFormat, 0, wiretap_format_free, new WireTapAudioFormat(audio_format));
+	rb_iv_set(audioformat, "@node", self);
+	return audioformat;
+}
+
+
+static VALUE wiretap_clip_frames(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE frames = Data_Wrap_Struct(cNodeFrames, 0, node_leave, node);
+	rb_iv_set(frames, "@node", self);
+	return frames;
+}
+
+
+static VALUE wiretap_audio_frames(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE audioframes = Data_Wrap_Struct(cAudioFrames, 0, node_leave, node);
+	rb_iv_set(audioframes, "@node", self);
+	return audioframes;
+}
+
+
+
+
+void Init_node() {
+
+	cNode = rb_define_class_under(mWiretap, "Node", rb_cObject);
+	cClip = rb_define_class_under(mWiretap, "Clip", cNode);
+	cAudio = rb_define_class_under(mWiretap, "Audio", cNode);
+	cReel = rb_define_class_under(mWiretap, "Reel", cNode);
+	cLibrary = rb_define_class_under(mWiretap, "Library", cNode);
+	cProject = rb_define_class_under(mWiretap, "Project", cNode);
+	cVolume = rb_define_class_under(mWiretap, "Volume", cNode);
+	cHost = rb_define_class_under(mWiretap, "Host", cNode);
+
+	rb_define_alloc_func(cNode, wiretap_node_allocate);
+	rb_define_method(cNode, "id", VALUEFUNC(wiretap_node_get_id), 0);
+	rb_define_method(cNode, "id=", VALUEFUNC(wiretap_node_set_id), 1);
+	rb_define_method(cNode, "reload", VALUEFUNC(wiretap_node_reload), 0);
+
+	rb_define_method(cNode, "metadata", VALUEFUNC(wiretap_node_metadata), 0);
+
+	rb_define_method(cClip, "format", VALUEFUNC(wiretap_clip_format), 0);
+	rb_define_method(cAudio, "format", VALUEFUNC(wiretap_audio_format), 0);
+	rb_define_method(cClip, "frames", VALUEFUNC(wiretap_clip_frames), 0);
+	rb_define_method(cAudio, "frames", VALUEFUNC(wiretap_audio_frames), 0);
+	
+
+
+	rb_define_method(cNode, "host?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "volume?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "project?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "library?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "reel?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "clip?", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cNode, "audio?", VALUEFUNC(wiretap_false), -1);
+
+	rb_define_method(cHost,    "host?",    VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cVolume,  "volume?",  VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cProject, "project?", VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cLibrary, "library?", VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cReel,    "reel?",    VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cClip,    "clip?",    VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cAudio,   "clip?",    VALUEFUNC(wiretap_true), -1);
+	rb_define_method(cAudio,   "audio?",   VALUEFUNC(wiretap_true), -1);
+	
+
+	rb_define_method(cNode, "find_child", VALUEFUNC(wiretap_node_find), 1);
+	rb_define_method(cNode, "type", VALUEFUNC(wiretap_node_get_type), 0);
+	rb_define_method(cNode, "name", VALUEFUNC(wiretap_node_get_name), 0);
+	
+	rb_define_method(cClip, "import_directory", VALUEFUNC(wiretap_clip_import_directory), 1);
+	rb_define_protected_method(cNode, "create_node", VALUEFUNC(wiretap_node_create_node), -1);
+	rb_define_protected_method(cNode, "create_clip", VALUEFUNC(wiretap_node_create_clip), -1);
+	
+	rb_define_method(cNode, "destroy!", VALUEFUNC(wiretap_node_destroy), 0);
+}

data/ext/nodechildren.cpp

@@ -0,0 +1,67 @@
+#include "wiretap.h"
+
+
+static void wiretap_node_children_free(WireTapNodeHandle* node) {
+}
+
+
+static VALUE wiretap_node_children_count(VALUE self) {
+	WireTapNodeHandle* node;
+	int num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	RUN(node->getNumChildren(num));
+	return INT2FIX(num);
+}
+
+static VALUE wiretap_node_children_get_at(VALUE self, VALUE index) {
+	WireTapNodeHandle* node;
+	Check_Type(index, T_FIXNUM);
+	
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	WireTapNodeHandle child;
+	RUN(node->getChild(FIX2INT(index), child));
+	
+	return wiretap_node_create_with(child, rb_iv_get(self, "@server"), rb_iv_get(self, "@node"));
+}
+
+static VALUE wiretap_node_children_each(VALUE self) {
+	WireTapNodeHandle* node;
+	int i, num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	RUN(node->getNumChildren(num));
+	VALUE server = rb_iv_get(self, "@server");
+	VALUE parent = rb_iv_get(self, "@node");
+
+	for(i = 0; i < num; i++) {
+		WireTapNodeHandle child;
+		RUN(node->getChild(i, child));
+		rb_yield(wiretap_node_create_with(child, server, parent));
+	}
+	return self;
+}
+
+
+static VALUE wiretap_node_children(VALUE self) {
+	Check_Node_Alive(self);
+	
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	VALUE children = Data_Wrap_Struct(cNodeChildren, 0, wiretap_node_children_free, node);
+	rb_iv_set(children, "@node", self);
+	rb_iv_set(children, "@server", rb_iv_get(self, "@server"));
+	return children;
+}
+
+
+void Init_children() {
+
+	rb_define_method(cNode, "children", VALUEFUNC(wiretap_node_children), 0);
+	cNodeChildren = rb_define_class_under(mWiretap, "NodeChildren", rb_cObject);
+	rb_define_method(cNodeChildren, "count", VALUEFUNC(wiretap_node_children_count), 0);
+	rb_define_method(cNodeChildren, "[]", VALUEFUNC(wiretap_node_children_get_at), 1);
+	rb_define_method(cNodeChildren, "each", VALUEFUNC(wiretap_node_children_each), 0);
+	
+}
+
+

data/ext/nodeframes.cpp

@@ -0,0 +1,233 @@
+#include "wiretap.h"
+
+#define NODERUN_E_FRAME(node, x) {if(!x) { \
+	frame.release(); \
+	rb_raise(eError, "Problem in wiretap: %s. File: %s: %d", node->lastError(), __FILE__, __LINE__); \
+}}
+
+/*
+ * Get frames count of clip
+ */
+static VALUE wiretap_node_frames_count(VALUE self) {
+	WireTapNodeHandle* node;
+	int num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->getNumFrames(num));
+	return INT2FIX(num);
+}
+
+/*
+ * Set frames count in clip
+ */
+static VALUE wiretap_node_frames_set_count(VALUE self, VALUE value) {
+	VALUE count = rb_funcall(value, rb_intern("to_i"), 0);
+
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->setNumFrames(NUM2INT(count)));
+	return count;
+}
+
+/*
+ * Get frame by index.
+ */
+static VALUE wiretap_node_frames_get_at(VALUE self, VALUE index) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	Check_Type(index, T_FIXNUM);
+	WireTapClipFormat format;
+	RUN(node->getClipFormat(format));
+
+	VALUE frame = rb_str_buf_new(format.frameBufferSize());
+	RSTRING(frame)->len = format.frameBufferSize();
+
+	NODERUN_E(node, node->readFrame(FIX2INT(index), STR(frame), LEN(frame)));
+
+	return frame;
+}
+
+/*
+ * Set frame at index. Accepts the formatted Stone image buffer as value.
+ */
+static VALUE wiretap_node_frames_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->writeFrame(FIX2INT(index), CSTR(value), LEN(value)));
+	return self;
+}
+
+/*
+ * Eval block on each frame
+ */
+static VALUE wiretap_node_frames_each(VALUE self) {
+	WireTapNodeHandle* node;
+	int i, num;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	RUN(node->getNumFrames(num));
+
+	WireTapClipFormat format;
+	RUN(node->getClipFormat(format));
+
+	for(i = 0; i < num; i++) {
+		VALUE frame = rb_str_buf_new(format.frameBufferSize());
+		RSTRING(frame)->len = format.frameBufferSize();
+
+		RUN(node->readFrame(i, STR(frame), LEN(frame)));
+		//rb_iv_set(frame, "@path", wiretap_node_frames_get_path_at(self, INT2FIX(i)));
+		rb_yield(frame);
+	}
+	return self;
+}
+
+/*
+ * Get path of frame at index
+ */
+static VALUE wiretap_node_frames_get_path_at(VALUE self, VALUE index) {
+	WireTapNodeHandle* node;
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	
+	Check_Type(index, T_FIXNUM);
+
+	WireTapStr path;
+	RUN(node->getFrameIdPath(FIX2INT(index), path));
+
+	return wiretap_to_str(path);
+}
+
+
+static void frame_prepare(VALUE self, WireTapNodeHandle** node, unsigned long* size, WireTapClipFormat** format) {
+	VALUE r_node = rb_iv_get(self, "@node");
+	VALUE r_format = rb_funcall(r_node, rb_intern("format"), 0);
+
+	WireTapNodeHandle* real_node;
+	Data_Get_Struct(self, WireTapNodeHandle, real_node);
+	*node = real_node;
+
+	WireTapClipFormat* real_format;
+	Data_Get_Struct(r_format, WireTapClipFormat, real_format);
+	*format = real_format;
+
+	*size = real_format->frameBufferSize();
+}
+
+/*
+ * Dump all frames into files, matched by pattern.
+ *      @clip.frames.dump_all("/tmp/clip/%d.sgi")
+ *
+ * It is substituted via snprintf
+ */
+static VALUE wiretap_node_frame_dump_all(VALUE self, VALUE file_pattern) {
+	WireTapNodeHandle* node;
+	unsigned long size;
+	WireTapClipFormat* format;
+	frame_prepare(self, &node, &size, &format);
+
+	int frame_count = NUM2INT(rb_funcall(self, rb_intern("count"), 0));
+	std::auto_ptr<unsigned char> frame(new unsigned char[size]);
+	for(int i = 0; i < frame_count; i++) {
+		NODERUN_E_FRAME(node, node->readFrame(i, frame.get(), size));
+		size_t buffer_size = PATH_MAX;
+		char file_name[buffer_size];
+		snprintf(file_name, buffer_size, STR(file_pattern), i);
+		wiretap_write_image_frame(format->width(), format->height(), format->bitsPerPixel(), frame.get(), file_name);
+	}
+
+	return self;
+}
+
+/*
+ * Dump one frame to file
+ */
+static VALUE wiretap_node_frame_dump(VALUE self, VALUE index, VALUE file) {
+	WireTapNodeHandle* node;
+	unsigned long size;
+	WireTapClipFormat* format;
+	frame_prepare(self, &node, &size, &format);
+
+	std::auto_ptr<unsigned char> frame(new unsigned char[size]);
+	NODERUN_E_FRAME(node, node->readFrame(NUM2INT(index), frame.get(), size));
+
+	wiretap_write_image_frame(format->width(), format->height(), format->bitsPerPixel(), frame.get(), CSTR(file));
+	return self;
+}
+
+/*
+ * Read one frame from a PPM file. If this is the first frame (index 0) and the clip has no frames yet one frame will be allocated.
+ * You cannot change the number of frames afterwards.
+ * THIS METHOD SHOULD BE PRIVATE DAMN!
+ */
+static VALUE wiretap_node_frame_write_from_file(VALUE self, VALUE index, VALUE filename) {
+	WireTapNodeHandle* node;
+	WireTapClipFormat format;
+
+	Data_Get_Struct(self, WireTapNodeHandle, node);
+	NODERUN_E(node, node->getClipFormat(format));
+
+	unsigned int bufSize = format.frameBufferSize();
+	std::auto_ptr<unsigned char> frame(new unsigned char[bufSize]);
+
+	int i = NUM2INT(index);
+	
+	FILE* infile = fopen(CSTR(filename), "r");
+	if(!infile) {
+		frame.release();
+		THROW("Couldn't open file %s for reading", filename);
+	}
+	
+	if(!ppm_read_format(infile, &format)) {
+		frame.release();
+		fclose(infile);
+		THROW("Couldn't read PPM format from file %s", filename);
+	}
+	
+	if(!ppm_read_image(infile, frame.get(), format.width(), format.height(), format.bitsPerPixel())) {
+		frame.release();
+		fclose(infile);
+		THROW("Couldn't read PPM image data from file %s", filename);
+	}
+  
+  fclose(infile);
+  
+	int totalFrms;
+	NODERUN_E_FRAME(node, node->getNumFrames(totalFrms));
+  
+	/* Edge case - If we are setting the first frame and the clip has no frames */
+	if ((totalFrms == i) && (i == 0)) {
+	  NODERUN_E_FRAME(node, node->setNumFrames(i+1)); /* wiretapd will crash on setNumFrames(0) */
+	} else if (i >= totalFrms) {
+	  /* Edge case - trying to add a frame to a clip after the fact will crash wiretapd */
+	  frame.release();
+	  THROW("You cannot add frames to an existing clip");
+	}
+
+	NODERUN_E_FRAME(node, node->writeFrame(i, frame.get(), bufSize));
+	return self;
+}
+
+
+void Init_nodeframes() {
+	
+	cNodeFrames = rb_define_class_under(mWiretap, "NodeFrames", rb_cObject);
+
+	rb_define_method(cNodeFrames, "count", VALUEFUNC(wiretap_node_frames_count), 0);
+	rb_define_method(cNodeFrames, "count=", VALUEFUNC(wiretap_node_frames_set_count), 1);
+	rb_define_method(cNodeFrames, "[]", VALUEFUNC(wiretap_node_frames_get_at), 1);
+	rb_define_method(cNodeFrames, "[]=", VALUEFUNC(wiretap_node_frames_set_at), 2);
+	rb_define_method(cNodeFrames, "path_at", VALUEFUNC(wiretap_node_frames_get_path_at), 1);
+	rb_define_method(cNodeFrames, "each", VALUEFUNC(wiretap_node_frames_each), 0);
+
+	rb_define_method(cNodeFrames, "dump", VALUEFUNC(wiretap_node_frame_dump), 2);
+	rb_define_method(cNodeFrames, "dump_all", VALUEFUNC(wiretap_node_frame_dump_all), 1);
+
+	rb_define_method(cNodeFrames, "write_from_file", VALUEFUNC(wiretap_node_frame_write_from_file), 2);
+
+	cAudioFrames = rb_define_class_under(mWiretap, "AudioFrames", cNodeFrames);
+	rb_define_method(cAudioFrames, "dump", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cAudioFrames, "read", VALUEFUNC(wiretap_false), -1);
+	rb_define_method(cAudioFrames, "dump_all", VALUEFUNC(wiretap_false), -1);
+
+}