diff --git a/lib/opencv.js b/lib/opencv.js
index edd51ec..3eb92e7 100755
--- a/lib/opencv.js
+++ b/lib/opencv.js
@@ -1,157 +1,138 @@
 var Stream = require('stream').Stream
   , Buffers = require('buffers')
   , util = require('util')
-  , path = require('path')
+  , path = require('path');
 
-var bindings = require('./bindings')
-
-var cv = module.exports = {};
-
-cv.__proto__ = bindings;
-/*
-
-# Matrix #
-The matrix is one of opencv's most core datatypes.
-
-*/
+var cv = module.exports = require('./bindings');
+var Matrix = cv.Matrix, VideoCapture = cv.VideoCapture,
+    ImageStream, ImageDataStream, ObjectDetectionStream, VideoStream;
 
 
-var matrix = cv.Matrix.prototype;
+Matrix.prototype.detectObject = function(classifier, opts, cb){
+  var face_cascade;
+  opts = opts || {};
+  cv._detectObjectClassifiers = cv._detectObjectClassifiers || {};
 
-matrix.detectObject = function(classifier, opts, cb){
-	opts = opts || {}
-
-  cv._detectObjectClassifiers = cv._detectObjectClassifiers || {}
-
-  if (cv._detectObjectClassifiers[classifier]){
-    var face_cascade = cv._detectObjectClassifiers[classifier];
-  } else{
-	  var face_cascade = new cv.CascadeClassifier(classifier);
+  if (!(face_cascade = cv._detectObjectClassifiers[classifier])){
+    face_cascade = new cv.CascadeClassifier(classifier);
     cv._detectObjectClassifiers[classifier] = face_cascade;
   }
 
-	face_cascade.detectMultiScale(this, cb, opts.scale, opts.neighbors
-		, opts.min && opts.min[0], opts.min && opts.min[1]);
-}
-
-matrix.inspect = function(){
-	var size = this.size() ? (this.size()[0] + 'x' + this.size()[1]) : '';
-
-	return "[Matrix " + size + " ]";
-
-}
-
-cv.ImageDataStream = function(){
-	this.data = Buffers([])
-	this.writable = true
-}
-
-util.inherits(cv.ImageDataStream, Stream);
-var imagedatastream = cv.ImageDataStream.prototype;
-
-imagedatastream.write = function(buf){
-	this.data.push(buf)
-	return true;
+  face_cascade.detectMultiScale(this, cb, opts.scale, opts.neighbors
+    , opts.min && opts.min[0], opts.min && opts.min[1]);
 }
 
 
-imagedatastream.end = function(b){
-	var self = this;
-
-	if (b)
-	  imagestream.write.call(this,b);
-
-	var buf = this.data.toBuffer();
-
-	cv.readImage(buf, function(err, im){
-	  self.emit('load', im);
-	});
+Matrix.prototype.inspect = function(){
+  var size = (this.size()||[]).join('x');
+  return "[ Matrix " + size + " ]";
 }
 
 
-
+ImageStream =
 cv.ImageStream = function(){
-	this.writable = true
+  this.writable = true;
+}
+util.inherits(ImageStream, Stream);
+
+
+ImageStream.prototype.write = function(buf){
+  var self = this;
+  cv.readImage(buf, function(err, matrix){
+    if (err) return self.emit('error', err);
+    self.emit('data', matrix);
+  });
 }
 
-util.inherits(cv.ImageStream, Stream);
-var imagestream = cv.ImageStream.prototype;
 
-imagestream.write = function(buf){
-	var self = this;
-	cv.readImage(buf, function(err, matrix){
-	  self.emit('data', matrix);
-	});
+ImageDataStream =
+cv.ImageDataStream = function(){
+  this.data = Buffers([]);
+  this.writable = true;
+}
+util.inherits(ImageDataStream, Stream);
+
+
+ImageDataStream.prototype.write = function(buf){
+  this.data.push(buf);
+  return true;
 }
 
-// Object detect stream
+
+ImageDataStream.prototype.end = function(b){
+  var self = this;
+  if (b) ImageStream.prototype.write.call(this, b);
+
+  var buf = this.data.toBuffer();
+  cv.readImage(buf, function(err, im){
+    if (err) return self.emit('error', err);
+    self.emit('load', im);
+  });
+}
+
+
+ObjectDetectionStream =
 cv.ObjectDetectionStream = function(cascade, opts){
   this.classifier = new cv.CascadeClassifier(cascade);
-  this.opts = opts || {}
+  this.opts = opts || {};
   this.readable = true;
   this.writable = true;
 }
+util.inherits(ObjectDetectionStream, Stream);
 
-util.inherits(cv.ObjectDetectionStream, Stream);
-var ods = cv.ObjectDetectionStream.prototype;
 
-ods.write = function(m){
+ObjectDetectionStream.prototype.write = function(m){
   var self = this;
-
-	this.classifier.detectMultiScale(m,
-      function(e, objs){
-        if (e) { throw e }
-        self.emit('data', objs, m);
-      }
-    , this.opts.scale, this.opts.neighbors
-	  , this.opts.min && this.opts.min[0], this.opts.min && this.opts.min[1]);
+  this.classifier.detectMultiScale(m, function(err, objs){
+    if (err) return self.emit('error', err);
+    self.emit('data', objs, m);
+  }
+  , this.opts.scale
+  , this.opts.neighbors
+  , this.opts.min && this.opts.min[0]
+  , this.opts.min && this.opts.min[1]);
 }
 
-// == Video Stream ==
+
+VideoStream =
 cv.VideoStream = function(src){
-  if (src instanceof cv.VideoCapture){
-    this.video = src
-  } else {
-    this.video = new cv.VideoCapture(src);
-  }
+  if (!(src instanceof VideoCapture)) src = new VideoCapture(src);
+  this.video = src;
   this.readable = true;
   this.paused = false;
 }
+util.inherits(VideoStream, Stream);
 
-util.inherits(cv.VideoStream, Stream);
-var videostream = cv.VideoStream.prototype;
-cv.VideoCapture.prototype.toStream = function(){
-  return new cv.VideoStream(this);
-}
 
-videostream.read = function(){
+VideoStream.prototype.read = function(){
   var self = this;
-
   var frame = function(){
     self.video.read(function(err, mat){
-      self.emit('data', mat)
-      if (!self.paused){
-        process.nextTick(frame)
-      }
-
+      if (err) return self.emit('error', err);
+      self.emit('data', mat);
+      if (!self.paused) process.nextTick(frame);
     })
   }
 
   frame();
 }
 
-videostream.pause = function(){
-  this.paused = true
+
+VideoStream.prototype.pause = function(){
+  this.paused = true;
 }
 
-videostream.resume = function(){
-  this.paused = false
-  this.read()
+
+VideoStream.prototype.resume = function(){
+  this.paused = false;
+  this.read();
 }
 
 
+VideoCapture.prototype.toStream = function(){
+  return new VideoStream(this);
+}
+
 
 // Provide cascade data for faces etc.
 cv.FACE_CASCADE = path.resolve(__dirname, '../data/haarcascade_frontalface_alt.xml')
-
-